This article walks through selecting Camunda 7 as a workflow engine, explains core concepts and components, shows how to integrate it into a Spring Boot project with Maven dependencies, configure the database, deploy BPMN models, and use the rich API for processes, tasks, variables, listeners, and gateways.
This article explains why rate limiting is critical for microservice architectures, reviews common limiting algorithms, and provides step‑by‑step implementations using Dubbo, Spring Cloud, Guava token‑bucket, Sentinel, Redis+Lua, and a reusable Spring Boot starter with custom annotations and AOP.
kkFileView is an open‑source Spring Boot‑based service that enables online preview of a wide range of document, image, archive and multimedia formats, offering multiple rendering modes and easy REST integration for developers.
This article explains the concept of plugin‑based development, outlines its benefits, compares common implementation methods such as Java SPI, custom configuration, and Spring Boot factories, and provides step‑by‑step code examples for building extensible backend services.
This article explains the purpose, differences, and proper usage of Spring validation annotations such as @NotNull, @NotBlank, @NotEmpty, as well as the @Valid and @Validated triggers, providing Maven dependency setup and concrete code examples for effective backend data validation.
This article explains how to integrate the Camunda 7 workflow engine into a Spring Boot project, covering core concepts, required Maven dependencies, configuration files, database schema, process modeling, task types, and detailed API examples for managing processes, tasks, variables, listeners, and permissions.
This guide explains how to integrate the ip2region library for offline IP‑to‑region lookups, implement memory‑accelerated queries, use an online WHOIS service for richer data, and embed the logic into a Spring Boot interceptor for seamless request handling.
This article reviews the latest Mica releases, highlighting version compatibility with Spring Boot, new Redis and XSS features, core utility enhancements, bug fixes, and upcoming support for Spring Boot 3.1.x, providing developers with a concise overview of the library’s recent advancements.
This article explains how to integrate the Camunda 7 workflow engine into a Spring Boot project, covering core concepts, required Maven dependencies, configuration files, database schema, process modeling, task types, gateways, and detailed API examples for process and task management.
This article explains the dangers of using the Linux kill -9 command on Java services, especially Spring Boot applications, and demonstrates several graceful shutdown techniques—including using SIGTERM, Tomcat's shutdown hooks, Spring Actuator, and custom shutdown configurations—to avoid data loss and ensure clean termination.
This article demonstrates multiple ways to add text or image watermarks to PDF documents within a Spring Boot application, covering Apache PDFBox, iText, Ghostscript, Free Spire.PDF, and Aspose.PDF, and provides complete Maven dependencies and code examples for each method.
This article explains the fundamentals of Spring WebFlux, its reactive programming model with Mono and Flux, compares it to Spring MVC, and provides practical code examples for building non‑blocking backend services using Spring Boot.
This tutorial provides a complete, step‑by‑step guide to set up a one‑click automated deployment pipeline for a Spring Boot application using Docker, Jenkins, Maven, and shell scripts on a CentOS 7 host, covering installation, configuration, job creation, testing, and execution.
This article demonstrates three practical approaches—native HttpClient, Spring's RestTemplate, and Feign client—to invoke external services from a Spring Boot application, providing code examples, configuration details, and tips for handling authentication tokens.
Learn how Project Loom’s virtual threads can replace heavyweight OS threads in Java Spring Boot applications, enabling one‑thread‑per‑request models, improving throughput under high concurrency, with step‑by‑step setup, code samples, and performance comparisons across 100‑, 300‑ and 500‑thread tests.
This article analyzes why MySQL recommends auto_increment primary keys over UUID or non‑sequential Snowflake IDs by creating three tables, running Spring Boot/JdbcTemplate performance tests, and examining index structures, lock contention, and fragmentation to guide optimal primary‑key selection.
This article explains the principles and practical implementations of plugin-based development in Java, covering SPI, custom configuration, runtime JAR loading, and Spring Boot factories, and demonstrates how to build flexible, extensible systems with real code examples.
Learn how to implement RFC 7807 Problem Details in Spring Boot 3, covering the JSON format, Spring’s built‑in support, configuration steps, custom extensions, and practical code examples for handling errors with ProblemDetail, ErrorResponse, and ResponseEntityExceptionHandler.
This article explains how to handle common failure scenarios in Spring Boot by using the spring-retry library, detailing the @Retryable and @Recover annotations, their parameters, configuration steps, code examples, and important considerations for building resilient backend services.
This article explains the concept of plugin‑based development in Java, outlines its advantages such as decoupling and extensibility, and provides detailed implementation guides using ServiceLoader, custom configuration files, and Spring Boot's spring.factories mechanism with complete code examples.
This article explains why and how to use plugin mechanisms in Java, covering the benefits of modular decoupling, common implementation patterns such as ServiceLoader, custom configuration loading, and Spring Boot's spring.factories, and provides step‑by‑step code examples and practical case studies.
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.
This article explains the concept and advantages of plugin-based development, outlines common implementation strategies in Java, demonstrates practical SPI and custom configuration approaches, and shows how Spring Boot’s spring.factories mechanism can be used to build extensible backend systems.
This article introduces Spring WebFlux, a reactive web framework introduced in Spring 5, explains the concept of reactive programming, compares it with Spring MVC, describes its concurrency model, and provides practical code examples for building a WebFlux application with Spring Boot.
Easy-Trans is a Spring Boot starter that leverages ORM frameworks like MyBatis‑Plus, JPA, and BeetlSQL to automatically translate IDs, dictionary codes, and enum values into human‑readable data, supporting caching, multi‑data‑source, micro‑service RPC, and flexible configuration for backend developers.
This article introduces Spring WebFlux as a reactive, non‑blocking web framework for Java, explains the concepts of reactive programming, compares it with Spring MVC, and provides practical code examples—including Mono/Flux usage, routing, and handlers—to help developers build and run a WebFlux application with Spring Boot.
The article explains MyBatis first‑level and second‑level caching mechanisms, their activation conditions, integration pitfalls with Spring Boot, and how to enable and use them safely, including configuration steps, code examples, and warnings about hidden risks of second‑level cache.
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 article explains how to limit the number of requests an API endpoint can receive within a specified time window by creating a @RequestLimit annotation, a Redis‑backed interceptor, and the necessary Spring Boot configuration and controller examples.
This guide introduces MinIO as an S3‑compatible object storage service and walks through its installation, Maven dependencies, Spring Boot configuration, Java client setup, REST controller implementation for file upload, preview, download, and deletion, and includes debugging screenshots.
This guide walks through setting up Camunda BPM 7.18 with Spring Boot 2.6.14, configuring dependencies and application properties, designing a two‑step approval workflow, deploying it via custom REST endpoints, and managing process start and task approval using Camunda’s services and APIs.
This article explains why publicly exposed APIs are vulnerable, describes the concepts of anti‑tampering and anti‑replay protection, and provides a complete Spring Boot implementation—including request signing, timestamp and nonce validation, and Redis‑based replay detection—to safeguard API endpoints.
This article demonstrates step‑by‑step how to set up a high‑performance MinIO object storage service using Docker, configure it in a Spring Boot application, and integrate file upload functionality with a Vue/Element‑UI front‑end, including code snippets for Docker commands, Java client setup, and UI implementation.
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 Spring Boot 3.0.5 processes errors, registers a default /error page, and returns either HTML or JSON responses based on the Accept header, detailing the underlying servlet and Tomcat mechanisms with code examples.
This article walks through configuring and using IntelliJ IDEA for remote debugging of a Spring Boot microservice, covering JVM arguments for different JDK versions, IDEA setup, startup script adjustments, and practical pitfalls such as log location, code consistency, and drop‑frame effects.
This article explains how to replace Spring Boot's default embedded Tomcat with Undertow, details the configuration steps, compares their performance and memory usage through benchmark results, and concludes that Undertow offers superior efficiency for high‑concurrency Java backend applications.
This article explains how to replace Spring Boot's default embedded Tomcat with the high‑performance Undertow server, details the necessary Maven dependencies and configuration steps, and presents benchmark results showing Undertow's superior throughput and lower memory usage under high‑concurrency workloads.
This guide walks you through installing Docker and Jenkins on CentOS 7, configuring Jenkins plugins, creating a freestyle job that builds a Spring Boot application with Maven, and deploying it via a Dockerfile for fully automated one‑click deployment.
This article explains Spring Boot's default JSON response, the internal HttpMessageConverter selection process, and how to configure XML and custom YAML responses by adding Jackson dependencies and implementing a custom HttpMessageConverter.
This guide introduces a lightweight Redis graphical management tool that offers full CRUD support for all Redis data types, outlines its Spring Boot backend and Vue frontend stack, provides step‑by‑step installation and Docker deployment instructions, and details current features, UI screenshots, and future development plans.
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 introduces the MyBatis-Plus Generator UI, a web‑based tool that wraps MyBatis‑Plus code generation to quickly produce Spring Boot compatible entities, mappers, services and controllers, explains how to integrate it via Maven and a main class, and demonstrates its rich customization and UI features.
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 tutorial shows how to integrate Keycloak 21.1.1 with Spring Boot 3.1 and Spring Security, covering realm and client setup, token acquisition, Maven dependencies, JWT configuration, a protected test endpoint, and verification of authentication behavior.
This article demonstrates how to create a generic utility that uses Java reflection to export lists of arbitrary objects to CSV or Excel files, covering dependency setup, core implementation, custom annotation support, and practical usage examples.
This article introduces the URule rule engine, explains its background and features, walks through installation and usage in a Spring Boot project, details core concepts such as variable, constant, parameter, and action libraries, and provides complete code examples for rule sets and decision tables.
This guide walks through setting up MySQL master‑slave replication in Docker, configuring the instances, testing synchronization, then deploying Canal and integrating it with a Spring Boot 2.7.8 application to capture database changes and push them into Redis.
This article introduces a lightweight Redis graphical management tool, outlines its backend (Spring Boot) and frontend (Vue) architecture, provides step‑by‑step installation instructions including Docker usage, describes current features like multi‑user management and permission control, and shares future development plans with screenshots and the project repository link.
This document introduces a lightweight Redis graphical management tool, outlines its Spring Boot backend and Vue frontend architecture, provides step‑by‑step installation instructions including Docker deployment, details recent feature enhancements such as multi‑user support and permission control, and mentions future plans for clustering and sentinel modes.
TLog is a near‑zero‑intrusion logging framework that automatically tags logs with traceId and other context information, enabling fast end‑to‑end request tracing across microservices, supporting various integration methods, async threads, RPC, HTTP clients, gateways, MQ, and common task schedulers.
This guide explains ten practical ways to enforce robust parameter validation in Spring Boot applications, covering built‑in annotations, custom constraints, server‑side checks, meaningful error messages, internationalization, validation groups, cross‑field rules, exception handling, testing strategies, and client‑side considerations.
This tutorial demonstrates how to create Spring Boot scheduled tasks whose execution intervals can be changed at runtime using either a configurable cron expression or a flexible periodic trigger, complete with code examples and a REST API for updating the schedule.
This article explains the design and implementation of a business operation logging feature in a Spring Boot application, contrasting flawed hard‑coded approaches with a clean AOP‑based solution, and provides full code snippets, configuration, database schema, and testing tips.
This article introduces FACE-UI, a front‑back separated web application that implements facial login by capturing a photo via the browser, sending it to a Spring Boot backend, and using Tencent Cloud's face comparison API for authentication, with full setup instructions and code examples.
This article explains how to design and implement a business operation logging feature using Spring AOP in a Spring Boot project, covering requirement analysis, anti‑pattern pitfalls, AOP design, environment and dependency setup, database schema, annotation and aspect code, and testing procedures.
This article explains how to enable fuzzy search on encrypted sensitive fields such as phone numbers and ID numbers in a MySQL database by using Spring Boot, AOP, tokenized ciphertext mapping tables, and encrypted keyword queries to balance security and query performance.
This article explains how to create a reusable Spring Boot starter for enterprise‑level object storage services by leveraging the Amazon S3 protocol, covering OSS fundamentals, dependency setup, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing with code examples.
This article explains the concept, advantages, design considerations, and step‑by‑step implementation of a multi‑tenant architecture using Spring Boot and Spring Cloud, covering database strategies, tenant isolation, dynamic routing, and deployment scenarios for SaaS applications.
This article introduces the URule rule engine, compares it with other engines, explains its features, demonstrates how to install and configure it in a Spring Boot project, and provides detailed guidance on creating variable, constant, parameter, and action libraries, building rule sets, decision tables, and applying them to real‑world scenarios.
This article presents sixteen practical Spring Boot best‑practice recommendations—including custom BOM management, auto‑configuration, project initialization, code organization, dependency injection, concurrency handling, externalized configuration, logging, testing, and more—to help developers build robust, maintainable microservices efficiently.
This article introduces Sa-Token, a lightweight Java permission authentication framework, explains why it was chosen over Spring Security and Shiro, details its core login and permission APIs, demonstrates integration with Spring Boot and WebFlux, and lists its extensive feature set for modern backend development.
This guide explains how to combine Kubernetes and Spring Boot to implement zero‑downtime releases by configuring readiness and liveness probes, defining graceful shutdown, applying rolling update strategies, setting up horizontal pod autoscaling, integrating Prometheus monitoring, and separating configuration via ConfigMaps for reusable images.
This article explains what circular dependencies are in Spring Boot, describes the symptoms and errors introduced in recent versions, and provides multiple practical solutions—including constructor injection, @Lazy, @DependsOn, and interface segregation—along with clear code examples for each approach.
This article explains the purpose and usage of Spring Boot's four main components—Starter, Autoconfigure, CLI, and Actuator—providing Maven and YAML examples, code snippets, and practical guidance for backend developers to simplify dependency management, bean configuration, command‑line tooling, and production monitoring.
This article walks through the background, core concepts, installation steps, library definitions, rule set creation, decision table usage, and a real‑world promotion scenario for integrating the URule rule engine with a Spring Boot backend, providing code snippets and visual configuration tips.
Spring Boot 3.1.0 introduces a host of enhancements—including automatic configuration for Spring Authorization Server, upgraded HttpClient support, refined Testcontainers integration, new Docker‑Compose capabilities, and updates to Hibernate, Jackson, Mockito, and SSL handling—while also providing detailed Maven and Gradle options for image building.
Spring Boot 3.1 introduces an enhanced Docker Compose module that automatically starts and stops containers, maps service properties without manual duplication, and configures application settings like Redis and MySQL, allowing developers to quickly integrate Docker Compose files into their Spring applications with minimal setup.
Spring Boot 3.1.0 introduces automatic configuration for Spring Authorization Server, upgraded HttpClient 5 support, enhanced Testcontainers management, Mockito 5 integration, Docker Compose integration, SSL configuration improvements, and numerous dependency upgrades such as Hibernate 6.2 and Jackson 2.15, all aimed at simplifying modern Java backend development.
This article introduces the URule rule engine, detailing its background, features, installation steps, core concepts such as library files and rule sets, provides code examples for Spring Boot integration, and discusses practical usage scenarios and decision table configuration.
Learn nine practical methods to access files in a Java project's resources directory—including getResource, getPath, getFile, getResourceAsStream, ClassPathResource, and absolute path techniques—complete with code examples and tips for handling Chinese characters and Spring Boot jar packaging.
This guide demonstrates how to integrate Spring Boot with Redis to implement personal search history, hot search ranking, and sensitive word filtering using a DFA algorithm, including Maven dependencies, YAML configuration, utility classes, service implementations, and controller endpoints with full Java code examples.
New Relic’s 2023 Java Ecosystem Report reveals that Java 11 still dominates production, while Java 17 has exploded with a 430% adoption increase in a year, and enterprises are rapidly modernizing Java applications for cloud‑native environments, driven by maintainability and security concerns.
This article presents a comprehensive set of Spring Boot best practices—including custom BOM management, auto‑configuration, project initialization with Spring Initializr, organized code structure, controller and service design, database isolation, externalized configuration, global exception handling, logging, testing strategies, and concurrency awareness—to help developers build robust, maintainable backend services.
This article presents a step‑by‑step tutorial on building robust Spring Boot backend APIs, covering environment setup, parameter validation techniques, global exception handling, unified response structures, optional response wrapping, API versioning via path or header, and comprehensive security measures such as token authentication, timestamp checks, request signing, replay protection, and HTTPS.
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 article introduces OKHttpUtil, a concise Java wrapper for the OkHttp library, outlines its key features, provides Maven dependency instructions, demonstrates GET, POST, file upload, download, and chained request usage, and shows how to integrate and configure it in Spring Boot as well as quickly build external API clients such as eBay.
This tutorial provides a complete step‑by‑step guide to set up a Jenkins server inside Docker on CentOS, configure Maven and plugins, create a pipeline that builds a Spring Boot project, builds a Docker image with a Dockerfile, and runs the container automatically, covering all common pitfalls.
This article introduces the URule rule engine, explains how to install and configure its open‑source version with Spring Boot, describes its core concepts such as variable, constant, parameter, and action libraries, and demonstrates rule set and decision table creation for real‑world business scenarios.
This article demonstrates how to consolidate user login permission checks, exception handling, and unified JSON response structures in a Spring Boot application by using AOP, custom HandlerInterceptor, @ControllerAdvice, and ResponseBodyAdvice, providing complete code examples and implementation details.
Encountering a java.lang.IllegalArgumentException: Request header is too large? This guide explains the root cause—oversized HTTP headers—and offers two practical solutions: adjusting the server’s max‑http‑header‑size setting in Spring Boot and redesigning requests to keep header data minimal.
This guide walks you through converting a Spring Boot JAR into a Windows executable using exe4j and then packaging it with its bundled JRE into an installer via Inno Setup, enabling users to run the application on machines without any Java runtime installed.
This article demonstrates how to implement end‑to‑end traceable logging in a Spring Boot application by configuring Logback, creating a request interceptor that injects a TRACE_ID, propagating the ID across thread pools with custom executors and MDC utilities, and verifying the solution with sample controller code and log output.
This article introduces a Spring Boot library that uses a configuration annotation to enable WebSocket load balancing across microservice instances, explains its abstract design, connection management, message routing, and provides usage examples with code snippets while also mentioning related promotional content.
This article explains how to configure Spring Boot 2.7.10 for AMQP‑based RabbitMQ and Apache Kafka messaging, covering property settings, connection factories, template customization, sending and receiving messages, listener containers, retry mechanisms, and stream processing with code examples.
This article explains why using the violent kill -9 command can corrupt data in Java services, describes the four‑step graceful shutdown process, and provides multiple Spring Boot solutions—including SIGTERM, Actuator shutdown endpoint, custom Tomcat connector, and @PreDestroy data‑backup hooks—to stop services safely while handling thread interruptions.
This article introduces a Spring‑Boot library that uses a configuration annotation to enable WebSocket load‑balancing across microservice instances, detailing its usage, abstract design, connection management, message routing, and extensibility for various long‑connection protocols.
An in‑depth tutorial demonstrates building a Netty‑based TCP client with Spring Boot, covering project architecture, module layout, message‑queue simulation, detailed Java code for client creation, connection handling, and testing endpoints, providing a complete, production‑ready demo for IoT socket communication.
This article demonstrates how to achieve cache‑database consistency by updating MySQL first, deleting Redis cache asynchronously via Canal, publishing change events to RabbitMQ, and handling acknowledgments manually in a Spring Boot application, complete with configuration steps and troubleshooting tips.
This guide shows how to use Alibaba Cloud MSE to non‑intrusively add service registration, discovery, and governance—including full‑chain gray release—to existing Spring Boot applications, with step‑by‑step instructions, demo setup, and practical code snippets.
This article explains the concept and purpose of Spring Boot starters, compares mybatis‑spring with mybatis‑spring‑boot‑starter through code examples, and details how the starter simplifies MyBatis integration by handling dependencies, configuration files, auto‑configuration, and mapper scanning for Java backend projects.
This article provides a step‑by‑step tutorial on building robust Spring Boot backend APIs, covering environment setup, parameter validation techniques, global exception handling, unified response structures, API version control, and security measures such as token authentication, timestamp checks, URL signing, replay protection, and HTTPS.
This article provides a detailed tutorial on building robust Spring Boot backend APIs, covering interface structure, environment setup, parameter validation methods, custom validators, global exception handling, unified response formats, optional response wrapping, API version control, and security measures such as token authentication and request signing.
This guide walks you through preparing an OpenAI account, obtaining an API key, using the Completion endpoint with example JSON, calling the API from plain JavaScript/HTML, and integrating the same service into a Spring Boot application with Maven dependencies and Java code.
Learn how to set up a complete CI/CD pipeline on CentOS 7 by installing Docker and Jenkins, configuring Maven, creating a Jenkins job, and using a Dockerfile to automatically build and run a Spring Boot application with a single click.
This tutorial explains how to integrate the Drools business rule engine into a Spring Boot project to calculate flexible e‑commerce discounts based on customer type, age, and order amount, showing dependency setup, configuration, model definitions, DRL rules, service and controller layers, and a test run.
This article provides a detailed tutorial on Spring Validation, covering basic dependency setup, requestBody and requestParam/PathVariable validation, advanced techniques such as group, nested, collection and custom validation, programmatic validation, fail‑fast mode, the difference between @Valid and @Validated, and the underlying implementation mechanisms within Spring MVC.
This guide explains how to use Spring Retry’s @Retryable and @Recover annotations in Spring Boot, covering dependency setup, enabling retries, annotating methods, configuring backoff policies, handling exhausted retries, and important precautions for reliable backend retry mechanisms.
PowerJob is a modern distributed scheduling and computation framework that supports various timing strategies, workflow orchestration, multiple execution modes, and a rich set of processors, offering a user‑friendly web UI, high availability, and easy integration with Spring Boot projects.
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.
