Spring Boot 3.0.0 M1, released on January 20 2022, upgrades the Java baseline to Java 17, migrates all Java EE APIs to Jakarta EE, drops support for several components, updates numerous Spring and third‑party dependencies, and outlines the upcoming release schedule.
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.
This article explains how to handle a PC‑triggered device upgrade record by using Quartz for timed execution and Spring Batch for bulk processing, detailing Maven dependencies, YAML configuration, service and batch classes, custom reader/writer logic, a processor that calls an upgrade‑dispatch API, and the overall challenges encountered.
This guide walks you through designing a simple front‑back separation microservice architecture, implementing it with Java Spring Boot, deploying multiple instances with Eureka, adding Prometheus‑Grafana monitoring, logging, tracing, flow control, and finally installing Kubernetes using K8seasy and verifying high‑availability across the cluster.
This guide walks through analyzing and optimizing cold‑start latency for a Spring Boot e‑commerce app on Alibaba Cloud Function Compute,{} covering tracing, reserved instances, lazy initialization, JVM tuning, and instance concurrency settings to improve performance.
This article explains how to monitor, collect, and analyze real‑time logs, use multi‑dimensional metrics, perform local debugging, and enable cloud‑edge debugging for Spring Boot applications running on a Serverless platform, providing step‑by‑step commands and visual guides.
This article investigates MySQL's recommendation to avoid UUIDs as primary keys by benchmarking auto‑increment, UUID, and random snowflake IDs using Spring Boot and JdbcTemplate, analyzing insert speed, InnoDB index behavior, and the trade‑offs of each key strategy.
This guide walks through using Serverless Devs to collect real‑time logs, query metrics, perform local debugging, and enable cloud‑edge debugging for a Spring Boot e‑commerce application running on Alibaba Cloud Function Compute, with step‑by‑step commands and screenshots.
This article explains how to use Spring Batch together with Quartz to periodically process device upgrade records, covering Maven dependencies, configuration files, service implementation, batch job and step definitions, a custom processor for HTTP dispatch, entity mapping, and job retry scheduling for failed updates.
This guide walks you through installing Spring Boot Admin, configuring a monitoring server, adding the client starter to a Spring Boot application, enabling Actuator for expanded metrics, and using SBA to view health, JVM, logs, and real‑time performance data across single or clustered services.
This article explains the principles and workflow of Single Sign-On (SSO) using OAuth2.0, illustrates the process with a real‑life scenario, compares multi‑point and single‑point login, and provides a complete Spring Boot example for building an authorization server, client, and role‑based access control in micro‑service architectures.
This article explains four distinct approaches to register Spring Boot event listeners, shows how to create custom events and listeners, provides complete code examples for each method, and demonstrates their execution order through a test run.
This guide explains how to use Alibaba Cloud's Application High Availability Service (AHAS) with Sentinel to implement fine‑grained traffic control, hotspot detection, concurrency limits, circuit breaking, and fallback handling for Java and Go web applications, illustrated with a Spring Boot example.
This article explains why multiple Spring Boot timers can conflict due to single‑threaded execution, demonstrates the problem with example outputs, and shows how to configure a thread pool and use @Async annotations to run timers concurrently, preventing bottlenecks and avalanche effects.
This article demonstrates how to use Redis key‑expiration notifications together with Spring Boot to automatically close orders that remain unpaid after a configurable timeout, eliminating inefficient polling and providing a clean backend solution for order lifecycle management.
This guide introduces MongoDB fundamentals and demonstrates how to integrate it with Spring WebFlux to create a fully reactive CRUD service, covering dependencies, configuration, entity definitions, repository interfaces, service logic, and controller endpoints.
This article explains what MDC is, its API, advantages, common issues like traceId loss in child threads and HTTP calls, and provides practical solutions using custom thread‑pool wrappers and HTTP interceptors to ensure reliable logging in Spring Boot applications.
This article provides a step‑by‑step guide for integrating email functionality into a Spring Boot application, covering SMTP/IMAP/POP3 basics, configuring JavaMailSenderImpl, sending simple and MIME messages with attachments, and includes full source code examples and troubleshooting tips.
This article explains the concepts, architecture, communication flow, and implementation details of a custom RPC framework built with Spring Boot, Netty, and Zookeeper, covering service registration, load balancing, custom message protocols, serialization, TCP handling, and deployment steps.
magic-api is a Java‑based rapid API development framework that lets developers create HTTP interfaces through a UI without writing Controllers, Services, DAOs, or XML, offering extensive database support, dynamic scripting, Swagger generation, and easy Spring Boot integration.
This guide walks through setting up Spring Security for WebFlux, covering Maven dependencies, reactive security beans, password encoding, filter chain rules, functional routing, and method‑level authorization with complete code examples for a Spring Boot 2.5.8 project.
mica‑mqtt, built on t‑io, offers a simple, low‑latency, high‑performance open‑source MQTT component that integrates easily into existing services, supports multiple protocols and deployment scenarios, and includes Spring Boot starter, GraalVM compilation, and Redis‑based clustering for robust IoT solutions.
This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean and dependency‑injection annotations, and essential Spring Boot configuration annotations, illustrating their usage with code examples and explaining how they work together to build robust backend applications.
This article explains how to protect a Spring Boot API from traffic spikes by applying common rate‑limiting algorithms, configuring Redis for distributed throttling, writing Lua scripts for atomic counters, and integrating a custom @Limit annotation with AOP to enforce limits across a cluster.
This article explains how to use Maven profiles and the maven‑assembly‑plugin to create environment‑specific zip packages for a Spring Boot application and provides a reusable shell script (shenniu_publish.sh) for extracting, starting, stopping, and managing the deployed JAR on Linux.
This article provides a comprehensive overview of Seata, covering its origins, supported transaction modes, installation steps, database initialization, detailed configuration for registry and Apollo, client setup, transaction lifecycle components, and scheduled tasks that manage global and branch transaction states.
This article demystifies Single Sign-On using OAuth2.0 by illustrating the authentication and authorization flow through a real‑world analogy, explaining HTTP redirects, detailing the four grant types, and providing a complete Spring Boot implementation with role‑based access control for both client and server sides in microservice architectures.
This tutorial explains how to deploy a Spring Boot‑based monitoring solution that tracks multiple remote JVMs, covering repository cloning, configuration of server and client properties, Maven installation of the starter jar, and running the monitor‑server with example code snippets and screenshots.
This guide explains the technical stack, deployment steps, and core features of the open‑source wx‑manage system for managing multiple WeChat public accounts, including backend setup, database initialization, and frontend launch.
This guide demonstrates how to configure and execute ServiceTask nodes in Activiti 7.1 within a Spring Boot 2.3.12 application, covering service class implementation, three configuration methods (direct class, delegate expression, Spring bean method), BPMN XML definition, and a REST endpoint to start the process.
This article explains why Spring Boot's default scheduled tasks run on a single thread and demonstrates three practical ways to configure multithreaded scheduling using SchedulingConfigurer, application properties, and the @Async annotation with a custom thread pool.
This tutorial explains how to achieve automatic API idempotency in Spring Boot by leveraging Redis for token storage, creating a custom @AutoIdempotent annotation, configuring an interceptor to validate tokens, and providing complete code examples and test cases to prevent duplicate operations.
This step‑by‑step guide shows how to prepare a VM, clone the open‑source Mall project, build Docker images for its dependencies, push them to Alibaba Cloud Container Registry, configure Serverless Devs, and finally deploy both the backend and Vue‑based frontend to Alibaba Cloud Function Compute, including log inspection and verification.
This article explains the concept of Spring Boot starters, how they replace cumbersome Spring MVC setup with automatic dependency import and configuration, details the inner workings of Spring Boot's auto‑configuration mechanism, and guides you through creating custom starters and publishing them as reusable modules.
Learn how to replace Spring Boot 2.x's default Logback logging with the high‑performance Log4j2 by adding the starter dependency, configuring the logging file, and setting up a basic log4j2.xml, including code snippets and troubleshooting tips for a smooth migration.
This article explains what Spring Boot Admin is, walks through creating a server and client to monitor Spring Boot applications, shows how to configure ports, enable the admin UI, and set up email and custom alert notifications for operational health monitoring.
This article explains how HikariCP, the default Spring Boot 2.x connection pool, improves database performance through byte‑code optimization, custom containers, and streamlined code, and it details the internal classes, lifecycle methods, configuration, monitoring, and practical usage examples.
This tutorial walks you through setting up Spring Boot to send simple and complex emails, covering SMTP/IMAP/POP3 basics, JavaMailSender configuration, code examples for plain text and attachment emails, auto‑configuration details, a REST controller, Thymeleaf UI, testing steps, and common SMTP error codes.
This article explains how PolarisMesh, Tencent's open‑source service discovery and governance platform, solves service address management and fault tolerance challenges in a Spring Boot microservice ecosystem, and provides step‑by‑step instructions—including Maven dependency, provider and consumer configuration, and sample code—to quickly integrate PolarisMesh via Feign.
This article explains the OAuth2 authorization framework, illustrates its principles with a delivery‑person analogy, details the four main grant types, and provides a step‑by‑step Spring Boot implementation including server configuration, resource protection, and Postman testing.
This article introduces Caffeine Cache as a high‑performance local cache for Java, explains its W‑TinyLFU algorithm advantages over Guava, details various eviction and loading strategies, and provides step‑by‑step Spring Boot integration with Maven dependencies, configuration properties, bean definitions, and annotation‑driven usage examples.
This tutorial explains how to use parallel gateways in Activiti 7 with Spring Boot, covering their branching and merging functions, a complete reimbursement‑approval example, BPMN XML definition, and Java code for starting, querying, and approving workflow tasks.
Spring Boot 2.6.0 introduces several important changes such as default prohibition of circular dependencies, custom sanitizing functions, automatic Redis connection‑pool activation, moved reactive session properties, Maven build‑info exclusions, WebTestClient support for MVC testing, and Log4j2 composite configuration options.
Logback’s CVE‑2021‑42550 affects versions below 1.2.9, allowing attackers with write access to the configuration file to execute arbitrary code via LDAP, but its severity is rated Medium; upgrading to 1.2.9 or newer, setting config files read‑only, and aligning Spring Boot versions can mitigate the risk.
This guide explains how to replace inefficient cron polling with RocketMQ's delayed message feature in Spring Boot, covering the core concept, configuration, producer and consumer implementation, testing, and how to customize delay levels for reliable time‑sensitive operations.
This article explains how to implement scheduled tasks in a Spring Boot application using RabbitMQ delayed queues, detailing the use of dead‑letter exchanges, message TTL settings, queue configuration, and Java code examples for publishing and consuming delayed messages.
Spring Boot 2.5.8 and 2.6.2 were released on December 22, bringing extensive bug fixes, documentation improvements, and a wide range of library upgrades—including Log4j2—while providing clear upgrade guidance for developers using the framework.
Spring Boot 2.6.2, released on December 21, introduces 55 bug fixes, documentation improvements, and a comprehensive set of dependency upgrades, providing developers with more stable configuration binding, corrected database initialization, enhanced security handling, and updated libraries across the ecosystem.
This article explains how to replace database‑polling scheduled jobs in e‑commerce systems with RabbitMQ delayed queues by leveraging dead‑letter exchanges and message TTL, providing step‑by‑step configuration, code examples, and deployment details for Spring Boot applications.
This article provides a comprehensive tutorial on creating Spring Cloud microservices, covering the fundamentals of microservice architecture, project initialization with Maven and IntelliJ, configuring Eureka registration servers, implementing service providers and consumers, using Ribbon and Feign for load‑balanced calls, and setting up high‑availability Eureka clusters.
Spring Boot Admin 2.5.5 is now available via Maven, bringing online restart support, Mac M1 compatibility, enhanced exception emails, paginated event logs, and several critical bug fixes including audit log loss and a log4j security issue.
This guide demonstrates how to configure Activiti 7 with Spring Boot to assign multiple candidate approvers for a task, implement a service that supplies candidate user IDs, expose controller endpoints to start and complete the process, and troubleshoot common security‑related errors.
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 article explains how to achieve hot deployment in Spring Boot by disabling template engine caches for Thymeleaf, FreeMarker, Groovy, and Velocity, using Debug mode, adding spring-boot-devtools, and optionally employing Spring Loaded or JRebel for more comprehensive live reloading.
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.
Spring Cloud 2020.0.5, a bug‑fix release compatible with Spring Boot 2.4.x and 2.5.x, is now available from the central repository, and includes updated dependencies, component version tables, and detailed changelogs for modules such as Netflix, Config, Gateway, Kubernetes, OpenFeign, Sleuth, and Vault.
This article examines the Log4j2 critical vulnerability, explains why merely having log4j‑api does not guarantee exposure, demonstrates step‑by‑step reproduction in a Spring Boot project, analyzes the JNDI injection mechanism, and outlines temporary mitigations and official fixes.
This article explains why RESTful API versioning is needed, presents four common versioning strategies (URI, request parameter, custom header, and media type), and provides complete Spring Boot code examples for each method along with factors to consider when choosing a strategy.
This article compares the three popular Java Redis clients—Jedis, Redisson, and Lettuce—detailing their differences in threading, I/O, and feature sets, and provides comprehensive Spring Boot configuration and code examples for using StringRedisTemplate, RedissonClient, and Spring Cache annotations to implement caching and distributed locks.
This article explains why traditional Excel export methods cause memory overflow, introduces Alibaba's EasyExcel library that keeps memory usage in kilobytes, and provides step‑by‑step Maven setup, POJO definitions, and code examples for exporting small, medium, and massive data sets in a Spring Boot environment.
This article explains four approaches for implementing Spring Boot event listeners—including manual registration, component scanning, properties configuration, and @EventListener annotation—while also covering how to create custom events and listener classes with complete code examples.
Learn how Bean Searcher enables Java backend developers to replace dozens of lines of ORM code with a single, flexible query method, supporting multi-table joins, dynamic filters, pagination, sorting, and custom operators, dramatically boosting development efficiency for complex list retrieval scenarios.
This guide walks through configuring custom and multiple data sources, using Spring Data repositories, fine‑tuning JPA and Hibernate settings, customizing naming strategies, enabling second‑level caching, and exposing repositories as REST endpoints in a Spring Boot 2.4.13 application.
Apache Log4j 2.16.0 introduces default JNDI disabling, stricter protocol limits, and the removal of Message Lookups to harden security, and Spring Boot users can upgrade by globally adjusting the log4j2 version, with detailed steps illustrated in the accompanying image.
With hardware costs dropping, many default to Redis for caching, but it isn’t always optimal; this article examines EhCache—a pure‑Java, in‑process cache—covering its architecture, eviction policies, API and XML configurations, and step‑by‑step Spring Boot integration, helping you decide when to prefer it.
This article analyzes a Spring Boot startup failure caused by a conflict between @Autowired and @DubboReference annotations when injecting the same service bean, explaining the underlying mechanism and providing solutions.
The author describes encountering quality‑assurance challenges in Spring Boot, revisiting unit‑testing frameworks like Spock, Mockito, and PowerMock, struggling with static‑method mocking, and ultimately adopting a "reset and rebuild" strategy to resolve dependency conflicts and improve test coverage.
This article introduces the retrofit‑spring‑boot‑starter library, shows how to add the Maven dependency, configure @RetrofitScan, define HTTP interfaces, inject them into services, and demonstrates advanced features such as annotation‑based interceptors, custom interceptors, connection‑pool management, logging, exception formatting, call adapters, converters, and global interceptors for Spring Boot projects.
This guide thoroughly explores Spring Validation, covering basic and advanced usage such as requestBody and requestParam checks, grouping, nested and collection validation, custom constraints, programmatic validation, fail-fast configuration, and the underlying implementation mechanisms within Spring MVC and Hibernate Validator.
The article introduces eladmin, an open‑source, front‑back separated admin platform built with Spring Boot, JPA, Spring Security, Redis and Vue, detailing its features, modular architecture, key functionalities, highlights, and providing a link to its GitHub repository.
This article provides a step‑by‑step tutorial on using Spring Boot Actuator to monitor microservice applications, covering quick setup, essential endpoints such as health, metrics, loggers, info, beans, heapdump, threaddump and shutdown, endpoint exposure configuration, and securing them with Spring Security.
This article explains how to implement a Redis distributed lock using Jedis in Java, covering lock creation with SETNX, expiration handling, lock deletion via Lua scripts, and a high-concurrency flash‑sale simulation with 100,000 parallel users.
This article explains why Spring Boot's default single‑threaded scheduler can cause timer conflicts in real‑world applications and demonstrates how adding @Async annotations together with a custom ThreadPoolTaskExecutor configuration enables concurrent execution of multiple scheduled tasks.
This comprehensive guide explains the principles, pitfalls, and best practices of implementing Redis distributed locks, covering basic SETNX usage, lock timeout handling, re‑entrant locks, Redlock algorithm debates, and practical Redisson integration with Spring Boot.
This article walks through writing a simple Java program, compiling it with javac, then using GraalVM's native-image tool to produce a JVM‑independent executable, compares file size and startup speed, discusses native-image limitations, and shows how Spring Boot can be built as a native image for dramatically faster startup.
FlyCms is an open‑source, Java‑based, Q&A‑style CMS built on Spring Boot, MySQL, Redis, Elasticsearch and Vue, and this guide walks you through its architecture, key features, required environment setup, installation commands, configuration, building, and launching the application.
This open‑source project implements a Spring Boot and Maven based license‑plate detection and training system in Java, leveraging OpenCV and JavaCPP, supporting multiple plate colors, SVM and ANN algorithms, and providing a B/S architecture with SQLite, Swagger documentation, and extensible image‑recognition features.
The article presents a detailed overview of the open‑source eladmin project, describing its Spring Boot‑based backend, Vue front‑end, modular architecture, RBAC permission model, code generation, and various built‑in features such as logging, monitoring, and cloud storage integration.
Spring Cloud 2021 (Jubilee) has been officially released, built on Spring Boot 2.6.x, introducing updated core components, new features like Redis routing, HTTP/2 and gRPC support, and important compatibility notes for Spring Boot and Spring Cloud Alibaba users.
This article explains how to integrate Elasticsearch into a Spring Boot project, covering version compatibility, supported access methods, dependency setup, configuration, entity mapping with annotations, repository creation, and unit testing to verify successful indexing and retrieval.
This tutorial explains how to install Docker, pull and run a FastDFS Docker image, verify the deployment, and then integrate FastDFS with Spring Boot by adding Maven dependencies, configuration files, and a Java utility class for file operations.
This tutorial walks through building a Spring Boot application with Apache Shiro, covering core concepts, database schema design, Maven dependencies, configuration files, entity and DAO layers, service implementations, Shiro realm and security configuration, login handling, role and permission testing, and future extension ideas.
This article explains why OAuth2.0 is needed, clarifies the differences between tokens and passwords, describes the OAuth2.0 protocol and its four grant types, and provides a step‑by‑step Spring Boot + Spring Cloud Alibaba implementation of an authorization server and a resource server with full code examples.
This guide explains how to use Spring Boot's programmatic transaction APIs—including TransactionTemplate, TransactionManager, and transactional event listeners—through detailed code examples, configuration tips, rollback handling, and best‑practice recommendations for backend Java development.
This tutorial demonstrates how to implement Redis distributed locks in Java using Jedis, covering lock creation with SETNX, expiration handling, safe unlocking via Lua scripts, and a high‑concurrency simulation of 100,000 users competing for limited stock.
Spring Boot 2.6.1, released on November 29, brings 11 bug fixes and documentation improvements to support the upcoming Spring Cloud 2021, addressing issues from pattern parsing to security filters, Lettuce integration, MockMvc configuration, and Elasticsearch dependency handling.
The mica‑mqtt library, built on t‑io, offers a simple, low‑latency, high‑performance open‑source MQTT solution for IoT, supporting MQTT v3.1/v3.1.1/v5, WebSocket sub‑protocol, HTTP API, clustering via Redis, Spring Boot starter integration, Prometheus/Grafana monitoring, and provides extensive client and server interfaces with code examples.
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 article demonstrates how to achieve automatic request idempotency in Spring Boot applications by leveraging Redis for token storage, custom annotations, and interceptor configuration, providing step-by-step code examples for building a Redis service, token service, custom annotation, interceptor, and testing the solution.
The article explains what Spring Boot application starters are, enumerates all 44 available starters with brief descriptions of their functionality, and invites readers to share the content and join a community for further architectural learning.
A colleague reported that a MyBatis insert stored a timestamp from the previous day, leading to a deep investigation that revealed mismatched timezone handling between MySQL, the JDBC driver, and Java, and presented two practical fixes to align all components.
This article explains how to build a QR‑code based login system by designing a token table, defining roles, creating two REST APIs (generate QR code and confirm identity), and integrating front‑end JavaScript with a Spring Boot WebSocket server, complete with full code examples and step‑by‑step instructions.
A Spring Boot channel service suffered an unexplained 100 ms extra latency, which was traced using Arthas to Tomcat’s handling of META‑INF resources from Swagger’s JAR, and the issue was resolved by upgrading the embedded Tomcat version.
This guide demonstrates how to integrate GitLab, Jenkins, Docker, Kubernetes, and Helm to achieve fully automated, environment‑specific deployments for Spring Boot backend services and Vue.js front‑end applications, covering configuration files, pipeline scripts, credential setup, and webhook integration for seamless CI/CD across development, testing, and production.
This guide walks you through setting up a comprehensive logistics and warehouse management system using Spring Boot and Jeecg‑boot, covering required environment versions, technology stack, database configuration, backend and frontend setup, and deployment steps with detailed screenshots and code snippets.
This guide explains how to use Alibaba's EasyExcel library for efficient, low‑memory Excel import and export in Java, covering its core features, common annotations, Maven dependencies, listener implementation, and practical code examples for both HTTP‑based and local file operations.
This article explains the difference between synchronous and asynchronous method calls in Java, demonstrates how to implement synchronous tasks, convert them to asynchronous using Spring Boot's @Async annotation, and shows how to coordinate completion with Future objects and unit tests.
Spring Boot 2.6.0 introduces major updates such as SameSite cookie support, health group configuration for main and management ports, enhanced /info endpoint with Java runtime details, WebTestClient testing, automatic spring‑rabbit‑stream setup, custom env/configprops sanitizing, new metrics, Docker build improvements, and default prohibition of circular bean references.
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.
Spring Boot 2.6 introduces Cookie SameSite support, reactive session timeout, custom data‑masking rules, automatic Redis pool configuration, richer runtime Java metrics, build‑info personalization, new startup and disk metrics, enhanced Docker image building, and many deprecated properties removed or renamed, improving security and performance.
