The article explains how JDK 24’s Gatherer API extends Java streams with custom intermediate operations, compares its functionality to Groovy’s rich collection methods, and provides concrete Gatherer implementations for slicing, fixed and sliding windows, folding, and subsequence detection, complete with runnable code examples.
This article explains why frequent business‑rule changes hurt backend release cycles, compares rule engines with Groovy dynamic scripts, walks through three integration methods, shows a Spring Boot implementation with caching and bean access, and details production pitfalls and best‑practice mitigations.
This article shows how AI can help write Groovy JSR223 scripts that dynamically generate large‑scale, unique, or realistically distributed test data inside JMeter threads, eliminating CSV I/O bottlenecks and improving maintainability for performance testing.
This article outlines how a team tackled long‑standing automation gaps in custom output modules and second‑party packages by introducing a lightweight interception verification system and a Groovy‑Spock data‑driven testing framework, achieving full‑coverage regression in minutes, reducing bug detection time, and boosting overall testing efficiency.
This article introduces four of Spring Boot’s expression engines—Groovy, MVEL, JEXL, and JSP EL—showing how to add their Maven dependencies, run concrete code examples, and provides practical guidance on selecting the right engine based on performance, feature richness, and integration ease.
The article explains why Chengwu low-code platform selected Groovy as its embedded scripting language, detailing requirements for dynamic execution, Java compatibility, sandbox security, and hot reloading, comparing Groovy against Java compilation, Kotlin Script, and JS engines, with concrete examples of flow logic, form validation, API preprocessing, and scheduled tasks.
This page compiles a comprehensive collection of tutorial links and video resources covering Chrome extension development, Java performance testing, interface testing, Groovy scripting, various utility videos, and the Arthas diagnostic tool, providing developers with organized references for learning and practice.
This guide walks you through installing Spring Boot CLI, explains its Groovy‑based features, demonstrates creating and running a Hello World web app, shows how to use @Grab for dependencies, test with spring test, package into executable JARs, and explore init and shell commands.
The author recounts a four‑year journey from UI automation to Java‑based performance testing, illustrating how mastering Java’s concurrency utilities and Groovy scripting can replace traditional tools like JMeter, enabling flexible, high‑throughput test scenarios and deeper control over test case design.
This article introduces GroovyShell, a powerful Groovy tool for runtime script execution, and provides five practical code examples—including basic usage, variable passing, multi‑line scripts, external script loading, and context control—followed by key application scenarios such as rule engines, dynamic configuration, rapid debugging, and data processing.
The article reviews Groovy's evolution from a top‑ranked general‑purpose language to a domain‑specific language, highlighting its key applications, syntax advantages, dynamic typing, and why it now serves best as a DSL despite a stagnant ecosystem.
This article explains how to configure Jenkins to send build results via email, covering the default Mailer plugin setup, testing, and advanced Email Extension plugin usage with default, Groovy, and HTML templates, including pipeline script examples and best practices for reliable notifications.
This article introduces Groovy as a JVM‑based dynamic scripting language, explains why it suits rapidly changing business rules such as payment integration, marketing and risk‑control, and provides step‑by‑step code examples, advanced usage patterns, best practices and common pitfalls for Java backend developers.
This article explains how upgrading Java and Groovy dependencies caused an IllegalAccessException in Caffeine's asynchronous cache due to module encapsulation, and details the attempted fixes including JVM '--add-opens' arguments and dependency version adjustments.
After upgrading to IntelliJ 2023.3 for better JDK 21 virtual‑thread support, users encounter a Groovyc ClassNotFoundError caused by missing IntelliJ internal classes, and the article outlines the affected builds and three practical work‑arounds, including a JVM option to run Groovyc in‑process.
The article describes a Groovy scripting issue where calling StringBuilder.setLength(0) triggers a NoSuchMethodError, explains Groovy's automatic property generation, demonstrates debugging steps, metaprogramming attempts, and the final workaround that resolves the error.
This article explains the Java Runtime addShutdownHook API, its purpose for registering shutdown hooks, typical use cases such as resource cleanup, state saving, and logging, and provides practical Java and Groovy code examples while noting that hook execution order is unspecified.
This article compares a Java + TestNG + HttpClient stack with a Groovy + Spock + RestAssured approach, showing how data‑driven testing, encryption handling, data extraction, and validation can be streamlined for more flexible and efficient API testing.
This tutorial explains how to use Jenkins shared libraries to consolidate repetitive pipeline code, set up Jenkins with Docker Compose, define reusable Groovy methods, create Docker build files, and configure pipeline jobs for maintainable, version‑controlled CI/CD workflows.
This article benchmarks the Groovy 'as' type‑conversion keyword against native Java conversion methods for String‑to‑double, double‑to‑String, and double‑to‑int operations using JMH, revealing that Java's built‑in approaches consistently outperform Groovy's 'as' keyword across various test cases.
This article explains Groovy’s def keyword as a mutable, untyped variable, shows how it differs from Java’s var, demonstrates dynamic reassignment, and provides a practical JSON‑to‑object conversion example that simplifies code while leveraging IntelliJ’s type inference.
This article explains Groovy’s def keyword as a dynamic, mutable type that lets variables change their actual object type at runtime, compares it with Java’s var, and demonstrates practical JSON‑to‑object conversion using def to simplify code.
This article explains how Jenkins shared libraries enable team collaboration by allowing Groovy scripts to be shared and version‑controlled, demonstrates how to call a specific Groovy file and all Groovy files in a directory from build.groovy, and lists the operational benefits of using shared libraries.
This article explains Groovy’s def keyword, showing how it enables optional typing for variables and methods, demonstrates its runtime type inference with code examples, and offers best‑practice guidelines including interactions with explicit types, Java objects, and compile‑time @TypeChecked checks.
This article explains how to use the parallel step and the Groovy collectEntries method in Jenkins Pipelines to run multiple jobs concurrently, reduce build time, and transform collections into maps for flexible stage generation, providing complete code examples and practical guidance.
This article provides an in‑depth tutorial on unit testing using Spock, covering its advantages over JUnit, core concepts like specifications, fixtures, feature methods, data‑driven testing, mock and stub techniques, interaction constraints, and tooling for automated test generation, all illustrated with Groovy and Java code examples.
This tutorial walks through setting up an Elasticsearch server, creating a Java REST client, implementing a custom GET‑with‑body request, building a reusable ESClient wrapper with common CRUD and search methods, and providing Groovy performance test cases for indexing and querying.
This article introduces Groovy as a JVM scripting language, outlines its typical use cases, and provides a detailed, code‑rich tutorial on how to integrate Groovy scripts into a Spring Boot application, including dependency setup, script execution, bean access, and security considerations.
This article explains Gradle's domain‑specific language (DSL), compares Groovy and Kotlin DSL syntax, and introduces Groovy closures with practical code examples, helping developers grasp build script fundamentals and migrate between Groovy and Kotlin Gradle scripts.
This article explains why @RequestBody conflicts with Swagger in Spring Boot, outlines two common but cumbersome work‑arounds, describes a Swagger API timeout caused by Groovy's MetaClass, and provides a concise configuration fix that eliminates both the timeout and the compatibility issue.
This article explains the compatibility challenges between Java functional interfaces and Groovy closures, introduces a utility class that converts Supplier, Function, Predicate, and Consumer into Groovy closures, and provides a complete code example with demonstration and output.
This tutorial explains how to install Spring Boot CLI, demonstrates the project layout, creates a Hello World application using Groovy, shows how to use @Grab for dependencies, run tests, package the app into an executable JAR, and generate new projects with the init command.
This guide demonstrates how to create, add, retrieve, delete, iterate, and filter Groovy Map objects using concise syntax, operator overloading, and built‑in APIs, providing clear code examples that boost testing efficiency compared to traditional Java approaches.
The report analyzes recurring morning Full GC alerts in a Java service, identifies a Groovy‑driven scheduled task as the root cause through JVM parameter review, log inspection, and memory profiling, and proposes concrete fixes such as reusing a single GroovyShell instance and clearing its classloader cache.
This article explains how to invoke other Groovy scripts and all Groovy files within a directory from a build.groovy file, providing concrete example code that demonstrates calling a Print method in hello.groovy and using it inside mytools.groovy.
The article examines the MySQL class com.mysql.cj.jdbc.MysqlConnectionPoolDataSource, revealing that despite its name it creates new connections each request and only recycles idle ones, provides a practical Groovy example, highlights pitfalls such as duplicate setURL methods, and concludes it’s unsuitable as a true pool for testing.
This tutorial explains how to automatically create and delete Jenkins agent pods on a Kubernetes cluster for each pipeline run by storing Groovy scripts in a shared library, loading them with ScriptConsole, and invoking the Kubernetes API through Jenkins.
This article demonstrates how to programmatically create Jenkins agent nodes on demand with Groovy scripts, covering import statements, node configuration, adding the node to Jenkins, and retrieving node details for further automation in a CI/CD pipeline.
This article details a performance evaluation of Apache Commons Pool2 on a MacBook Pro, comparing no‑wait and wait scenarios, presenting QPS results, identifying bottlenecks in LinkedBlockingDeque and AtomicLong, and outlining the test setup, code, and conclusions.
The article explains how repetitive null‑checking code in Java can be simplified using Groovy's safe navigation operator and Java 8's Optional class, providing cleaner and more maintainable ways to prevent NullPointerException when accessing nested object properties.
An in‑depth analysis reveals how Groovy’s implicit getter feature and method‑resolution rules cause a static method call to be intercepted by a subclass’s getTest method, leading to unexpected output and thread locking during performance testing.
The author shares a deep‑dive performance analysis of the FunTester framework, comparing Java and Groovy implementations, detailing JVM tuning, hardware usage, and practical tips that enabled a single Groovy process to sustain 110,000 QPS while outlining when distributed testing and connection‑pool sizing become necessary.
Spock is an open‑source Java/Groovy testing framework that blends JUnit‑style structure with a concise Groovy DSL, offering data‑driven “given‑expect‑where” tests, straightforward mocking and property injection, Maven‑based setup, and seamless PowerMock integration for static‑method mocking, making it a powerful alternative to traditional unit‑test tools.
This article compiles a comprehensive list of Groovy-related tutorials and articles covering Java‑Groovy integration, scripting, Gradle builds, JMeter extensions, operator overloading, closures, reflection, and other advanced language features for developers seeking practical guidance.
The article explains how the author built a Groovy‑based scraper that reads a Markdown list of WeChat links, fetches each article’s HTML, extracts the hidden publication timestamp with a regex, and rewrites the Markdown file to include the dates, using simple HTTP calls and a brief pause to avoid anti‑scraping measures.
This article walks through setting up Spock for Java/Groovy projects, lists required Maven dependencies, shows how to handle static‑method mocking with PowerMock and Mockito, and provides concrete code examples for mocking @Autowired components, shared objects, and defining mock behavior.
The article explains how to create a lightweight custom waiting utility in Java (using Groovy syntax) that repeatedly checks a condition every 0.5 seconds, simplifying thread synchronization for performance testing of multithreaded code.
This article introduces LevelDB, a Google‑open‑source key‑value store, and illustrates four practical use cases—temporary token storage, hidden credential management, stateful Java services, and lightweight historical data archiving, accompanied by Groovy/Java code examples for implementation.
Apache Groovy 4.0.0 RC2 has been announced, featuring language enhancements such as new compilation behavior for operators and method naming, along with extensive upgrades to build, test, and runtime dependencies across the project.
This guide shows how to configure IntelliJ IDEA to automatically insert class and method Javadoc comments using file and code templates and live templates, including custom Groovy scripts for @author, @date, @param, and @return annotations.
This article introduces the fundamentals of Gradle as a universal build automation tool and explains how the Android Gradle Plugin integrates with it, covering project structure, build files, tasks, the three build lifecycle phases, DSL syntax, and provides example Groovy/Kotlin scripts for configuring Android applications.
This article demonstrates how to achieve Java hot‑update without rebuilding by leveraging Groovy's metaclass and GroovyShell, walking through a verification example, a full script implementation, and practical tips for handling script encoding issues.
This article explains what unit testing is, how to implement it with frameworks like Spock, provides a simple Groovy example, and discusses the advantages and drawbacks of unit tests for software development.
This article explains Gradle's fundamentals, compares it with Maven, introduces Groovy's abstract syntax tree (AST) concepts, and provides a step‑by‑step demo that parses a Gradle script into an AST, modifies it to inject a dependency, and attempts to write the changes back to the original build file.
This article introduces Jenkins Pipeline fundamentals, explains stages, nodes, and steps, compares Declarative and Scripted syntaxes, and provides detailed code examples for Windows, Docker, and Git operations to illustrate building, testing, and deploying applications.
This article demonstrates how to dynamically add custom methods to fastjson's JSONObject in Groovy by leveraging MetaClass and closures, providing code examples that simplify JSON traversal and output during API testing for developers.
This article explains how to create a fixed-size Java thread pool, attach a daemon thread that monitors the main thread, and use Phaser for synchronization, providing complete Groovy and Java examples with detailed code and console output.
This article demonstrates how Groovy's MetaClass can be used at runtime to add object methods, static methods, and properties to classes, and includes a complete Spock unit‑test example that verifies dynamic behavior with detailed code snippets and console output.
This article explains how to achieve Go‑style asynchronous execution in Java and Groovy by leveraging closures, the java.util.function.Supplier interface, custom thread‑pool wrappers, and Phaser‑based synchronization, complete with practical code examples and a custom ThreadFactory implementation.
This article compares how Java, Groovy, Python, and Go implement closures and treat functions as parameters, showing concrete syntax for defining single‑parameter, multi‑parameter, and parameter‑less closures, as well as returning and invoking them within methods.
This guide walks Java developers through installing Groovy, using its .groovy files, manipulating lists, maps, conditionals, loops, and leveraging built‑in JsonBuilder and HTTPBuilder for JSON handling and HTTP requests, all with clear code examples.
This article explains Groovy’s default‑parameter feature, shows how to embed scripts and random values in defaults, demonstrates practical API‑testing examples, and compares the execution cost of using default values versus explicit arguments in a high‑iteration performance test.
This article describes the background, requirements, architecture, script language selection, performance testing, and future plans of a rule engine used to send notifications to couriers in Dada Logistics, highlighting the trade‑offs among Groovy, MVEL, SpEL and Aviator.
This guide explains how to install and configure the Jenkins Active Choice Parameter plugin, create Groovy scripts for dynamic build options, debug GitLab API calls with curl or Postman, and implement both basic and optimized Groovy code to retrieve project branches and tags using stored Jenkins credentials.
This tutorial explains how to use Jenkins to integrate command‑line tools and webhooks for automating GitLab branch creation, covering API discovery, Postman testing, pipeline scripting, credential handling, shared library implementation, and final system configuration.
The article presents a comprehensive guide to using the Spock testing framework for Java and Groovy backend development, illustrating its BDD‑style DSL, data‑driven tables, integrated mocking (including static methods via PowerMock), exception verification, in‑memory DAO testing, and enhanced coverage reporting compared to JUnit.
This article explains the recent updates to the DCS_FunTester distributed performance‑testing framework, including Groovy script execution, a new master‑slave registration mechanism, service‑layer extraction, and synchronization logic, while providing concrete Java code examples for each enhancement.
This tutorial walks you through installing Groovy, configuring environment variables, cloning the FunTester repository, building with Gradle, and running a simple hello‑world test case, while also detailing the framework's project structure and essential code snippets.
This article walks through the design, evolution, and technical details of FunTester—a Java/Groovy‑based open‑source testing framework that unifies functional, automated, and performance testing, explains why existing tools like Postman and JMeter fall short, and outlines its distributed testing service and future roadmap.
By adopting Groovy as a JSR‑223 script engine, the Vivo Internet Server team streamlined dynamic query and rule processing in their Java content platform, demonstrating integration via ScriptEngineManager, GroovyShell, and GroovyClassLoader, while optimizing performance through caching and static typing and enforcing security with SecureASTCustomizer and isolated execution.
This guide explains why Jenkins Shared Libraries are essential for reducing repetitive pipeline code in micro‑service projects, walks through creating and configuring a shared library, and demonstrates advanced usage with parameters, multi‑branch pipelines, and environment variable handling.
This article details a practical implementation of a distributed performance testing framework using DCS_FunTester, describing the master‑slave architecture, Docker image setup, Groovy/Java scripts, sample code, console output, and server logs to help engineers replicate the approach.
This article introduces a flexible, script‑driven performance testing approach built on the FunTester framework, explains how to write Groovy/Java test scripts, demonstrates a demo implementation with reflection‑based execution, and covers test case creation, transmission, and execution for HTTP‑based load testing.
This article introduces the FunTester distributed testing framework, explains its single‑node HTTP API, provides complete Java, generic Java, and Groovy code examples, details request parameters, response structure, and the underlying PerformanceResultBean class for analyzing test results.
This article introduces Jenkins shared libraries, explaining their structure, how to create a library with Groovy classes, configure it in Jenkins, and use it in pipelines, including sample code for colored log output and step-by-step setup instructions for DevOps practitioners.
This article details a practical implementation of the FunTester distributed performance testing framework, covering its master‑slave‑server architecture, Docker image creation with a Groovy base, and full code examples for the master scheduler, slave agent, and test server.
This guide walks you through installing the DingTalk and Build User Vars plugins, configuring a DingTalk robot, creating a Groovy shared library, and integrating it into a Jenkins pipeline to automatically push build notifications and change logs to DingTalk.
This article explains how to invoke another Groovy script and all Groovy scripts in a directory from a build.groovy file, providing clear example code that demonstrates defining a method in one script and calling it from another within a DevOps automation context.
This article explains how to work around Groovy's invokeMethod limitation of accepting only a single Object argument by using String arrays or var‑args, demonstrates Java and Groovy reflection implementations, and provides complete code examples for multi‑parameter performance test scripts.
This article experimentally examines how different sources of performance‑test error—fixed versus random request latency, thread‑count variations, and log‑printing overhead—affect QPS calculations, revealing that higher concurrency amplifies error while increased request repetitions and reduced logging improve measurement accuracy.
This article explains how to extend a performance testing framework to record and visualize individual HTTP interface latencies by parsing consolidated logs, grouping timings by URL, and using a Groovy script with StatisticsUtil to generate response‑time charts.
This article demonstrates a Groovy script that extracts QR‑code image URLs from a web page using regular expressions, then downloads each image to a local directory, illustrating practical web‑scraping techniques and reusable utility methods for HTTP requests and file handling.
This article presents practical Java and Groovy code snippets for downloading images from URLs, explains a concise Groovy one‑liner, and introduces a helper method that cleans and extracts filenames, illustrating Groovy tuple usage for storing URL‑name pairs.
Yidun’s public-opinion monitoring platform transforms massive raw web data into a unified format by separating dynamic Groovy-script-driven cleaning from static processing, achieving real-time source integration, high throughput, scalability, and high availability while addressing format diversity, team coordination, and performance-flexibility trade-offs.
This tutorial walks you through setting up Jenkins with Docker, exploring built‑in and custom pipeline environment variables, overriding rules, Boolean handling, and capturing shell command output, providing practical code examples for each step.
This guide explains how to automate the creation of Jenkins pipeline jobs by generating Job DSL templates, converting them to XML via an online playground, and applying the Jenkins Core API or Script Console to create or update jobs programmatically.
The article explains a Groovy runtime initialization error caused by the language treating both double‑quoted and single‑quoted literals as Strings rather than chars, leading to a mismatched enum constructor, and provides a corrected enum definition with explicit char casting to resolve the issue.
This article describes how to automate verification of Socket.IO interfaces using a custom VerifyBean class in Java/Groovy, covering setup, message handling, cross‑validation logic, and includes full source code and sample console output.
This article walks through the design and implementation of a custom JsonPath validation library using Groovy operator overloading, detailing the core enums, verification bean, arithmetic handling, and practical demo code, while providing repository links for Gitee and GitHub.
This article describes how to implement a multi‑interface performance test for the collect and uncollect operations of a teacher’s resource list, using Groovy scripts, a custom FunTester framework, multithreaded request generation, request‑id tracking, and response recording to produce QPS and RT metrics.
Faced with network latency and only a Docker container available, this guide compares two practical ways to run Groovy test scripts—packaging the test class into a JAR and invoking its main method, or using a reflection utility to call methods dynamically—complete with code samples, Maven commands, and execution results.
This guide explains how to use Jenkins pipeline shared libraries to create a flexible DingTalk robot notifier, covering message types, template design, Groovy implementation, and integration into pipeline post‑steps for automated build alerts.
When using SpotBugs' Gradle plugin in a Java project, you may encounter "Cannot compile Groovy files" errors, which can be fixed by adding a Groovy SDK through the IDE's project structure settings.
This article walks through building and executing a Groovy‑based test script that registers two users, joins a room, exchanges chat messages over a Socket (WebSocket) connection, and cleanly closes the sockets, illustrating the full workflow and code structure for backend socket API testing.
This article describes a practical workflow for static testing Java and Groovy code with SpotBugs in IntelliJ, including dependency setup, bug detection, clear versus suppress options, and the syntax for applying @SuppressFBWarnings annotations in both languages.
This guide explains how to install the Active Choices plugin in Jenkins and use Groovy scripts to create dynamic, parameterized build options such as checkboxes, radio buttons, and cascading selections within a Pipeline, including a complete Jenkinsfile example.
This tutorial demonstrates three ways to calculate the average of an integer array—using a classic Java for‑loop, a Java Stream Lambda expression, and Groovy’s built‑in collection methods—complete with code samples and console output.
This tutorial demonstrates step‑by‑step how to obtain the union of two arrays in Java—both primitive and object types—by leveraging a HashSet with addAll, includes full code examples, console output, and a concise Groovy alternative.
The article reflects on the pros and cons of JVM languages—especially Groovy—in team projects, examining readability, writability, IDE support, maintainability issues, and why newer alternatives like Kotlin Script may be more suitable for large‑scale development.