This article explains how to enable and configure Spring Boot's @Async annotation, provides code examples for thread‑pool setup and asynchronous service methods, and discusses important caveats such as calling async methods from the same class, transaction incompatibility, blocking issues, and exception handling.
This tutorial walks you through adding MongoDB dependencies to a Spring Boot project, configuring the connection, defining entity and repository classes, implementing service and controller layers, and optionally setting up sharding or replica‑set architectures for scalable data management.
This article explains how to implement a memory-efficient sign-in system and continuous-sign-in statistics using Redis BitMap, covering basic BitMap commands, Spring Boot integration, core source code, and a BitMap-based approach to mitigate cache-penetration attacks.
This article demonstrates how to integrate Project Loom virtual threads into a Spring Boot application, configure Maven and Tomcat, implement REST endpoints, run JMeter load tests, and compare response times between traditional and virtual threads to showcase significant performance improvements.
Redis Sorted Sets, powered by skip lists, provide O(log n) operations for ranking and range queries; this article explains their internal structure, core commands, and demonstrates how to implement a real‑time leaderboard in Spring Boot using Redis, complete with configuration, entity design, and service methods.
This article explains the concepts of pessimistic and optimistic locking, compares their use cases, demonstrates version‑based and CAS implementations, and shows a complete Spring Boot example with retry‑enabled optimistic lock handling using AOP and custom annotations.
This article explains the concept and inner workings of Spring Boot Starters, demonstrates how they simplify dependency management and auto‑configuration, and provides a step‑by‑step guide to creating and using a custom Starter with full code examples.
This article compares Spring Boot and Quarkus, detailing their architectures, reactive capabilities, native image support, and performance metrics from JMeter and VisualVM tests, while also offering migration guidance for developers moving from Spring to the Kubernetes‑native Quarkus framework.
This article compares Spring Boot and Quarkus across startup time, memory usage, CPU consumption, and response latency, presents benchmark results from JMeter and VisualVM tests, and provides practical guidance for migrating Java developers from Spring to the cloud‑native Quarkus framework.
This tutorial walks through converting a functional Spring Boot JAR into a Windows executable using exe4j, bundling a local JRE, and creating a user‑friendly installer with Inno Setup, providing step‑by‑step screenshots and configuration details for non‑technical end users.
Spring Boot 3.2 introduces Java 21 virtual thread support, SSL hot‑reload for embedded servers, GraalVM native image improvements, and a preview of Spring AI, marking a major evolution for Java backend development and performance optimization.
This article explains how to simplify Spring MVC interface calls by defining custom annotations, implementing a custom HandlerMapping, configuring it in Spring Boot 2.6.12, and demonstrating usage with example code, while also covering related handler adapters and underlying principles.
This step‑by‑step guide shows how to download, configure, and launch SkyWalking with Spring Boot, connect it to Elasticsearch, instrument a sample service and Redis calls, and view real‑time monitoring data through the SkyWalking UI and Kibana.
This article explains how to enable and configure Spring Boot's @Async annotation, demonstrates proper thread‑pool setup, highlights common mistakes such as calling async methods within the same class or mixing with @Transactional, and provides guidance on handling blocking tasks and exceptions for robust asynchronous execution.
This article compares Spring Boot and Quarkus, detailing their architectures, performance benchmarks—including startup time, memory usage, CPU, and response latency—both in JVM and native modes, and provides guidance on migrating Spring applications to Quarkus with code examples and best‑practice tips.
This article explains why Elasticsearch is fast, outlines its key features, and provides a complete Spring Boot 2.4 tutorial—including dependencies, configuration, data model, repository usage, and test code—for building a distributed search service.
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.
Anson from Tencent Cloud describes how the 微搭 low‑code platform uses a hybrid‑cloud architecture that separates public‑cloud design from private‑cloud deployment, employing a split‑able micro‑service design that can be merged into a single pod, cutting resource usage by up to 90 % and eliminating version‑related O&M issues.
This article explains the concept of open interfaces and signature verification, outlines the end‑to‑end signing and verification flow, and provides a complete Spring Boot implementation including configuration properties, a signature manager, custom annotation, AOP aspect, request‑caching filter and utility classes, all illustrated with code snippets.
This article explains how to use Debezium's change data capture (CDC) capabilities to monitor MySQL binlog events, compares Canal and Debezium, outlines typical CDC use cases, and provides a complete Spring Boot integration guide with configuration, code examples, and testing procedures.
This article compares the Spring Boot and Quarkus Java frameworks by examining their architectures, running reactive test applications, measuring startup time, memory usage, CPU consumption and response latency for both JVM and native builds, and provides practical guidance for migrating Spring developers to Quarkus.
Learn how to implement comprehensive parameter validation in Spring Boot 2.6.12 using JSR‑303 Bean Validation, covering simple checks, validation groups, single‑parameter validation, nested objects, custom utilities, internationalization, and unified AOP‑based handling with practical code examples and configuration steps.
This guide explains Spring Validation in Spring Boot 2.6, covering its lightweight features, configuration of Bean Validation providers, injection of validators, practical examples, custom annotation creation, method‑level validation, and additional configuration options with clear code samples.
This article explains how to integrate Lua scripts into Spring Boot projects for Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation with code examples, error handling, security considerations, and best‑practice recommendations for backend developers.
This guide walks through adding Camunda 7 to a Spring Boot project, covering Maven dependencies, configuration files, database schema, BPMN modeling, task types, gateways, API usage, variable handling, listeners, and deployment, providing a complete end‑to‑end workflow solution.
This article introduces Java virtual threads, compares them with traditional platform threads, demonstrates multiple creation and execution patterns, showcases performance benefits through code examples, and explains structured concurrency as a preview feature for building high‑throughput, scalable backend applications.
After migrating a project to the MDP framework based on Spring Boot, the author observed swap overuse and physical memory far exceeding the 4 GB heap; using JVM native memory tracking, gperftools, strace, pmap, and a custom allocator, they traced a native‑memory leak to Spring Boot’s ZipInflaterInputStream during JAR scanning and resolved it by limiting scan paths.
This guide explains why and how to encrypt sensitive information in Spring Boot configuration files using Spring Cloud's built‑in encryption, Jasypt, command‑line parameters, and demonstrates the underlying implementation classes for secure application deployment.
This article explains Spring Boot's auto‑configuration mechanism, covering how @EnableAutoConfiguration loads configuration classes, the role of @AutoConfigurationPackage and @Import, the processing of spring.factories and metadata files, and how the main application class is registered in the IoC container.
This article introduces Redisson, a Java framework built on Redis for distributed systems, detailing its extensive features such as distributed objects, locks, rate limiters, and task scheduling, and provides step‑by‑step guidance on integrating Redisson’s distributed lock into Spring Boot applications with code examples.
This guide explains how to use Spring's Formatter SPI and AnnotationFormatterFactory to create, register, and test custom type converters and annotation‑based formatters in a Spring Boot 2.6.12 application, complete with code samples and endpoint demonstrations.
This article introduces Easy-Es, a Java ORM framework built on Elasticsearch's RestHighLevelClient that simplifies query construction and CRUD operations, provides step‑by‑step setup including Maven dependencies, configuration, entity and mapper definitions, controller examples, and advanced features such as condition builders, index management, logging, and aggregation queries.
This tutorial demonstrates how to integrate Activiti workflow engine event listeners into a Spring Boot application, covering task assignment, task completion, and process completion events with code examples, testing steps, and important configuration details.
This guide shows how to extend a Spring Boot application with Activiti to query historic process data, generate highlighted process diagrams, and expose endpoints that display real‑time workflow progress, including code snippets for service methods, configuration, utilities, and a controller for image rendering.
Explore the fundamentals and advanced techniques of asynchronous programming in Java, from basic thread creation and thread pools to Future, FutureTask, CompletableFuture, and Spring Boot’s @Async annotation, including practical code examples, event handling, and message queue integration for high‑throughput systems.
The article details a week‑long investigation of a sandbox environment where Spring Boot APIs became unresponsive due to Redis connection pool blocking, describing the use of system tools, JVM thread analysis, and code inspection to identify mis‑configured pool settings and recommending proper connection handling with Spring's RedisTemplate.
This article explains Redis' client‑server request model, introduces the pipeline technique, compares normal and pipelined requests, and provides Spring Boot code examples that demonstrate a three‑fold speed improvement when writing 100,000 keys.
This article introduces Java 21’s major enhancements—including lightweight virtual threads and generational ZGC—provides code samples for creating virtual threads and enabling ZGC, demonstrates a Spring Boot 3.x application using record patterns, and explains how to monitor Java 21 services with Alibaba Cloud ARMS on ACK.
This article walks through the theory behind RSA, illustrates two battlefield‑style scenarios for encryption and signing, and then shows how to integrate RSA‑based request/response encryption into a Spring Boot application using Maven, annotations, configuration files, and a JavaScript front‑end, complete with code snippets and troubleshooting tips.
This article explains how to merge multiple user requests on the server side, batch them into a single SQL query using a blocking queue and CompletableFuture, and handle high‑concurrency scenarios with scheduled tasks and timeout‑aware queues to save database connection resources.
This tutorial explains how to configure Spring Cloud Gateway, set up static routes, and then use Nacos for dynamic route management by adding dependencies, configuring bootstrap.yml, defining JSON route data, and implementing a listener bean to refresh routes without restarting the service.
This tutorial provides an in‑depth guide to Spring Boot covering core concepts such as project setup, configuration files, logging frameworks, MVC architecture, CRUD examples, error handling, embedded servlet containers, Docker integration, JDBC/MyBatis/JPA data access, startup process, and how to create custom starter modules.
This article explains the purpose and differences of Spring's @ConfigurationProperties and @PropertySources annotations, provides step‑by‑step guidance for creating POJOs, configuration classes, property files, and demonstrates how to bind and inject configuration values in a Spring Boot application with code examples.
mica-auto is a Spring Boot starter tool that uses annotation processing to automatically generate configuration files such as spring.factories, AutoConfiguration.imports, and spring-devtools.properties, supporting Kotlin meta‑annotations and Java SPI, with Maven and Gradle integration instructions and version compatibility details.
This guide explains why asynchronous request interfaces are essential for high‑concurrency Spring Boot applications, outlines their advantages and typical use cases, and provides step‑by‑step code examples for DeferredResult, Callable, ResponseBodyEmitter, StreamingResponseBody, and reactive Mono implementations.
This article walks through multiple ways to add real‑time in‑site notifications—such as the familiar red‑dot badge—to a web application, covering short and long polling, iframe streaming, Server‑Sent Events, MQTT and WebSocket, with complete Spring Boot code examples and client‑side snippets.
This article explains the essential Spring Boot annotations—including @SpringBootApplication, @EnableAutoConfiguration, @ComponentScan, and the various @Conditional family—detailing their purposes, composition, and usage with clear code examples for Java backend development.
This article explains the core Spring Boot annotations—@SpringBootApplication, @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan—detailing their combined functionalities, usage patterns, and providing Java code examples to illustrate how they simplify application configuration and startup for developers.
This article explores JDK 21's major features including virtual threads, generational ZGC, and new APIs, comparing their performance with traditional threading models and demonstrating practical implementations in Spring Boot.
This article walks you through implementing RSA‑based encryption and digital signatures in a Spring Boot application, covering the theory of asymmetric cryptography, practical code snippets for Maven, configuration, controller annotations, and a JavaScript client that encrypts requests and verifies responses to protect API data from eavesdropping and tampering.
This article dissects how Spring Cloud Config Center integrates with Spring Boot, detailing the startup phases, the prepareEnvironment logic, the bootstrap container that fetches remote configurations, and the @RefreshScope mechanism that enables dynamic property refreshes.
This article explains the principles of RSA asymmetric encryption, illustrates two communication scenarios, and provides a step‑by‑step Spring Boot implementation with Maven dependencies, configuration, annotations, and front‑end JavaScript code to encrypt API requests and decrypt responses, helping developers secure their APIs.
This article explains how to use Redis BitMap to build a memory‑efficient sign‑in feature and continuous‑sign‑in statistics in a Spring Boot microservice, covering basic BitMap commands, key design, core Java code, testing steps, and a bitmap‑based solution for cache‑penetration protection.
This article explains Java memory concepts, demonstrates how to set JVM memory parameters for Spring Boot via startup scripts and configuration files, lists common memory flags, and provides practical tips for reducing memory consumption and improving application performance.
This tutorial explains how to enable and use Spring Cache with annotations like @Cacheable, @CacheEvict, and @CachePut, integrates JSR‑107 and Ehcache, provides full Maven and configuration examples, and demonstrates caching behavior through a series of practical code snippets and tests.
This article walks through the complete Spring Boot startup sequence, starting with the SpringApplication.run entry point, detailing the preparation, application context creation, and refresh phases, and shows how the embedded Tomcat server is instantiated and started, illustrated with code snippets and diagrams.
This article explains why using kill -9 to terminate Linux processes can cause data loss, demonstrates how to gracefully stop Spring Boot services with kill -15, the Actuator shutdown endpoint, and custom shutdown configurations, and shows how to add pre‑destroy hooks for backup tasks.
The article explains the drawbacks of field injection in Spring Boot—such as poor testability, loss of immutability, tighter framework coupling, risk of NullPointerExceptions, and hidden circular dependencies—and demonstrates how constructor injection provides a cleaner, more maintainable alternative with clear code examples.
This article presents a complete Netty TCP client demo built with Spring Boot, detailing the project architecture, module layout, business flow, key code implementations—including a local BlockingQueue, message processing with Redis locks, client initialization, handler logic, and testing endpoints—providing a practical reference for backend developers.
This guide explains why Spring Boot emails may show the default no‑reply address instead of a custom product name and demonstrates how to configure the sender alias using SimpleMailMessage or MimeMessage with code examples.
This article details how a hidden 100 ms delay in a Spring Boot channel system was traced to Tomcat‑embed’s handling of Swagger‑UI resources, diagnosed with Arthas, and resolved by upgrading the embedded Tomcat version.
This article demonstrates how Spring Boot’s connectionTimeout setting influences server‑client connections, using three experiments—controller sleep, HttpURLConnection requests, and raw socket communication—to reveal that the timeout only terminates idle client connections, not the duration of request processing.
Learn how to launch Spring Boot applications with custom JVM and Spring options, understand common parameters like server port, profiles, and property overrides, explore code examples for retrieving values, and grasp the loading order and priority of configuration sources.
Learn how to integrate Elasticsearch 7.8 with Spring Boot 2.4, covering essential dependencies, index management, document CRUD, bulk operations, and advanced queries such as pagination, sorting, filtering, highlighting, aggregations, and grouping, all demonstrated with concise Java High-Level REST client code examples.
This article presents a complete Netty TCP long‑connection demo built with Spring Boot 2.2.0 and Redis, explains the project architecture, module layout, business flow using a local BlockingQueue instead of RocketMQ, and provides detailed source code for the queue holder, processing logic, client implementation, handler, and test controllers.
This article introduces Spring Boot’s core “magic” features—including auto‑configuration, starter dependencies, embedded servers, externalized configuration, Actuator, DevTools, testing support, ecosystem components, performance tips, and continuous learning—providing a comprehensive guide for building efficient Java backend applications.
This article explains how to combine multiple user queries into a single database request using a queue, ScheduledThreadPoolExecutor, and CompletableFuture in Spring Boot, demonstrating code implementations, handling Java 8 CompletableFuture timeout limitations, and showing performance gains through request merging under high concurrency.
After a sudden 500 error crippled an online service, the author traced the issue to Spring Cloud Gateway’s HttpMessageReader creating temporary directories for every request, eventually exhausting inode space; the article explains the root cause, inode basics, and how upgrading to version 5.2.16 resolves the problem.
This article provides a comprehensive guide on implementing WebSocket in Spring Boot, covering three native approaches (Javax, WebMVC, WebFlux) with server‑ and client‑side configurations, and briefly introducing four third‑party libraries (Java‑WebSocket, SocketIO, Netty) for advanced use cases.
This article explains why field injection in Spring Boot should be avoided, highlighting its drawbacks such as poor testability, mutability, tight coupling, risk of null‑pointer exceptions, and circular dependencies, and demonstrates how constructor injection offers a cleaner, more maintainable alternative with code examples.
This article demonstrates how to secure Spring Boot API data using RSA asymmetric encryption, covering the theory of RSA, step‑by‑step project setup, Maven dependencies, annotations for automatic encryption/decryption, Java and JavaScript client implementations, and practical testing of encrypted endpoints.
This guide walks through installing Apache Ignite via Docker, configuring it alongside MySQL in a Spring Boot project, setting up data sources and MyBatis, and performing benchmark tests to illustrate Ignite’s superior in‑memory SQL performance compared to traditional MySQL setups.
This article explains how to enable fuzzy searches on encrypted sensitive fields such as names, phone numbers, and ID numbers in a Spring Boot backend by using a tokenized ciphertext mapping table, outlining four possible solutions, recommending the tokenized approach, and providing complete configuration and code examples.
This article explains practical methods to protect sensitive API data in Spring Boot applications, covering encryption, masking, access control, logging, HTTPS, and database security, and demonstrates three implementation approaches: SQL‑level masking, field‑level encryption, and custom Jackson serialization using annotations and a contextual serializer.
This article explains the fundamentals of microservice architecture, introduces Spring Cloud and its core components, and provides a step‑by‑step tutorial for building a distributed e‑commerce system using Spring Boot, Eureka, Ribbon, Feign, and related Spring Cloud features.
This tutorial demonstrates how to integrate a custom MyBatis TypeHandler in a Spring Boot 2.6.12 application to automatically encrypt sensitive fields before persisting them to MySQL and decrypt them on retrieval, covering dependencies, configuration, entity definition, encryption utilities, mapper XML, and test cases.
This article introduces Spring Native, explains how it uses GraalVM to compile Spring Boot apps into native executables with sub‑100 ms startup and lower memory usage, provides step‑by‑step setup and Docker build instructions, and compares its performance against traditional Spring Boot launches.
This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes key concepts such as pointcuts, advice, aspects, and weaving, and provides step‑by‑step code examples—including simple and advanced use cases and detailed annotation usage—to help developers integrate AOP effectively into their Spring Boot applications.
This step‑by‑step guide shows how to install and configure Docker on CentOS 7, optionally set up docker‑compose, pull a Tomcat image, build a Spring Boot project, package it, and run it inside a Docker container, including commands for mounting, port mapping, and verifying the deployment.
This article demonstrates how to implement a captcha‑based login mechanism in a Spring Boot application with a front‑end/back‑end separation, detailing the traditional session‑based approach, the new Redis‑backed token solution, and providing complete code examples for configuration, service, controller, and data objects.
This guide explains what Swagger is, why it’s useful for RESTful APIs, and provides step‑by‑step instructions for integrating Swagger 3.0 with Spring Boot 2.7, handling version conflicts, customizing documentation, adding security, and using annotations to enrich API metadata.
This article presents a comprehensive set of Spring Boot best practices for developers, covering proper package structuring, design patterns, starter dependencies, production-ready versions, Lombok usage, constructor injection, slf4j logging, controller responsibilities, service layer logic, null‑pointer avoidance, collection handling, pagination, caching, custom exception and response handling, code cleanup, meaningful naming, case conventions, simplicity, formatting standards, and tooling such as SonarLint.
An in‑depth guide explains three rate‑limiting algorithms—counter, leaky bucket, and token bucket—demonstrates their implementation in Spring Boot using Guava’s RateLimiter and Baidu’s ratelimiter‑spring‑boot‑starter, provides full Maven dependencies, configuration snippets, and Java code examples, and shows testing results.
This article explains how to structure a Spring Boot controller by describing the four parts of a request, demonstrating elegant parameter validation, implementing a unified response wrapper with status codes, and handling both validation and business exceptions through centralized advice and custom exception classes.
This article demonstrates how to merge multiple user‑info requests on the server side using a blocking queue, ScheduledThreadPoolExecutor, and CompletableFuture in Spring Boot, thereby consolidating SQL queries into a single batch call to save database connection resources while handling high concurrency.
This guide explains how to implement delayed and priority queues in RabbitMQ 3.8 using Spring Boot 2.6, covering dead‑letter exchange configuration, message expiration, priority settings, code examples for sending and consuming messages, and practical considerations such as priority limits and ordering behavior.
This article explains how to standardize API return formats with a generic Result object, define error codes and custom exceptions, implement a global exception handler, use ResponseBodyAdvice for automatic response wrapping, and package these utilities into a reusable Spring Boot starter for cleaner backend code.
Spring Boot 3.0.0 M1 introduces a Java 17 baseline, requires migration of all Java EE APIs to Jakarta EE, removes support for several third‑party libraries, updates numerous Spring project dependencies, and outlines the upcoming release cadence, while also highlighting community resources and promotional offers.
Learn how to capture MySQL data changes using Debezium's CDC capabilities within a Spring Boot application, avoiding heavyweight message brokers by leveraging binlog monitoring, configuring connectors, handling snapshots, and processing change events for use cases like cache invalidation, data integration, and simplifying monolithic architectures.
This article provides a detailed guide on implementing unified exception handling in Spring Boot applications, covering background concepts, the use of @ControllerAdvice and @ExceptionHandler, custom assertion utilities, error response structures, and practical examples for handling various controller and service layer exceptions efficiently.
This article compares Server‑Sent Events, WebSocket, and long‑polling for real‑time data push in Spring Boot, explains their communication models, performance trade‑offs, and provides complete server‑side and client‑side code examples for implementing SSE and custom event types.
This article provides a detailed overview of Spring MVC and Spring Boot annotations such as @RequestMapping, @GetMapping, @PostMapping, @RequestBody, @ControllerAdvice, @Component, @Bean, @Scope, @Autowired, and others, explaining their purposes, attributes, usage patterns, and offering practical code examples for each.
This guide walks through installing MySQL in Docker, configuring master‑slave replication, verifying synchronization, deploying a Canal server, and integrating it with a Spring Boot application to automatically push database changes into Redis.
This tutorial shows how to activate Java 21 virtual threads in Spring Boot 3.1 (and earlier versions), provides full configuration code for Tomcat, Undertow and Spring async, and demonstrates a performance test where concurrency gains reduce total execution time by over five times.
This article explains how to integrate feign-reactor with Spring Boot 2.7, covering OpenFeign features, reactive client setup, code examples, timeout configuration, and programmatic usage to enhance microservice communication.
This article explains how to replace repetitive try‑catch blocks with a unified exception handling framework in Spring Boot, using @ControllerAdvice, custom Assert utilities, and enum‑based error codes, while showing concrete code examples, configuration steps, and runtime results.
This article demonstrates how to create a custom HttpMessageConverter in Spring Boot 2.6.12 to parse a simple “name:张三,age:20” string into a Users object, configure it in WebMvc, and explains the underlying Spring MVC request‑handling flow that invokes the converter.
Oracle's Java 21 release introduces virtual threads, record patterns, ordered collections and a preview FFM API, while Eclipse survey data shows rising Spring and Spring Boot usage and accelerating cloud‑native adoption among Java developers.
This guide walks through setting up a Spring Boot project with JDK 8, Atomikos, and JPA to manage two MySQL data sources, configure JTA transaction handling, define entity managers, services, and a controller, and demonstrates successful and failing transaction scenarios with code snippets and screenshots.
This article introduces the Erupt framework—a pure‑Java, annotation‑driven backend admin solution that requires no front‑end code, generates CRUD interfaces automatically, and can spin up a complete management system in just a few minutes, with step‑by‑step setup, configuration, and customization examples.
