This article explains how to package a Spring Boot application using Maven profiles and the assembly plugin, generate a zip deployment bundle, and deploy it on Linux with a custom shell script that supports start, stop, restart, and unzip operations.
This article presents a comprehensive guide to building a Spring Boot backend system by outlining essential design principles, detailing a multi‑module architecture with clear responsibilities, and providing complete Maven POM configurations for each module to enable scalable and maintainable development.
This article walks through setting up a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates common pitfalls, and provides essential scaffold code such as global exception handling, logging, CORS configuration, Swagger setup, and response wrappers.
This article explains how to secure Spring Boot deployment packages by using Maven plugins for code obfuscation and encryption, configuring classfinal‑maven‑plugin to encrypt class files, configuration files, and libraries, and demonstrates password‑less and password‑protected startup as well as machine‑bound execution to prevent reverse engineering.
This article provides a comprehensive guide to Maven, covering repository configuration, basic project setup, dependency declaration and management, module organization, unified version control, essential plugins such as jar, assembly, and shade, as well as build settings like compiler version, resource exclusion, and main class definition.
This article walks through the challenges of setting up a Java development environment, demonstrates how to create a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot, and Kafka, showcases essential Maven configurations and code snippets for global exception handling, logging, CORS, Swagger, and recommends useful in‑memory tools such as embedded Redis, DB, Kafka, Hutool, MyBatis‑Plus, MapStruct, and Redisson.
This guide explains the background, purpose, and step‑by‑step process for creating an automated security code detection platform that integrates SonarQube, Jenkins, Maven, SVN and MySQL, enabling continuous security testing and reporting within the software development lifecycle.
This article provides a step‑by‑step tutorial on integrating the Sensitive‑Word Java library via Maven, demonstrates core find/replace APIs, showcases advanced detection features such as email, URL, IPv4 and custom replacement strategies, and includes complete code examples and output results.
This article walks through creating a Spring Boot project, handling IDE setup, managing Spring Cloud and Kafka version compatibility, using Maven for dependency management, and provides essential scaffold code such as global exception handling, logging aspects, CORS configuration, and Swagger integration.
This article provides a detailed tutorial on Maven, covering basic project configuration, repository setup, POM structure, dependency declaration and scopes, indirect dependencies, exclusions, variable properties, multi‑module management, unified dependency management, essential plugins such as jar, assembly and shade, as well as build settings like compiler version, resource exclusion, and main‑class definition.
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 common XLS expressions such as jx:area, jx:each, jx:mergeCells, and dynamic column handling to simplify complex Excel report generation.
This article walks through creating a Spring Boot project, handling version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates common Maven configurations, provides global exception handling and logging aspects, and lists useful backend tools such as embedded Redis, MyBatis‑Plus, and Redisson.
This article explains how to use the iTextPdf library in Java to design a PDF template, fill fixed fields, dynamically generate product tables, and merge the two parts into a single invoice PDF, including Maven dependencies and sample code.
This guide explains how to use Maven plugins such as spring-boot-maven-plugin, maven-dependency-plugin, and maven-jar-plugin to package a Spring Boot application into an executable JAR with external lib dependencies, and shows how to deploy the resulting artifacts in a Docker container using a custom Dockerfile.
This article provides a detailed tutorial on using Maven for Java projects, covering basic repository setup, dependency declaration, scope options, indirect dependencies, exclusions, variable properties, multi‑module configuration, dependencyManagement, and essential plugins such as jar, assembly, and shade, with practical code examples and best‑practice recommendations.
This guide walks you through the pain points of environment setup, shows step‑by‑step creation of a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot and Kafka, and provides ready‑to‑use Maven configurations, global exception handling, logging, CORS, Swagger, and a curated list of useful development tools.
This tutorial walks through creating a Maven‑based Spring Boot backend project with multiple modules, configuring pom.xml files, application properties, and logging, then adds a scheduled Douyin hot‑search crawler using OkHttp, demonstrating full end‑to‑end setup for a web service.
After upgrading from Tomcat 7 to Tomcat 8, the application’s mixed log4j‑1.4 and logback‑1.2.3 dependencies caused the SLF4J binder to be loaded nondeterministically, so Tomcat 8 sometimes selected the Log4j binder without a configuration file, resulting in completely missing log output; removing the conflicting jars or enforcing a deterministic class‑loading order restored logging.
This guide presents 28 practical IntelliJ IDEA tricks—from viewing code history and adjusting memory settings to customizing keymaps, code inspections, Maven dependency visualization, and multi‑instance debugging—helping Java developers dramatically boost productivity and streamline daily workflows.
Learn step‑by‑step how to create a custom Spring Boot starter, configure its properties, define services and controllers, register it via spring.factories, and then integrate the starter into other projects with Maven dependencies and configuration files.
This guide explains how to protect a Spring Boot release package from source leakage by comparing code obfuscation and encryption, detailing the configuration of the classfinal‑maven‑plugin, launch commands with and without passwords, and binding the encrypted jar to a specific machine.
This article walks through the challenges of setting up a Java backend environment, demonstrates how to create a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot, and Kafka, and provides reusable code snippets for exception handling, logging, CORS, Swagger, and response wrapping, along with recommended tools.
This article explains how to enable hot deployment in Spring Boot using DevTools, configure automatic recompilation in IDEs, simplify Java bean code with Lombok, and add the Spring Configuration Processor for property metadata, providing Maven snippets and step‑by‑step instructions.
This article compares Maven and Gradle, outlining their core concepts, build performance, flexibility, learning curve, and stability to help Java developers choose the most suitable build tool for their projects.
The article compares Maven and Gradle, detailing their histories, core concepts, advantages, disadvantages, and performance differences, and offers practical advice for Java developers on choosing the most suitable build tool for their projects.
This article provides a detailed tutorial on Maven, covering repository configuration, basic project structure, dependency management, module inheritance, unified version control, and common build plugins such as jar, assembly, and shade, with practical XML examples and code snippets for Java backend projects.
On his first day the new Java backend developer discovered duplicated internal and external configuration files causing NullPointerExceptions, hard‑coded role strings, mixed System.out and logger calls, missing manager review leading to DB mismatches, arbitrary production database edits, and Maven pom‑type dependency errors, prompting a shift to unified application.yml settings, JVM‑specified config locations, consistent logging, and stricter coding standards.
This guide explains what Java Agents are, their core capabilities such as bytecode enhancement, performance monitoring, security checks, and debugging, and provides step‑by‑step instructions for implementing the premain method, creating a ClassFileTransformer, packaging the agent with Maven, and loading it both statically and dynamically.
The guide explains how to protect a Java core module deployed on user servers by integrating ProGuard for bytecode obfuscation, Xjar for JAR encryption, and ClassFinal for class‑file encryption, providing Maven plugin configurations, startup commands, and verification that the combined approach renders decompiled code empty or unreadable.
This article explains how to protect Java backend code deployed on user servers by applying ProGuard, Xjar, and ClassFinal for JAR obfuscation and encryption, detailing Maven configurations, startup commands, decompilation results, and best‑practice integration of both tools in a Spring Boot project.
This article outlines essential backend design principles such as single responsibility, high cohesion, low coupling, reusability, clear boundaries, moderate modularity, layered architecture, dependency inversion, testability and future adaptability, and demonstrates their application in a multi‑module Spring Boot project with detailed Maven configurations.
This article provides a detailed tutorial on Maven, covering repository setup, basic POM structure, dependency management, module configuration, unified dependency versions, and common build plugins such as jar, assembly, and shade, with practical XML examples and code snippets.
MapStruct is a powerful Java annotation‑based mapper that outperforms BeanUtils by generating compile‑time mapping implementations without reflection, supporting simple, nested, collection, and custom mappings, dependency injection, constants, expressions, and error handling, making object‑DTO conversions efficient and maintainable in Spring Boot projects.
The June 2024 VS Code for Java update introduces enhanced project settings with new compiler, Maven, and formatter tabs, easier access via the status bar, test coverage improvements, Gradle Build Server projects, Spring feature upgrades including @DependsOn support and Spring Boot 3.3 compatibility, and new extension packs for Java development.
Learn how to use Maven Archetype to create standardized project skeletons, customize templates, generate and share archetypes, and integrate them into IDEs, streamlining Java project initialization, reducing manual setup errors, and improving development efficiency across teams.
A Java developer recounts how an unexpected Excel export failure was traced to mismatched EasyPOI and Apache POI versions, the impact of Maven's -U flag, and the step‑by‑step resolution involving dependency alignment and careful version selection.
This article introduces JMH, explains why it outperforms simple loops or other tools, and provides step‑by‑step Maven setup, benchmark creation, execution, and advanced annotations such as @Warmup, @Fork, @Setup, Blackhole usage, and SpringBoot integration for accurate Java micro‑benchmarking.
This guide walks through fixing four common Jenkins pipeline problems: replacing unreachable plugin update sites with domestic mirrors, resolving Maven build errors caused by missing server JVM libraries, clearing stale Git config lock files, and adjusting file descriptor limits on build nodes to prevent out‑of‑resource failures.
This article presents a comprehensive Spring Boot backend architecture for the XiaoLe project, detailing design principles, a ten‑module Maven structure, key pom configurations, and the rationale for using Maven import to manage dependencies.
This article presents a configurable OLAP framework that streamlines multi‑dimensional, multi‑metric analysis by separating core and interaction domains, using metadata‑driven modeling, runtime request handling, and Maven‑based integration to accelerate development and improve query performance.
This guide explains how to install Jenkins, Java, Maven, and Git in an offline Linux environment, covering required dependencies, downloading and installing packages, configuring tools, adding plugins, handling common errors, and finalizing the Jenkins setup for continuous integration pipelines.
This article explains why Maven runs unit tests during the package phase, describes the Maven lifecycle, and provides several practical methods—including command‑line flags, pom.xml configuration, and IDE settings—to skip tests when building a Java project.
This guide walks through setting up a complete CI/CD environment on three CentOS 7.6 machines—GitLab, Jenkins, and Tomcat—covering installation, configuration, plugin management, Maven integration, SonarQube scanning, and automated deployment of a Java web application.
Spring AI brings artificial‑intelligence capabilities to the Spring Boot ecosystem, offering model support, vector‑database integration, SQL‑like filtering, and easy Maven configuration, enabling Java developers to add generative AI, semantic search, and AI‑driven image generation to their backend applications.
This guide demonstrates how to leverage Maven resource filtering for automatic property expansion in Spring Boot 3.2.5, configure externalized settings via spring.main and system properties, customize configuration file locations, activate profiles, set parent containers, modify DispatcherServlet paths, enable Tomcat access logs, MBean registry, and generate build and Git metadata.
This article explains how to design a clean, maintainable Spring Boot backend by applying core software principles, organizing modules such as core, common, business, and admin, and providing complete Maven pom examples to illustrate a modular multi‑module project layout.
This guide explains why SpringBoot JARs become bulky when many dependencies are included, shows how to inspect the packaged libraries, and provides step‑by‑step Maven configurations and runtime commands to build a leaner JAR that loads external libs only when needed, dramatically speeding up deployment.
This guide walks you through the fundamentals of Java Spring Boot projects, explains WAR vs JAR deployment, sets up Maven and Jenkins, configures SSH and DingTalk notifications, and provides a complete CI/CD pipeline with scripts for automated builds and releases.
This guide walks you through setting up Jenkins to pull code from GitLab, build a SpringBoot 3 Java project with Maven, back up and copy JAR files to a remote server, and perform rolling updates of Docker Swarm services, all with step‑by‑step instructions and code snippets.
This article introduces the Maven Helper plugin, explains how to install it both online and offline in IntelliJ IDEA, and demonstrates its key features for simplifying Maven dependency management, conflict resolution, and project packaging, helping developers focus on coding rather than build complexities.
This article details Kuaishou's engineering architecture governance process, covering project background, IDEA performance bottlenecks, cloud‑based IDE solutions, MavenHelper and custom Maven plugins for dependency analysis, handling NoClassDefFoundError issues, and static‑dynamic class dependency detection to improve backend build efficiency.
This article explains how to lower the learning curve of DDD and CQRS by using structured, standardized, and templated approaches, introduces a Maven archetype for rapid project scaffolding, and demonstrates an IntelliJ IDEA plugin that auto‑generates boilerplate code for aggregate roots, commands, queries, and related components.
IntelliJ IDEA 2024.1 introduces full‑line code completion powered by a local deep‑learning model, Java 22 language support, a revamped terminal, sticky lines in the editor, enhanced Maven handling, improved debugging, richer Spring assistance, advanced HTTP client features, and new database tools, all aimed at boosting developer productivity and safety.
This article explains how to build a Maven‑based tool that scans a Java codebase, removes trivial getter and setter methods, adds Lombok’s @Data annotation, and rewrites the source files using JavaParser, complete with implementation steps, code examples, and usage instructions.
Graceful Response is a Spring Boot library that provides unified response wrapping, global exception handling, custom error codes, validation support, and configurable response styles, enabling developers to write cleaner controller code, reduce boilerplate, and improve API consistency.
This article explains how to implement IP‑location lookup by recommending the free ip2region offline library, provides Maven dependency details, shows step‑by‑step Java code for loading the XDB file, querying an IP address, interpreting the result format, and highlights its high accuracy and cross‑region support.
This article analyses the challenges of protecting intellectual property in B2B Java applications, reviews existing obfuscation and encryption tools, and proposes a lightweight Maven‑based encryption plus javaagent decryption scheme that secures both proprietary code and third‑party dependencies while keeping performance impact below five percent.
The article presents a Java Spring solution that uses a custom URLClassLoader to dynamically load, register, and unload governance task JARs as Spring beans and XXL‑Job handlers at runtime, with configuration persistence via YAML or Nacos and Maven Shade packaging for seamless updates without service restarts.
Graceful Response is a Spring Boot component that provides unified response wrapping, global exception handling, and custom error codes, helping developers reduce boilerplate, improve code readability, and accelerate API development while maintaining consistent error responses.
This article presents a developer‑centric guide to designing a Java code‑optimization tool that automatically replaces trivial getter/setter methods with Lombok’s @Data annotation, detailing the scanning, filtering, modification steps, JavaParser usage, Maven integration, and practical usage instructions.
The solution introduces a plug‑in architecture that uses a custom URLClassLoader to load governance task JARs at runtime, registers their Spring beans and @XxlJob handlers with XXL‑Job, and provides unload logic to deregister jobs, destroy beans, and update configuration via YAML or Nacos without restarting the service.
This article explains how to package a Spring Boot application so that its dependencies are stored externally and loaded at runtime using Maven plugins and the PropertiesLauncher, enabling easy replacement of individual libraries without rebuilding the entire fat jar.
This guide walks through installing Jenkins and Nexus via Docker, configuring a Maven hosted repository in Nexus, setting up Jenkins credentials and plugins, and creating a Jenkins pipeline that builds a Maven project and publishes its artifacts to Nexus, enabling automated CI/CD for Java applications.
This guide demonstrates how to set up a Maven project with the Fabric8 Kubernetes Java client, configure minimal kubeconfig or ServiceAccount credentials, and use sample code to list namespaces, illustrating essential steps for connecting Java applications to a Kubernetes cluster with minimal configuration.
This article explains Maven dependency conflicts, their causes, resolution principles like path-nearest and declaration-first, and practical solutions including exclusions, optional dependencies, dependency management, and the Maven Helper plugin for analyzing and fixing jar version clashes.
This article explains how to create a Spring Boot fat‑jar that externalizes its dependencies by configuring the spring‑boot‑maven‑plugin and maven‑assembly‑plugin to produce a ZIP layout, then uses the PropertiesLauncher with loader.path to load libraries from a separate libs directory at runtime.
This article explains how to protect Java server-side code from decompilation by applying ProGuard shrinking/obfuscation and Xjar/ClassFinal encryption, provides detailed Maven plugin configurations, sample pom.xml snippets, command‑line launch options, and demonstrates the resulting protected JARs with screenshots.
This article explains how to protect Java applications from decompilation by configuring a ProGuard file and adding the ProGuard Maven plugin, then building the project to generate an obfuscated JAR, complete with step‑by‑step instructions and sample configuration code.
This article explains how to obtain a client’s IP address from an HttpServletRequest, convert it to a geographic location using the ip2region library, and provides multiple Java implementation options, Maven dependencies, and performance testing commands for efficient backend IP lookup.
Maven’s version ranges let you specify acceptable artifact versions, but open‑ended ranges like [2.3.0,) cause Maven to fetch the newest matching release, leading to nondeterministic builds and potential incompatibilities, so you should pin exact versions and use dependencyManagement for consistent, stable builds.
This article covers Java backend architecture fundamentals, including front‑end/back‑end separation, Maven configuration, distributed lock implementations with Redis and Zookeeper, session handling in distributed systems, database locking strategies, and useful code snippets for common patterns.
When Maven’s archetype plugin hangs during project generation, you can resolve it by specifying archetypeCatalog=internal or local as a command-line or VM option, placing a downloaded archetype-catalog.xml in ~/.m2, or configuring a domestic mirror in settings.xml, after which generation completes in seconds.
This article explains why manual property copying in Java is inefficient, compares several runtime bean‑copy utilities, and demonstrates how MapStruct provides a compile‑time, type‑safe, high‑performance solution for shallow and deep object mapping, including handling of collections and ignored fields.
This article introduces PowerJob, a Java‑based enterprise distributed task scheduler, outlines its key features, installation methods, step‑by‑step server and client setup, task creation, and detailed configuration options for robust backend job management.
This article explains how to use Maven profiles and the Maven Assembly Plugin to create environment‑specific Spring Boot zip packages and provides a reusable shell script (shenniu_publish.sh) for extracting, starting, stopping, and restarting the packaged JAR on Linux, improving deployment efficiency.
This guide explains how to troubleshoot and fix the UnsupportedOperationException caused by missing or outdated ASM libraries when upgrading the JDK, covering removal of old Maven dependencies, adding the correct ASM version, updating Groovy and related plugins, and disabling the Log4j shutdown hook warning.
This article introduces mybatis-plus-generator-ui, a highly customizable web‑based code generator built on MyBatis‑Plus that supports multiple databases, offers interactive UI for generating Entity, Mapper, Service, Controller and other layers, and provides detailed usage, configuration, and extension instructions for Java backend developers.
This guide explains how to protect Spring Boot production packages from reverse engineering by applying code obfuscation with ProGuard and full encryption using the ClassFinal Maven plugin, including configuration steps, encrypted startup commands, machine‑binding activation, and the resulting decompilation behavior.
This article explains why upgrading to JDK 17 is essential, outlines the long‑term support, performance gains from modern garbage collectors like ZGC, new language features such as switch expressions and records, and provides detailed migration steps, Maven and Spring Boot configuration, and troubleshooting tips for a smooth transition.
This article explains how to create a reusable Maven archetype for Spring Boot applications, covering the definition and benefits of scaffolding, step‑by‑step template preparation, archetype generation, artifact adjustments, publishing to a repository, and using the scaffold to quickly start new microservice projects.
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.
