This article explains Java compilation and decompilation basics, introduces the JD‑GUI decompiler, and provides a step‑by‑step guide to protect Java applications by configuring ProGuard and integrating it into a Maven build, including sample configuration files and common pitfalls.
This article examines the benefits of moving from JDK 11 to the long‑term support JDK 17, detailing performance gains—especially sub‑millisecond ZGC pause times—new language features, compatibility considerations, benchmark results, and step‑by‑step migration instructions for Spring‑based applications.
This article introduces Hutool, a comprehensive Java utility library that consolidates common functions such as file handling, encryption, date manipulation, and more, explains its key modules, shows how to add it via Maven, and provides practical code examples for utilities like DateUtil, StrUtil, NumberUtil, and SecureUtil.
This article explains why a Spring Boot application runs with the configured port when packaged as a JAR using the embedded Tomcat, but switches to Tomcat's default port and context path when deployed as a WAR, and provides step‑by‑step instructions to package and deploy both formats along with historical context and technical differences.
This article explains how to use Maven profiles and the maven‑assembly‑plugin to create a zip package for a Spring Boot application, and provides a reusable shell script (shenniu_publish.sh) for deploying, starting, stopping, and managing the service on Linux.
This article explains what unit testing is, why it’s essential, and provides a step‑by‑step guide for writing Java unit tests with JUnit, integrating them into Maven projects, and generating detailed coverage reports using IDE features and JaCoCo.
This article introduces Hutool, a versatile Java utility library that consolidates common functions such as file handling, encryption, caching, and more, provides Maven installation instructions, and demonstrates practical code examples for date, string, number, map, security, and captcha utilities.
This guide explains how to install the IDEA Maven Helper plugin, use its Dependency Analyzer to detect and exclude conflicting Maven dependencies, and provides alternative methods such as IDEA Diagrams and Maven commands for managing Java project dependencies.
This article introduces Lombok, explains how it leverages Java's annotation‑processing (JSR‑269) and abstract syntax tree (AST) modifications to generate boilerplate code at compile time, and provides a step‑by‑step guide to manually implement a @Getter annotation processor with full Maven project examples.
This article explains how to protect Java applications from reverse engineering by using ProGuard for code obfuscation, detailing the creation of a proguard.cfg file, Maven plugin configuration, and the build process to generate an obfuscated JAR.
This tutorial walks you through creating a Spring Cloud Alibaba project from scratch using IntelliJ IDEA and Maven, covering parent project setup, module creation, pom.xml configuration, a simple Spring Boot application, a Hello World controller, and how to run and verify the service.
This article documents a comprehensive migration from JDK 8 to JDK 17, detailing new language and JVM features, step‑by‑step upgrade procedures, Maven and SpringBoot version changes, performance benchmarking, and ZGC‑based garbage‑collection tuning to dramatically reduce pause times.
After a Java system went live, a disk usage alert exceeding 90% prompted an investigation that uncovered a third‑party jar’s debug‑level Log4j configuration writing large logs to the root directory, and the issue was resolved by excluding the offending jar via Maven, highlighting the need for careful dependency management.
This article documents a comprehensive upgrade from JDK 8 to JDK 17, detailing new language and JVM features, evaluation criteria for selecting services, step‑by‑step migration of Maven settings, dependencies, SpringBoot and middleware, performance testing results, and ZGC‑focused garbage‑collector tuning.
This article explains the differences between JAR and WAR files, why Spring Boot runs with an embedded Tomcat when packaged as a JAR, how deployment changes when using an external Tomcat, and provides step‑by‑step instructions with Maven configurations to build Spring Boot applications as either JAR or WAR packages.
This article explains the three main Maven dependency principles—shortest‑path priority, declaration order priority, and override priority—illustrates them with concrete examples and code snippets, describes common conflict errors, and outlines the complete Maven dependency loading workflow.
This article introduces the JXLS library for Java, explains how to add Maven dependencies, provides backend utility and controller code for exporting Excel files, and details template creation and common JXLS expressions such as jx:area, jx:each, jx:mergeCells, and dynamic column handling.
This article introduces the Hutool Java utility library, outlines its many modules and features, shows how to add it via Maven, and provides practical code examples for date, string, number, map, encryption, and captcha utilities to help developers avoid reinventing the wheel.
This guide compiles a comprehensive set of IntelliJ IDEA configurations and shortcuts—including SVN change indicators, multi‑project windows, Tomcat UTF‑8 fixes, import settings, compilation speed tweaks, global encoding, serialVersionUID generation, Maven/Tomcat setup, file exclusion, language injection, and quote wrapping—to streamline Java backend development.
Spring Cloud 2023.0 (Leiden) milestone, built on Spring Boot 3.2, introduces updated dependencies, repository configurations, and early support for MVC Server in Spring Cloud Gateway, enhanced Kafka Streams handling in Spring Cloud Stream, Java HttpClient in OpenFeign, and upgraded Kubernetes integration, with source code and deployment links provided.
This tutorial walks through a complete, step‑by‑step setup of a one‑click CI/CD pipeline that installs Docker and Jenkins on CentOS, configures Maven, creates a Jenkins job, builds a Spring Boot JAR, packages it into a Docker image, and runs the container, providing all commands and screenshots for a seamless deployment experience.
This guide walks through building a reusable Maven archetype scaffold from a Spring Boot template, covering template preparation, Maven configuration, archetype generation, publishing to a repository, and using the scaffold to quickly create new backend projects.
A Java developer added fastjson to a SkyWalking agent for JSON conversion, causing class‑loading conflicts in a SpringBoot 2 application; the article analyzes the root cause, demonstrates debugging steps, explains the parent‑delegation mechanism, and presents solutions using Maven shade relocation or switching to Gson, with practical lessons for avoiding similar issues.
This article analyzes how adding Fastjson to a SpringBoot agent causes classloader conflicts that prevent GenericHttpMessageConverter from loading, explains the underlying parent‑delegation mechanism, and presents solutions such as using Maven Shade to rename packages or switching to a lightweight JSON library like Gson.
JSONCompareUtils, a full‑JSON comparison component added to the Artemis framework, lets automated tests recursively compare large JSON responses via a Maven‑provided library with Java and Python wrappers, streamlining service‑splitting, BC‑traffic, and cross‑environment validation while dramatically cutting manual verification effort and speeding regression testing.
This article explains common Maven JAR dependency conflict scenarios and presents four practical solutions—including using Exclusions, configuring dependency scopes, applying the Maven Shade plugin for class relocation, and employing class‑loader isolation strategies—to help developers choose the appropriate method for their build and runtime environments.
This article introduces the open‑source MapStruct library, shows how to configure Maven and Lombok dependencies, defines entity and DTO classes with Lombok annotations, creates a mapper interface, and demonstrates simple, list, multi‑source, and default‑value mappings with complete code examples.
This article explains why Java applications should migrate from JDK 8 to JDK 17, introduces GraalVM native‑image technology, provides detailed upgrade procedures, Maven configuration, code examples, and a summary of performance benefits and typical issues encountered during the migration.
This article introduces BeetlSQL's recent updates—including Oracle12Style support and a version upgrade—provides the Maven dependency configuration, lists the wide range of databases it works with, and presents detailed benchmark comparisons against other ORM frameworks.
This article provides a comprehensive collection of IntelliJ IDEA configuration tips covering SVN change visibility, opening projects in new windows, fixing Tomcat Chinese character encoding, adjusting import display, speeding up compilation, setting global file encodings, generating serialVersionUID, customizing code templates, and various other IDE shortcuts and settings.
This article starts from a conventional three‑layer architecture, refines it into a domain‑driven design (DDD) application structure, demonstrates the evolution through five concrete steps, and shows how to package the final architecture as a reusable Maven Archetype with detailed installation and usage instructions.
This article introduces the Pie framework, a Java-based implementation of the responsibility‑chain design pattern, demonstrates how to integrate it with Maven, shows step‑by‑step code examples for handlers, outbound factories, bootstrapping, and global exception handling, and explains its benefits for clean, maintainable backend development.
maven‑mvnd, an Apache‑backed build tool that embeds Maven and leverages GraalVM, speeds up Java project compilation by reusing JVM processes, caching plugin classloaders, and retaining JIT‑generated code, with parallel module builds and simple mvn‑to‑mvnd command substitution, though JDK version quirks may require workarounds.
This article explains the differences between JAR and WAR packaging for Spring Boot applications, shows why embedded Tomcat behaves differently from external Tomcat, and provides step‑by‑step instructions with Maven commands and pom.xml modifications to build both JAR and WAR artifacts.
Learn how to set up a complete CI/CD pipeline on CentOS 7 by installing Docker and Jenkins, configuring Maven, creating Dockerfiles, and automating the build, test, and deployment of a Spring Boot application with detailed commands, screenshots, and best‑practice tips.
This guide explains what a scaffolding tool is, why it’s essential for micro‑service development, and provides step‑by‑step instructions for creating, publishing, and using a Maven archetype scaffold with Spring Boot, including Maven configuration, version handling, and repository deployment.
This article explains how to reduce the size of SpringBoot executable JAR files by separating application classes from dependency libraries, configuring the Maven build to use a ZIP layout, and deploying the slimmed package with a custom loader path, thereby speeding up uploads and updates.
This article explains how to set up Docker on Windows, integrate it with IntelliJ IDEA, build and run a Spring Boot application inside a container, and connect the containerized service to a Redis instance, including configuration, Maven plugin setup, and troubleshooting steps.
This article guides you through refining a classic three‑layer architecture into a domain‑driven design, structuring the project with Maven Archetype, and implementing a simple CMS with both backend (Spring Boot) and frontend (Vue) components, complete with step‑by‑step setup instructions.
This guide walks you through installing Jenkins and Nexus via Docker, configuring a Maven hosted repository in Nexus, adding necessary Jenkins plugins and credentials, and creating a Jenkins pipeline that builds a Java project and publishes its artifacts to Nexus, enabling automated CI/CD for your applications.
This article explains how Spring Boot's parent POM configures Maven resource filtering, uses the @ delimiter for variable substitution in YAML and properties files, and demonstrates multi‑profile activation to manage environment‑specific settings during build and packaging.
This tutorial walks through setting up a CentOS 7 environment, installing Docker CE, deploying Jenkins in a Docker container, configuring Maven and required plugins, creating a Jenkins pipeline that builds a SpringBoot project, packages it into a Docker image via a Dockerfile, and runs the container automatically, providing full end‑to‑end CI/CD automation.
This article provides a step‑by‑step guide on how to integrate Dubbo with SpringBoot to enable the gRPC protocol, covering project structure, Maven BOM dependencies, protobuf generation, service implementation, configuration details, and the differences between Dubbo‑enabled gRPC and native gRPC.
This article explains how to manage Maven dependencies, understand transitive, optional, and excluded dependencies, configure dependency scopes, navigate the Maven build lifecycle, use plugins, and set up module aggregation, inheritance, properties, versioning, environment profiles, and a private Nexus repository for Java projects.
This article introduces the open‑source MapStruct library for Java, shows how to configure Maven, defines entity and DTO classes, demonstrates basic and advanced mapping techniques—including list conversion, multi‑object merging, and default values—while providing complete code examples and explanations.
This guide walks you through analyzing a Spring Boot microservice project, configuring Maven parent and child POM files, packaging the required modules, and deploying both the backend JAR and the frontend assets on Windows or Linux servers using simple command‑line tools.
This article provides a step‑by‑step tutorial on analyzing a Spring Boot microservice project, configuring parent and child Maven pom files, packaging modules with Maven plugins, and deploying both backend JARs and frontend assets to Windows or Linux servers.
This article explains why simple timing is unreliable in Java due to JIT compilation, introduces the official JMH tool for microbenchmarking, outlines best‑practice tips, demonstrates how to set up a Maven project, write benchmark code, run tests, interpret results, and details each JMH annotation.
This article explains how to use Spring's profile‑specific configuration files, package a multi‑module Java project with Maven or IDEA, and deploy the resulting JAR on a Linux server by installing JDK, setting environment variables, and starting the application in foreground or background.
This article explains why a Spring Boot project runs differently when packaged as a JAR versus a WAR, outlines the historical evolution of Java web containers, compares the characteristics of JAR and WAR files, and provides step‑by‑step Maven commands and pom.xml configurations for building both package types.
This step‑by‑step guide shows how to install Docker and Jenkins on CentOS, configure Jenkins plugins and Maven, create a freestyle job that pulls a Spring Boot project from Git, builds it with Maven, packages it into a Docker image, and runs the container automatically.
This article explains how to use Spring's dynamic profile configuration to separate environment-specific YAML files, demonstrates jar and IDE launch options, outlines Maven and IDEA packaging steps, and provides detailed instructions for installing Java, configuring environment variables, and deploying the packaged Spring Boot application on a server.
This article introduces the popular microservice stacks, explains Quarkus’s advantages, shows three ways to create a Quarkus project, demonstrates local development and port configuration, and provides a step‑by‑step Jenkins CI pipeline for building and running the application.
This article introduces Java Agent technology, explains the differences between premain and agentmain modes, demonstrates how to build, package, and attach agents using Maven and the Attach API, and shows practical bytecode manipulation techniques with Instrumentation and Javassist, complete with code examples.
This tutorial walks through enabling Docker remote connections on Linux and Windows, installing and configuring the IntelliJ IDEA Docker plugin, adding a docker‑maven‑plugin to a Spring Boot Eureka project, building Docker images, creating containers with port mapping, and setting up one‑click deployment for rapid backend development.
This article introduces MapStruct, a compile‑time Java bean‑mapping code generator, explains its core concepts, shows step‑by‑step examples—including Maven dependencies, entity and DTO definitions, mapper interfaces, custom conversions, and advanced configurations—while comparing its performance to other copy utilities and highlighting deep‑copy behavior.
This article explains how to build a generic Java utility that exports any list of objects to an Excel‑compatible CSV file by using reflection to extract field names for headers and values for rows, includes Maven dependencies, custom annotations, and practical usage examples.
This article introduces Flyway as a database migration solution, explains its versioned, undo and repeatable migrations, details common commands, shows Maven and YAML configuration for Spring Boot, provides sample SQL migration scripts and logs, and highlights paid‑only features.
This article explains why Maven runs unit tests during the package phase, describes the problems caused by missing production database access, and provides five practical methods—including command‑line flags, pom.xml configuration, IDE settings, and Maven runner options—to skip tests when building a Java project.
The article details multiple ways to skip unit tests when packaging a Maven Java project, including command‑line flags, pom.xml configuration, IDE settings, and Maven runner VM options, enabling developers to build JAR files without test execution when production configurations are needed.
This article explains why a Spring Boot application behaves differently when run as a JAR versus deployed as a WAR, outlines the historical context of servlet containers, compares JAR and WAR formats, and provides step‑by‑step Maven commands and pom.xml modifications for packaging both types.
This article explains the concept of scaffolding for software development, outlines why it is essential for microservice architectures, compares custom persistence solutions with Spring Data, and reviews popular backend scaffolding tools such as Spring Boot, Maven, Netty, Java EE, and Dropwizard.
This article introduces Java Microbenchmark Harness (JMH), explains why warm‑up is necessary, details common annotations, shows how to set up a Maven project, provides a complete benchmark example comparing LinkedList iteration methods, and demonstrates how to run and interpret the results.
This article details how the Omega platform reduced compilation time by up to 60% by adding Maven -am -pl flags, leveraging GoTemplate custom functions, and adjusting GitLab‑CI variables, providing a step‑by‑step verification of each attempt and the final solution.
This article introduces Screw, a tool that automatically generates database documentation in HTML, Word, or Markdown for many popular databases, and shows how to integrate it with Maven and Java in just two simple steps.
The article humorously deconstructs an overly complex Java enterprise setup, illustrating how excessive use of interfaces, abstract classes, factories, dependency injection, XML configuration, and heavyweight IDE tooling leads to bloated, hard‑to‑maintain code that ultimately fails in production.
This article explains how to create a Spring Boot package that keeps dependencies external by configuring the spring-boot-maven-plugin and maven-assembly-plugin, using a ZIP layout and PropertiesLauncher, so the application can be started with a custom loader.path that points to a libs directory.
Apache NetBeans 16 introduces extensive updates—including enhanced YAML and Dockerfile support, improved Maven and Gradle integration, Java 19 features, and numerous bug fixes—making it a more powerful free IDE for Java and other language development.
This article demonstrates how to package a Spring Boot application using Maven profiles and the Maven Assembly Plugin to create a zip release, and provides a reusable shell script (shenniu_publish.sh) for extracting, starting, stopping, and restarting the service on Linux.
Spring Boot 3.0 adds a Native Executables feature that lets Java code be compiled ahead‑of‑time into machine code, contrasting with the traditional JIT approach, and provides a Maven command to generate platform‑specific executables for faster startup and performance.
This article explains common Maven commands, describes why a JAR built for execution cannot be imported by a third‑party project, and provides step‑by‑step solutions using the maven‑compiler‑plugin and maven‑assembly‑plugin to create dependency‑inclusive JARs.
This article explains what Spring Native is, how to set up the required environment, the two main ways to build a native Spring Boot image using either Buildpacks or the GraalVM native-image Maven plugin, and demonstrates container deployment and performance comparison with traditional JVM execution.
This article explains how to securely encrypt sensitive Spring Boot configuration properties such as database passwords using the Jasypt library, covering dependency setup, YAML configuration, encryption/decryption testing, custom encryptors, property detectors, resolvers, filters, and Maven plugin usage, all with practical code examples.
Learn how to protect your Java code from reverse engineering by compiling, decompiling, and applying ProGuard obfuscation, including creating a proguard.cfg file and configuring the Maven ProGuard plugin, with detailed examples and screenshots illustrating each step of the process.
This guide explains Java compilation basics, the need for code obfuscation, provides a complete ProGuard configuration file, shows how to integrate the ProGuard Maven plugin into a pom.xml, and demonstrates building an obfuscated JAR with Maven.
This article explains the concepts of Java compilation and decompilation, introduces code obfuscation with ProGuard, and provides step‑by‑step Maven configuration to protect Java applications from reverse engineering, including sample configuration files and build commands.
The article shares a developer's practical experience of transitioning from backend to frontend by learning Vue and React, exploring component libraries, tackling layout and styling challenges, and integrating the frontend build into a backend Maven project for a complete gateway console.
This article explains how Java source files are compiled into class files, how they can be decompiled, and provides a detailed, code‑rich tutorial on protecting a Spring Boot project by configuring ProGuard through a proguard.cfg file and Maven plugin to produce an obfuscated JAR.
The article explains that when using MapStruct with Lombok, Maven must list Lombok before MapStruct (or define annotationProcessorPaths) so Lombok’s annotation processor runs first, and then demonstrates basic and advanced mapping techniques, Spring integration, and singleton caching strategies.
This article explains how to construct a reusable base package for backend systems by defining Maven dependency guidelines, a unified response body with business codes, proper data object layers such as PO, BO, DTO, VO, and pagination utilities, while illustrating the concepts with concrete Java code examples.
This article explains why and how to split a Spring Boot project into Maven modules, defines a common framework with clearly separated modules such as api, base, rpc, service, interaction, and start, and provides practical steps and code snippets for managing dependencies in complex backend applications.
This article provides a practical step‑by‑step guide to integrating Dubbo with Nacos in a Spring Boot project, covering environment setup, Maven configuration, module creation for public API, provider and consumer services, and testing the RPC call, while highlighting version compatibility and common pitfalls.
This article introduces JMH, the official Java microbenchmarking tool, explains why warm‑up is needed, shows how to build a Maven project, provides a complete LinkedList iteration benchmark example, demonstrates common JMH annotations, and outlines how to run and interpret benchmark results.
This tutorial walks through building a simple Dubbo‑Nacos integration using Spring Boot, covering environment setup, Maven project structure, dependency management, service interface definition, provider and consumer modules, configuration files, and a test call, enabling rapid development of high‑performance Java microservices.
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.
