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.
This tutorial demonstrates how to integrate Spring Boot with the Activiti workflow engine, covering essential operations such as querying tasks, suspending, activating, and deleting process instances, and provides complete Java code snippets and controller endpoints for each function.
This tutorial walks through setting up a Spring Authorization Server in a Spring Boot servlet project, adding required dependencies, configuring filter chains, persisting OAuth2 clients, authorizations, and consents with JDBC, and defining JWK sources and provider settings for a complete OAuth2 authorization server.
This extensive tutorial explains Spring Boot’s core mechanisms—including the IoC container, class loading, SpringFactoriesLoader, event publishing, and automatic configuration—through detailed explanations and code examples, helping developers understand and extend Spring Boot’s startup process.
This article demonstrates how to achieve automatic request idempotency in Spring Boot applications by leveraging Redis for token storage, custom annotations, and a handler interceptor, detailing the underlying concepts, code implementation, configuration, and testing procedures to prevent duplicate processing.
This article explains how to achieve reliable API idempotency in Spring Boot applications by using Redis for token storage, defining a custom @AutoIdempotent annotation, configuring an interceptor to enforce token checks, and providing complete Java code examples and testing steps.
This article introduces MyBatis‑Mate, an official MyBatis‑Plus extension that provides enterprise‑grade features such as sharding, data auditing, field encryption, sensitive data masking, dictionary binding, dynamic DDL maintenance, and flexible data‑source switching, complete with usage examples and code snippets.
This article explains how to prevent data leaks by encrypting configuration files and masking sensitive fields in Spring Boot applications using Jasypt, covering Maven setup, encryption/decryption methods, custom annotations, AOP implementation, and the underlying PBE algorithm details.
This article explains how to package a Spring Boot application into a Docker image using Jib, install the Spring Boot Operator, and manage the application lifecycle on Kubernetes—including deployment, scaling, graceful shutdown, node affinity, and custom operator configuration—through detailed code examples and YAML manifests.
This tutorial shows how to quickly add GraphQL support to a Spring Boot web project by creating a Maven project, adding custom dependencies, defining schema files, implementing resolvers and a controller, and testing query and mutation endpoints, all without using the official graphql‑java‑tools starter.
This article explains how to perform elegant parameter validation in Spring Boot by distinguishing controller‑level and service‑level checks, introduces Hibernate Validator annotations, demonstrates their usage with code examples, and shows additional utilities like commons‑lang3 and custom validation annotations for robust backend development.
This article explains why rate limiting is needed for high‑traffic Java services, reviews common throttling techniques such as Hystrix, Sentinel, token‑bucket algorithms, and then provides multiple concrete implementations—including Guava RateLimiter, Redis counters, interceptor configuration, and Tomcat connector settings—complete with code samples.
This article outlines the full sequence of Spring Boot application events—from ApplicationStartingEvent at launch to ApplicationFailedEvent on errors—explaining when each event fires, its purpose, and providing code snippets that illustrate the event triggers within the SpringApplication lifecycle.
This article explains how to implement delayed message delivery in RabbitMQ using the official delayed‑queue plugin and Spring Boot, covering configuration of exchanges, queues, bindings, message publishing with delay headers, and consumer handling, along with code examples and test results.
This tutorial explains how to implement read/write splitting in Spring Boot by configuring multiple data sources, creating a custom AbstractRoutingDataSource, and using AOP to dynamically route queries to master or slave databases based on method patterns and annotations.
This article explains three practical Redis-based rate‑limiting techniques—using SETNX for simple counters, ZSET for a sliding‑window algorithm, and a token‑bucket implementation with List—complete with Java code examples and discussion of their advantages and drawbacks.
This article demonstrates how to extend MyBatis-Plus to support ClickHouse-specific DML operations by defining custom SQL method enums, implementing UpdateByIdClickHouse and ClickHouseSqlInjector classes, creating a SuperMapper interface with new CRUD methods, and providing unit tests to verify the integration.
This article walks through the challenges of multi‑user WebSocket communication in a clustered environment and presents two practical solutions—session broadcasting and a consistent‑hashing based routing—using Spring Boot, Spring Cloud Gateway, Redis, Netty, and Ribbon to achieve scalable, reliable real‑time messaging.
This article demonstrates three practical techniques for retrieving Spring-managed beans inside static methods—using @PostConstruct initialization, a static ApplicationContext from the main class, and a manual ApplicationContextAware component—complete with code examples and usage guidelines.
This article explains how to add a reusable appkey whitelist check to a Spring‑Boot web framework by comparing four implementation methods—traditional AOP, Spring Interceptor, custom ArgumentResolver, and Servlet Filter—detailing their code, configuration steps, extensions, and execution order.
This article explains how to seamlessly integrate JSR‑303 Bean Validation with Spring Boot, covering the underlying concepts, required dependencies, built‑in and Hibernate‑specific constraints, simple, group and nested validation techniques, result handling, the role of spring‑boot‑starter‑validation, and how to create custom validation annotations and validators.
This article explains three techniques for obtaining Spring beans inside static methods—using @PostConstruct initialization, a static ApplicationContext stored in the main class, and implementing ApplicationContextAware—complete with code examples and detailed guidelines for the @PostConstruct annotation.
Explore Spring Web MVC's functional programming model (WebMvc.fn) in Spring Boot 2.4.12, covering immutable ServerRequest/ServerResponse, RouterFunction routing, handler functions, predicates, nested routes, filters, validation, and practical code examples for building clean, annotation‑free REST endpoints.
This article demonstrates how to extend MyBatis‑Plus to support ClickHouse-specific SQL operations by creating custom enum definitions, method classes, a SQL injector, a super mapper interface, and accompanying unit tests, enabling update, delete, and logical delete functionalities that differ from standard MySQL behavior.
This article explains how to install and configure JRebel for both local and remote hot deployment in Spring Boot projects, compares it with Spring DevTools, and provides step‑by‑step instructions, code snippets, and troubleshooting tips for multi‑module applications.
This article explains how to design and implement a points‑based lottery (luck draw) system in Java with Spring Boot, covering database schema for prizes, probability limits, prize pools, the random draw algorithm, prize restrictions, and asynchronous prize distribution using a factory pattern.
This guide explains Spring MVC's request handling flow, detailing core components like DispatcherServlet, HandlerMapping, and HandlerAdapter, and demonstrates multiple controller definitions—including @RestController, HttpRequestHandler, Controller interface, and HttpServlet extensions—along with necessary configuration snippets.
This article explores practical approaches for enabling multi‑user communication in a distributed WebSocket cluster, covering session handling challenges, architecture design, technology stack choices, Netty versus Spring WebSocket implementations, consistent‑hashing load balancing, and detailed code examples for Spring Cloud Gateway and Ribbon integration.
This tutorial shows how to quickly set up GraphQL in a Spring Boot web project by creating the project, adding Maven dependencies, defining schema files, implementing providers and resolvers, exposing a GraphQL endpoint, and testing query and mutation operations.
This article explains three practical ways to retrieve Spring beans from static methods—using @PostConstruct annotation, a static ApplicationContext defined in the main class, and a manually injected ApplicationContext via ApplicationContextAware—complete with code examples and usage notes.
This article explains the internal workflow of Spring MVC’s HandlerMethodArgumentResolver for processing controller method parameters, walks through the core source code steps, and demonstrates how to implement and register a custom argument resolver using a bespoke annotation.
This article provides a detailed analysis of HikariCP’s initialization, core components, startup flow, connection acquisition logic, monitoring metrics, and key configuration parameters, illustrating how Spring Boot 2.x leverages this high‑performance JDBC connection pool and offering guidance for tuning and extending it.
This article explains how to place parameter validation in the appropriate layer, introduces Hibernate Validator with Maven dependencies and common annotations, provides a validated entity example, shows controller usage with @Valid/@Validated, and demonstrates useful Commons‑Lang3 utilities for string and collection checks.
This article provides an English overview of Spring Boot’s core functionalities—including standalone JAR execution, embedded servlet containers, starter POM simplification, auto‑configuration, production‑ready monitoring, and code‑free XML—while also discussing its pros and cons, key features, CLI tool, Maven parent, and commonly used annotations.
This article explains how to design a QR‑code login flow using a MySQL table, defines the involved roles, outlines required REST and WebSocket interfaces, and provides complete Spring Boot backend and JavaScript frontend code examples for generating QR codes, validating tokens, and notifying the client in real time.
This guide explains how to configure and use Spring Bean Validation, demonstrates simple and method‑level validation, and shows how to create custom constraint annotations with full code examples for a Spring Boot 2.4.11 application.
