This article provides a comprehensive guide to upgrading Spring Boot to version 2.7, detailing common issues such as missing dependencies, logging conflicts, circular bean references, Swagger configuration changes, Flyway compatibility, JUnit version mismatches, and JSON Long precision loss, along with concrete code‑based solutions.
This article explains how Java developers can use Maven’s dependency‑management features to create a centralized version‑control system that unifies third‑party library versions across multiple modules and services, reducing upgrade pain, avoiding version conflicts, and establishing a solid foundation for scalable backend architecture.
This tutorial provides a complete, code‑rich example of integrating Dubbo with Nacos using Spring Boot, covering environment setup, Maven project structure, module creation, configuration files, Java source code, and testing the RPC service call.
This guide explains how to reduce Spring Boot jar size by separating third‑party dependencies from business code, configure Maven for dependency splitting, use Jenkins to detect changes via MD5 checks, and deploy the resulting packages through SSH or Docker‑based pipelines.
The Taobao User Operations Platform team reduced CI unit‑test time from fifty minutes to ten by configuring Maven Surefire to reuse forks, use a fork count of twice the CPU cores, and run methods in parallel with an appropriate thread count, achieving faster builds while keeping failure rates low.
This guide explains how to download JDK, Maven, Scala and Spark 3.3.0, modify the Spark pom and configuration files for CDH 6.3.2, compile Spark with Maven, deploy the binaries to a client node, set up spark‑sql and spark‑submit scripts, and address common runtime issues.
This article explains why a Spring Boot application that runs fine in an IDE may throw NoSuchMethodError or NoSuchFieldError when packaged as an executable jar, and provides systematic steps—including JVM class‑loading flags, Maven enforcer rules, and class‑path inspection—to locate and resolve the root cause.
This guide walks you through creating XEChat‑Idea, a Netty‑based instant messaging and game‑battle plugin for IntelliJ IDEA, covering project structure, environment setup, build commands, server deployment, plugin configuration, packaging, and installation steps.
This guide shows two reliable Maven techniques—using the versions-maven-plugin and a placeholder with the flatten-maven-plugin—to safely update version numbers across dozens of modules without manual errors or risky global replacements.
This guide walks through installing Docker and Jenkins on CentOS 7, configuring Jenkins with necessary plugins, setting up Maven, creating a Jenkins pipeline to pull, build, and containerize a Spring Boot project, and finally testing and running the application automatically, providing a complete one‑click CI/CD solution.
This tutorial walks through creating a Netty‑based WebSocket server in Java, adding Maven dependencies, integrating it with a SpringBootApplication, implementing server and channel handlers, crafting a simple HTML client, and extending the setup to support URL parameters, complete with code examples and screenshots.
This article introduces the AlanPOI library for Java, detailing its lightweight Maven dependency, core import features, advantages over raw POI, configuration via XML, implementation of the ExcelConsumeInterface, and versatile export capabilities with code examples and advanced usage patterns.
This article introduces XEChat‑Idea, a Netty‑based instant messaging and game‑battle plugin for IntelliJ IDEA, detailing its features, project structure, required environment, step‑by‑step build, run and deployment instructions for both the server and the IDEA plugin, and how to install it locally.
This article explains how to obtain a user's IP address from an HttpServletRequest, introduces the ip2region offline IP‑location library, demonstrates Maven integration and multiple Java query implementations—including file‑only, vector‑index, and full‑memory caching—while providing benchmark and testing instructions.
This guide walks you through installing the XEChat IDEA plugin, using its instant‑messaging and game features, deploying the Netty‑based server with Maven, and exploring the source code to understand its architecture and command‑line interactions.
Gradle offers a modern, flexible alternative to Maven for Java projects, with faster builds, concise Groovy scripts, powerful dependency scopes, easy installation via binaries, package managers, or the Gradle Wrapper, plus configurable mirrors and proxy settings, making it ideal for backend development workflows.
This guide walks you through installing, using, and deploying a Netty‑based instant messaging and game plugin for IntelliJ IDEA, covering setup steps, chat commands, game play, server deployment with Maven, and how to explore its source code for learning.
This tutorial explains how to obtain a user's IP address from an HttpServletRequest, interpret the IP using the ip2region offline database, and display the corresponding province or country in a Java backend application, including code examples and Maven integration.
Gradle offers a faster, more flexible alternative to Maven for Java projects, with simple installation options, wrapper support, concise dependency syntax, powerful task scripting, easy mirror configuration, and superior performance, making it essential for modern backend development.
This article explains Spring Boot’s auto‑configuration mechanism, focusing on how the spring‑boot‑autoconfigure module automatically sets up the embedded Tomcat server, detailing the relevant Maven dependencies, configuration classes, conditional annotations, and the lifecycle steps that create and start the Tomcat container.
COLA (Clean Object‑Oriented & Layered Architecture) is Alibaba’s open‑source framework that defines a structured, layered approach to reduce system entropy, offering both an architectural guide and a suite of reusable components—plus Maven archetypes and step‑by‑step commands to quickly generate and run a functional backend service.
This guide explains how to identify the cause of a Maven compilation AssertionError by enabling debug logging, examining stack traces, and configuring the Maven Compiler Plugin to force the use of the javac compiler for more detailed error information.
This article provides a comprehensive tutorial on implementing Single Sign‑On using the open‑source CAS solution, covering the concepts of SSO and CAS, required development environment, server‑side deployment, client integration with Spring Boot, configuration details, and a complete end‑to‑end testing workflow.
This guide explains how to configure Maven profiles and the assembly plugin to create a zip package for a Spring Boot application, then use a reusable shell script to unzip, start, stop, and restart the service on Linux, streamlining deployment across multiple environments.
This article explains how to package a Spring Boot application using Maven profiles and the maven‑assembly‑plugin, generate a zip release, and deploy it on Linux with a reusable shell script that handles unzip, start, stop, and restart operations.
This article introduces the AJ-Captcha library, explains its sliding‑puzzle and click‑based behavior verification types, and provides a step‑by‑step guide with Maven configuration, front‑end integration code, and Spring Boot backend verification to replace traditional graphic captchas.
This guide demonstrates how to configure Maven profiles for different environments, use the Maven assembly and jar plugins to create a zip package of a Spring Boot application, and deploy and manage the service on Linux using a custom shell script called shenniu_publish.sh.
This article introduces Java Microbenchmark Harness (JMH), explains why warm‑up is needed, walks through project setup with Maven, demonstrates benchmark code for LinkedList iteration, details common JMH annotations, shows how to run and interpret results, and concludes with practical usage tips, while also mentioning a promotional book giveaway.
This article explains how to use Maven profiles and the maven‑assembly‑plugin to create environment‑specific Spring Boot zip packages, configure the accompanying assembly.xml, and deploy them on Linux with a custom shenniu_publish.sh script that supports unzip, start, stop and restart operations.
This guide introduces FastJSON 2.0—a high‑performance JSON/JSONB library for Java—covers Maven configuration, key classes and methods, how to serialize and deserialize Java objects, and demonstrates powerful JSONPath queries for partial data extraction.
This article introduces FastJSON 2.0, explains how to add the Maven dependency, outlines the main classes and methods for JSON, JSONB, and JSONPath, and provides code examples for serializing and deserializing Java objects as well as partial parsing with JSONPath.
This guide explains how to start Maven in debug mode, configure a remote debugger to connect on port 8000, and perform step‑by‑step debugging of Maven builds, including the necessary command line and IDE settings.
The article explains why a Spring Cloud project upgraded from Java 8 to Java 11 gets stuck during Maven compilation, shows how to enable detailed compiler logs with Maven‑compiler‑plugin settings, presents the lengthy compilation output, and advises cautious use of Lombok’s @Builder.Default to avoid similar hangs.
This guide walks you through setting up a basic Java gRPC project by outlining required Maven dependencies, creating the .proto SDK, implementing a server with a custom service, building a client stub, and running a test to verify the end‑to‑end RPC call.
This article explains how Java annotations can be leveraged not only at runtime via reflection but also during compilation by creating custom annotation processors, illustrating the definition of an annotation, implementing a processor, configuring SPI, and demonstrating error handling with Maven.
This article explains how to use Spring Boot to add WebSocket support, covering the protocol basics, Maven dependencies, configuration classes, a test controller, a simple HTML client page, and troubleshooting tips, all illustrated with complete Java and JavaScript code examples.
This article explains how to add SpringBoot DevTools for hot deployment, integrate Lombok to simplify JavaBean code, and configure the Spring Configuration Processor for property metadata, providing step‑by‑step instructions, IDE settings, and Maven dependency snippets for a smoother development experience.
This step‑by‑step guide shows how to configure JDK 1.8 and Maven 3.6.2, create a new Spring Boot project in IntelliJ IDEA using Spring Initializr, examine the generated pom.xml, add a simple HelloController, and verify that the application runs successfully.
This article chronicles the history of front‑end engineering—from the early stone‑age JSP/PHP era through Maven, Grunt, Webpack, and Snowpack—highlighting key tools, code examples, and future trends that have shaped modern front‑end development practices.
This guide walks you through creating a KubeSphere DevOps project, configuring Jenkins pipelines, pulling code, compiling Java with Maven, building Docker images, tagging and pushing them to a registry, and deploying the application, complete with screenshots and step‑by‑step instructions.
When generating Maven projects with the archetype plugin, developers often encounter long waits or failures; this guide explains four practical solutions—including adding the internal catalog parameter, setting VM options, using a local archetype‑catalog.xml, and configuring Maven mirrors—to accelerate project creation and avoid errors.
This comprehensive tutorial explains why Maven is essential for Java projects, walks through installation, project structure, common commands, repository management, dependency scopes, lifecycle phases, Eclipse integration, and advanced features, providing code examples and visual diagrams for clear understanding.
The article sarcastically critiques the over‑engineered nature of enterprise Java projects, illustrating how simple tasks become tangled in excessive classes, interfaces, factories, dependency‑injection frameworks, XML configurations, massive JARs, and IDE bloat, ultimately leading to deployment failures due to environment mismatches.
Despite limited online resources, this article presents a comprehensive collection of over 60 JavaFX utilities, setup instructions, and examples—including QR code generation, character escaping, and PDF conversion—to help developers quickly build and debug GUI applications.
This article walks through installing Jenkins, preparing the environment with JDK, Git, and Maven, configuring Jenkins plugins and a freestyle job, defining build parameters and shell scripts to clone a Gitee repository, build a Spring Boot jar with Maven, stop any running instance, and start the new application, followed by troubleshooting tips and a final summary.
This guide explains why Maven archetype project creation often hangs or fails, and provides four practical solutions—including adding internal catalog parameters, configuring VM options, preparing a local archetype‑catalog.xml, and setting an Alibaba mirror—to speed up builds and avoid errors.
This guide walks through setting up Jenkins to clone a Gitee repository, configure Maven and Git plugins, define a parameterized freestyle job, and use shell scripts to build and launch a Spring Boot application, including troubleshooting steps for Maven path issues.
This article introduces Java Microbenchmark Harness (JMH), explains why warm‑up is needed, shows how to build a benchmark project with Maven, provides a complete LinkedList iteration benchmark example with all relevant JMH annotations, demonstrates execution commands, and interprets the resulting performance reports.
Apache Flink 1.13.6, the latest patch release, addresses 99 bugs and vulnerabilities, upgrades Log4j to 2.17.1, provides new Maven dependencies, and introduces numerous fixes and enhancements across SQL, checkpointing, state backend, and Kubernetes integration, urging users to upgrade promptly.
This article provides a step‑by‑step tutorial for installing, configuring, and running a JVM monitoring solution that integrates with Spring Boot, covering repository cloning, server configuration, Maven installation, application property setup, and accessing the monitor server UI.
This article explains how Spring Boot's spring-boot-maven-plugin creates an executable JAR, describes the internal structure and Manifest, details the role of JarLauncher and the custom LaunchedURLClassLoader, and provides concrete code examples for class loading and execution.
This article explains how to enable SpringBoot DevTools for hot deployment, integrate Lombok to simplify JavaBean code, and add the Spring Configuration Processor to provide property‑binding assistance, including Maven dependency snippets and IDE configuration steps for a smoother development experience.
This article introduces how to enable SpringBoot DevTools for hot deployment, integrate Lombok to reduce boilerplate code, and use the Spring Configuration Processor for property binding hints, providing Maven dependencies, IDE settings, and example code snippets for Java backend development.
This article provides a detailed step‑by‑step guide to Maven, covering why to use it, its core concepts, installation, creating a first project, repository coordinates, dependency scopes, lifecycle phases, Eclipse integration, advanced dependency features, and build configuration with code examples.
This guide compiles the most useful Maven commands and IDE tips for creating, building, packaging, and deploying multi‑module Java projects, covering project structure, command syntax, advanced combinations, and IntelliJ IDEA integrations.
This article examines Spring Boot 3’s migration to Java 17, the adoption of Spring 6, updated Maven and Gradle versions, the move to Jakarta EE 9, removal of legacy components, and practical advice on when and how to upgrade your backend applications.
An in‑depth comparison of Maven, Gradle, and the Maven Daemon (mvnd) examines their features, configuration differences, and real‑world build performance on Spring Boot projects, revealing that Gradle delivers the fastest packaging times while offering simpler, more readable build scripts.
The article details how a business‑oriented company built an architecture committee, secured leadership support, defined clear design principles, restructured a monolithic common package into modular base projects, and used concrete case studies and team‑wide promotion to successfully evolve its technical architecture.
This article introduces Maven‑mvnd, an Apache‑backed, GraalVM‑powered Maven alternative that speeds up Java builds through daemon processes and JVM optimizations, explains its installation (including Homebrew on macOS and JDK version considerations), demonstrates usage, and discusses performance benefits and known issues.
This article discusses the challenges of incompatible Jar version conflicts in Java projects, explores classloader isolation approaches like Pandora and SOFAArk, and provides a step‑by‑step guide to using the Maven Shade Plugin to relocate and package conflicting Guava libraries into a custom wrapper jar.
The article explains Maven Central's new "Vulnerabilities" column that highlights known CVEs for each dependency, discusses its relevance to recent Log4j2 risks, and shows how to use the OWASP Dependency‑Check Maven plugin to scan and report vulnerable Java libraries.
This article introduces Maven MVND, a native build daemon that embeds Maven for faster builds, outlines its key features, shows how to download and install version 0.7.1, demonstrates equivalent Maven commands using mvnd, and discusses its current performance and production readiness.
This article provides a detailed, step‑by‑step guide to Maven, covering why to use it, its core concepts, installation, project structure, pom.xml configuration, common commands, dependency scopes, repository handling, lifecycle phases, Eclipse setup, advanced features, and build customization for Java backend development.
The article introduces mvnd, a GraalVM‑based Maven daemon that accelerates builds by reusing processes, leveraging JIT compilation, and supporting parallel execution, then details installation across Linux, macOS and Windows, configuration tips, and usage commands, showing how it narrows the performance gap with Gradle.
This guide explains how Maven projects can detect, visualize, and resolve hidden dependency conflicts by using tools like mvn dependency:tree, understanding transitivity and the nearest‑wins rule, applying dependencyManagement, scopes, exclusions, optional dependencies, and best practices such as regular analysis and shading to prevent runtime errors.
This article introduces mvnd, a GraalVM‑based Maven daemon that runs as a persistent build service, explains how it achieves faster startup and parallel builds, and provides step‑by‑step installation, configuration, and usage instructions for Windows, macOS, and Linux.
The article explains how incompatible JAR versions, such as differing Guava releases required by business code and middleware, can be resolved efficiently by using Maven Shade Plugin to relocate packages, offering a lightweight alternative to heavyweight class‑loader isolation solutions like Pandora or SOFAArk.
This guide walks through installing Jenkins and Nexus Repository Manager with Docker, configuring a Maven hosted repository, adding Nexus credentials and Maven tools in Jenkins, and creating a Jenkins pipeline that builds a Java project and publishes its artifacts to Nexus, illustrating a complete CI/CD workflow.
This guide shows how to package a Spring Boot application using Maven profiles and the maven-assembly-plugin, create a zip release that includes configuration files, the compiled jar and a custom deployment script, and then use the script to unzip, start, stop, and restart the service on Linux.
This guide explains step‑by‑step how to upgrade Log4j2 to the secure 2.16.0 version in Spring Boot applications by adjusting Maven configurations, understanding parent POM inheritance, and overriding properties, ensuring a fast and reliable fix for the critical vulnerability.
After upgrading IntelliJ IDEA to version 2021.3, Maven 3.8.1 blocks HTTP repositories by default, causing private‑repo download failures, but you can resolve the issue by adjusting the Maven settings or switching to HTTPS.
This article explains why multiple Java logging frameworks often clash in SpringBoot and Dubbo applications, identifies common causes such as transitive dependencies and duplicate versions, and provides step‑by‑step Maven configurations and adaptation techniques to unify logging with SLF4J and Logback.
This article explores using Byte Buddy to build Java agents, detailing the premain method, class loading mechanisms, handling dependency conflicts with Maven shade versus custom classloaders, and implementing a Dispatcher to bridge agent and application classloaders, providing practical code snippets and diagrams for each step.
This guide explains how to separate unit and integration tests in a Maven project, configure the Build Helper and Failsafe plugins, set up JaCoCo to generate combined coverage reports, and visualize them in SonarQube, including a complete example pom.xml.
Spring Boot 2.6.0 arrives with a host of new features—including default circular‑reference protection, SameSite cookie support, reactive session enhancements, custom sanitizing rules, endpoint changes, Redis pool options, WebTestClient testing, Log4j2 composite configuration, numerous dependency upgrades, and several deprecations—plus updated Maven coordinates and version timelines for developers to consider before upgrading.
This tutorial walks through installing Docker, configuring remote access, creating a Spring Boot project with Maven, adding Docker support via plugins, writing Dockerfile and application code, building the image, and running the container, demonstrating a complete end‑to‑end deployment workflow.
This tutorial walks through setting up a Spring Boot and MyBatis multi‑module project in IntelliJ IDEA, covering environment preparation, directory layout, parent and child module creation, Maven dependency configuration, bean scanning, MyBatis integration, and verification of the running application.
This article provides a detailed overview of Maven, covering its purpose, core concepts such as coordinates and repositories, the build lifecycle phases, as well as dependency declarations and scopes, as well as plugin configuration, custom bindings, and advanced features like aggregation, inheritance, and profile-based builds.
This guide walks through creating a SpringBoot and MyBatis multi‑module project in IntelliJ IDEA, covering environment setup, parent and child module creation, dependency configuration, bean scanning, MyBatis integration, and troubleshooting common startup errors, culminating in a runnable demo endpoint.
This tutorial walks through setting up a SpringBoot‑based multi‑module Maven project with MyBatis integration in IntelliJ IDEA, covering environment preparation, parent and child module creation, dependency configuration, package scanning, and verification of a simple REST endpoint, while highlighting common pitfalls and solutions.
This tutorial shows how to replace Swagger with smart-doc, a zero‑annotation API documentation tool for SpringBoot that generates HTML docs and Postman collections, covering Maven plugin setup, configuration files, custom tags, error‑code mapping, request‑header definitions, and step‑by‑step usage examples.
This article provides a step‑by‑step DevOps tutorial covering Docker fundamentals, Jenkins pipeline setup, GitLab integration, Maven builds, SpringBoot configuration, multi‑machine remote deployment scripts, and practical tips for automating containerized applications.
This article provides an English overview of Spring Boot’s core functionalities—including standalone JAR execution, embedded servlet containers, starter POM simplification, auto‑configuration, production‑ready monitoring, and code‑free XML—while also discussing its pros and cons, key features, CLI tool, Maven parent, and commonly used annotations.
This article explains Maven's repository types, dependency declarations, version handling, conflict resolution strategies, best practices for early detection, standard directory layout, lifecycle phases, and scope definitions, providing a comprehensive guide for developers to master Maven in Java projects.
This article analyzes a Maven multi‑module project where a static constant change in a shared API module caused unexpected Redis key errors at runtime due to JDK compile‑time constant folding, outlines the investigation steps, identifies the root cause, and provides best‑practice recommendations for version management.
This guide explains how to store, upload, and retrieve build artifacts using Nexus repository manager through its UI, Maven configuration, Jenkins Nexus Artifact Uploader plugin, custom pipeline functions, and direct REST API calls, including download examples with curl and wget.
This guide introduces SonarLint and SonarQube, explains how to install and configure them for Java projects, demonstrates scanning with Maven, and provides additional resources such as Alibaba Java coding conventions and documentation links, helping developers improve code quality and maintainability.
Learn how Maven’s dependency resolution can cause jar conflicts, recognize common runtime errors like ClassNotFoundException, and use IDE tools, Maven commands, parent POM management, exclusion and version locking techniques to identify and eliminate conflicting jars in Java backend projects.
This article introduces the open‑source MapStruct library for Java, shows how to configure Maven and Lombok, provides step‑by‑step code examples for basic and advanced entity‑to‑DTO mappings—including list conversions, multi‑object mappings, and default values—so developers can replace boilerplate conversion code with clean, type‑safe mappings.
This guide explains how to use the open‑source Screw tool to automatically produce database schema documentation in HTML, Word, or Markdown and to generate Java entity classes, offering step‑by‑step examples with Maven plugin and Java code configurations for MySQL, Oracle, and PostgreSQL.
This article shares a developer’s experience converting a Java Spring Boot microservice to Kotlin, covering why Kotlin is attractive, required Maven plugins and dependencies, code‑migration quirks such as open classes and @Jvm annotations, testing hurdles, and the final decision to revert to Java.
This article introduces the open‑source MapStruct library for Java, showing how to configure Maven dependencies, define entity and DTO classes with Lombok, create mapper interfaces, and perform simple and advanced object conversions such as list mapping, multi‑object merging, and default value handling.
This guide walks through installing OpenOffice on a Windows server, launching its headless service, adding jodconverter dependencies to a Spring Boot project, configuring conversion settings, writing a controller to transform DOC files into HTML, and invoking the endpoint from a Vue front‑end, with troubleshooting tips.
This article introduces three essential code‑quality tools—SonarLint, SonarQube, and the Alibaba code‑convention plugin—explaining their installation, basic usage, integration with Maven, and how they help developers detect code smells, enforce standards, and quantify quality metrics in Java projects.
This article explains how to package a Spring Boot application using Maven profiles and the maven‑assembly‑plugin, generate a zip deployment package, and manage the deployment with a custom shell script that supports unzip, start, stop, and restart operations across different environments.
This article provides a detailed introduction to Maven, covering why to use it, its core concepts, installation steps, project structure, essential commands, dependency management, lifecycle phases, and integration with Eclipse, offering practical code examples and configuration snippets for Java developers.
This article explains Maven’s repository types, dependency declaration, conflict resolution strategies, best‑practice tips, standard directory layout, lifecycle phases, and scope definitions, providing Java developers with the knowledge needed to use Maven confidently in multi‑module projects.
This guide explains how to detect, visualize, and resolve Maven dependency conflicts by using the dependency tree, understanding transitivity and the nearest‑wins rule, managing versions with dependencyManagement, applying scopes, exclusions, and optional flags, and following best practices such as centralizing versions in a parent POM and regularly running analysis tools.
This article details the final updates to the DCS_FunTester distributed testing framework, covering Gradle multi‑module configuration, dependency handling, result aggregation, task dispatch, health‑check endpoints, and registration optimizations with practical code examples in Java and Maven.
This guide explains what Tekton is, outlines its core CRDs, shows how to deploy it on a Kubernetes cluster, and provides a step‑by‑step example that builds, containers, and deploys a Spring Boot application using Maven, Docker, and Tekton pipelines.
