This article introduces four methods—manual setting, TaskDecorator, InheritableThreadLocal, and TransmittableThreadLocal—to propagate contextual data such as user information from a parent thread to child threads in Spring Boot asynchronous execution, providing code examples and practical recommendations.
Spring Boot 3.1.4 is now available on Maven Central, adding Java 21 support, a new JavaVersion enum entry, dozens of bug fixes, documentation improvements, and a long list of dependency upgrades for developers building modern backend applications.
Java 21, the latest LTS release, introduces virtual threads, sequenced collections, record patterns, and other enhancements; the article explains these new features, guides developers on configuring IDEs and runtimes with Azul Zulu and IntelliJ IDEA, and resolves Lombok incompatibility by updating to version 1.18.30.
This guide explains how to set up Spring Data R2DBC with Spring Boot, covering driver selection, dependency configuration, application properties, entity definitions, CRUD services, controllers, repository usage, and optimistic locking for reactive relational database interactions.
This tutorial walks through using Spring Batch with Spring Boot 2.6.12 to create a batch job that reads CSV data, processes each record, and writes the results into a MySQL database, covering architecture, configuration, code components, and execution steps.
This tutorial explains why centralized log collection is essential for micro‑service systems, introduces the ELK stack (Elasticsearch, Logstash, Kibana), provides step‑by‑step installation on Ubuntu, shows how to configure Logstash shipper and indexer pipelines, and demonstrates integration with Spring Boot and Nginx logs for real‑time monitoring.
This article summarizes a performance comparison between Spring Boot applications using virtual threads and those built with Spring WebFlux, detailing the test scenario of JWT verification and MySQL queries, the environment, code implementations, benchmark results across various concurrency levels, and concluding that WebFlux outperforms virtual‑threaded Spring Boot.
This guide explains how to use Spring Boot's Formatter SPI to create custom type converters, implement both simple and annotation‑based formatters, register them in a WebMvcConfigurer, and test the conversions through REST endpoints, complete with code examples.
This article examines the ClassCastException that occurs when 100 threads concurrently query MyBatis using a shared SqlSession, analyzes the root cause in DefaultSqlSession and BaseExecutor, and explains how Spring Boot’s MyBatis integration employs SqlSessionTemplate, ThreadLocal binding, and transaction management to guarantee thread‑safe SqlSession usage.
This article provides a step‑by‑step guide for backend developers to replace Shiro with jCasbin in a Spring Boot application, covering Maven dependencies, configuration files, Enforcer initialization, custom filter implementation, and runtime permission add/remove APIs, all with complete code examples.
This tutorial walks you through creating a Spring Cloud Alibaba project from scratch using IntelliJ IDEA and Maven, covering parent project setup, module creation, pom.xml configuration, a simple Spring Boot application, a Hello World controller, and how to run and verify the service.
This article explains how to merge multiple user‑detail requests on the server side using a blocking queue, scheduled thread pool and CompletableFuture in Spring Boot, thereby converting many individual SQL calls into a single batch query, saving database connections and improving high‑concurrency performance.
This article provides an in‑depth overview of the most frequently used Spring Boot annotations, categorizing them into Spring MVC, Spring Data JPA, Spring Security, and other essential annotations, and demonstrates their practical usage with concise examples.
This tutorial walks through integrating Dataway—a UI‑driven, code‑free API configuration tool based on DataQL—into a Spring Boot project, covering Maven dependencies, property settings, datasource setup, Hasor module integration, enabling annotations, and publishing a test endpoint.
This guide explains how to embed Dataway—a DataQL‑based API configuration tool—into a Spring Boot application, covering dependency setup, property configuration, datasource integration, Hasor module wiring, enabling Hasor, launching the app, accessing the UI, creating and publishing APIs using SQL or DataQL, and verifying the results.
The Spring Boot 3.0.0 M1 milestone upgrades the Java baseline to Java 17, migrates all Java EE APIs to Jakarta EE, removes support for several third‑party libraries, updates a long list of Spring and external dependencies, and outlines the upcoming release cadence.
This tutorial explains how to set up a unified ELK (Elasticsearch, Logstash, Kibana) real‑time log analysis platform on Ubuntu, covering component installation, Logstash shipper and indexer configurations, integration with Spring Boot and Nginx logs, and background management with Supervisor.
This guide explains how Spring Boot’s default logging uses Logback with Commons Logging, details the console log format, color coding, file output options, rolling policies, log levels, logger groups, and advanced customizations through logback‑spring.xml and environment properties.
This article explains microservice service‑splitting principles, demonstrates a demo project with separate order and user services, and shows how to implement remote calls between them using Spring Boot's RestTemplate, including code examples and provider‑consumer concepts.
This article explains the concept and benefits of plugin-based development, outlines common Java implementation approaches such as SPI, configuration‑driven reflection, runtime JAR loading, and Spring Boot's spring.factories, and provides detailed code examples and a complete case study demonstrating flexible, hot‑pluggable SMS services.
This guide explains how to protect plaintext Spring Boot configuration values by encrypting them using Spring Cloud Context's DecryptEnvironmentPostProcessor, covering dependency setup, key generation, JCE policy installation, code examples, and runtime decryption for secure property access.
This article explains Spring Web MVC's functional programming model (WebMvc.fn), covering immutable ServerRequest/ServerResponse, RouterFunction routing, HandlerFunction handling, validation, nested routes, filters, and provides comprehensive code examples for Spring Boot 2.4.12.
This guide walks through setting up a Spring Boot 2.4.12 project with JDK 1.8, Oracle, and two data sources—master and slave—covering Maven dependencies, application.yml settings, custom property classes, HikariDataSource beans, JPA EntityManagerFactory, MyBatis SqlSessionFactory, mapper scanning, and testing entity creation to verify successful configuration.
This guide explains how to combine local and remote caches using Alibaba's JetCache in a Spring Boot project, covering dependency setup, configuration files, annotation‑based usage, advanced API methods, testing procedures, and common troubleshooting tips for a robust multi‑level caching solution.
Learn step‑by‑step how to set up Prometheus and Grafana with a Spring Boot 2.4.12 application, configure dependencies, expose metrics via Actuator, customize meters, and monitor database connection pools, providing a complete observability solution for Java backend services.
This article examines Spring Boot 2.7.10’s embedded Tomcat configuration, detailing default connection queue sizes, thread pool parameters, key Tomcat settings such as AcceptCount and MaxConnections, internal thread components, and practical testing results that reveal how connection limits affect client‑server handshakes.
This article explains what a service gateway is—combining routing and filters—covers why it is needed for centralized cross‑cutting concerns such as authentication, rate limiting and monitoring, describes the architecture and request flow with gateway, open‑service and microservices, and recommends a Java‑based stack including Spring Boot, Netflix Zuul, Consul, JWT, Prometheus, Grafana, ELK and JMeter.
This guide demonstrates how to integrate RocketMQ 4.8.0 into a Spring Boot 2.4.12 application, covering dependency setup, configuration, sending and receiving normal, ordered, cluster/broadcast, and transactional messages, complete with code snippets and execution results to help developers implement reliable messaging patterns.
This article explains what Swagger is, why it is useful for RESTful API documentation, and provides a step‑by‑step guide for integrating Swagger 3.0 with Spring Boot 2.7.6, handling version conflicts, customizing Docket settings, securing the UI, and applying advanced annotations to enrich the generated documentation.
This article introduces the most commonly used Spring Boot utility classes—including assertions, object and collection helpers, file/IO utilities, reflection, and AOP support—providing code examples and usage guidelines to help Java backend developers write cleaner, more efficient code.
This article explains the differences between JAR and WAR files, why Spring Boot runs with an embedded Tomcat when packaged as a JAR, how deployment changes when using an external Tomcat, and provides step‑by‑step instructions with Maven configurations to build Spring Boot applications as either JAR or WAR packages.
This article provides a comprehensive guide to implementing WebSocket in Spring Boot, covering server and client configurations for Javax, WebMVC, and WebFlux, along with code examples, deployment tips, and insights into alternative libraries such as Java-WebSocket, SocketIO, and Netty.
This article explains how to implement a user sign‑in feature and its statistical analysis using Redis BitMap within a Spring Boot backend, covering basic BitMap commands, integration steps, core source code, continuous sign‑in calculation, and a bitmap‑based solution for cache penetration.
This guide demonstrates how to integrate Spring Boot 2 with OAuth2 for unified authentication, configure a Redis-backed token store, implement a resource server with custom security settings, and test protected endpoints, providing complete code snippets and configuration details.
This guide walks through Spring Framework 6.1's new JdbcClient API, showing how to define a Bookmark entity, create the corresponding MySQL schema, perform fluent CRUD operations, and verify them with Testcontainers‑based integration tests in a Spring Boot 3.2 project.
This article provides a detailed exploration of Spring and Spring Boot's extensible interfaces, illustrating the complete bean lifecycle, presenting an invocation order diagram, and offering practical code examples for each extension point such as ApplicationContextInitializer, BeanFactoryPostProcessor, SmartInstantiationAwareBeanPostProcessor, and more, enabling developers to customize container behavior effectively.
This article provides a comprehensive guide on implementing WebSocket in Spring Boot, covering the Javax API, Spring WebMVC and WebFlux configurations, client and server setups, message handling, handshake interceptors, and a brief overview of popular third‑party libraries such as Java‑WebSocket, SocketIO and Netty.
This article explains how to standardize Spring Boot controller handling by receiving parameters, defining unified status codes, applying global validation, wrapping responses consistently, and managing exceptions with custom advice, using annotations, enums, and AOP techniques to improve code readability and front‑end integration.
This guide explains how to design a max‑effort notification mechanism for a recharge scenario using Spring Boot 2.4.12 and RabbitMQ 3.7.4, detailing the interaction flow, repeat‑notification strategy, message verification, and provides complete code for both pay‑manager and users‑manager modules, including configuration, entities, services, listeners, and controllers.
This tutorial explains what Swagger is, why it is useful for RESTful API documentation, and provides step‑by‑step instructions for integrating Swagger 3.0 into a Spring Boot 2.7.6 project, including Maven dependencies, configuration classes, handling startup errors, customizing the UI, security settings, and annotation usage.
This article explains how to design and implement a resumable multipart file upload system using MD5 file identification, MinIO/S3 pre‑signed URLs, and Spring Boot controllers and services, covering database schema, task initialization, part uploading, merging, and cleanup of incomplete uploads.
This tutorial walks through creating a full‑featured OAuth2 authorization server using Spring Boot 2.4.12, storing tokens in Redis, defining client and user entities in MySQL, configuring grant types, and testing the authorization, password, client‑credentials, and implicit flows.
MyBatis-Flex is a lightweight, high‑performance enhancement to MyBatis that offers flexible query tools, extensive database support, and impressive speed gains over MyBatis‑Plus, with a step‑by‑step quick‑start guide for Spring Boot integration.
This guide explains how to protect API data exchange by implementing HTTPS, JWT, rate limiting, MAC, and symmetric encryption (AES/DES) in a Spring Boot backend, while using Vue and Axios on the frontend, including custom annotations, request/response advice, and crypto‑js utilities for end‑to‑end encryption.
This guide explains how to implement a custom HttpMessageConverter in Spring Boot 2.5, covering the converter class, configuration, data model, controller, testing steps, and the internal request‑handling flow within the Spring MVC framework.
This article introduces Alibaba's JetCache Java caching framework, explains how to combine local and Redis remote caches for multi‑level caching, provides Maven dependencies, configuration examples, three usage patterns (AOP, API, advanced API), testing steps, and common troubleshooting tips for Spring Boot projects.
Spring Boot 3.1.3, now on Maven Central, brings 82 bug fixes, extensive documentation updates, and a comprehensive set of dependency upgrades, while the PIG platform adds compatibility with this version, offering developers a ready‑to‑use micro‑service starter kit.
Spring Boot 2.7.15, released on Maven Central, brings 45 bug fixes, documentation improvements, and numerous dependency upgrades, while the PIG microservice platform has been updated to this version; note that Spring Boot 2.x will cease maintenance in November 2023, urging migration to 3.x.
This article explains the principles, system design, key generation, encoding strategies, HTTP redirection techniques, and step‑by‑step Spring Boot project setup needed to build a reliable short‑link service for marketing and internal applications.
This article explains how to prevent duplicate API calls and achieve idempotency in Spring Boot 3.0.5 by using unique tokens, timestamps, or Spring AOP, and provides complete code examples for custom annotations, AOP aspects, interceptors, and Redis‑based token management.
This article demonstrates how to improve Spring Boot order‑creation API calls by moving from sequential RestTemplate requests to multithreaded, thread‑pooled, CompletionService and CompletableFuture approaches, comparing performance and highlighting best practices for high‑concurrency scenarios.
This guide walks through setting up Spring Batch 4.2.7 with Spring Boot 2.4.12, covering architecture, configuration, job, step, reader, processor, writer, listeners, and deployment, demonstrating how to read CSV data, process it, and persist results to a MySQL database.
This guide walks you through setting up Spring Boot Admin, covering server and client configuration, essential monitoring features, security setup, custom notification code, and integration with microservices and Nacos for comprehensive application health management.
This article explains why URL mappings that worked in Spring Boot 2.x break after upgrading to Spring Boot 3, demonstrates the issue with trailing slashes, and provides three practical solutions—including a filter, Nginx rule, and Spring Cloud Gateway optimization—to restore correct routing.
This guide explains why API rate limiting is essential, outlines common algorithms, and walks through three practical implementations in Spring Boot 3—using Guava, Spring Cloud Gateway with RedisRateLimiter, and a custom annotation‑based solution with Redis backing.
Bean Searcher is an open‑source Java library that delivers a condition‑retrieval engine up to 100 times faster than MyBatis, natively supports multi‑table joins, pagination, sorting and aggregation, and enables developers to implement sophisticated list‑search APIs with a single line of code, dramatically reducing backend development effort.
This article explains how Spring Boot 2.4.12 configures error handling, from default HTML/JSON responses based on the Accept header to the internal auto‑configuration that registers custom error pages in the embedded Tomcat container using BeanPostProcessors and the BasicErrorController.
This comprehensive guide presents 22 essential Spring Boot best practices—from proper package structuring and design patterns to logging, caching, pagination, and code hygiene—helping developers build high‑performance, maintainable Java backend applications efficiently.
This guide explains Spring Boot's programmatic transaction management using TransactionTemplate, TransactionCallback, and PlatformTransactionManager, covering configuration, rollback handling, event listeners, and when to prefer programmatic versus declarative approaches, complete with code examples.
This article presents a comprehensive collection of Spring Boot best practices—including proper package structure, design pattern usage, starter dependencies, Lombok integration, constructor injection, SLF4J logging, controller and service design, null‑pointer avoidance, collection handling, pagination, caching, custom exception handling, response objects, code cleanup, meaningful naming, casing conventions, simplicity, consistent formatting, and SonarLint usage—to help developers build efficient, maintainable, and high‑performance backend applications.
This article introduces Alibaba's JetCache framework, explains how to configure and combine local and remote (Redis) caches in a Spring Boot project, and demonstrates three usage patterns—AOP annotations, API mode, and advanced CacheManager API—along with troubleshooting tips and test procedures.
This guide explains why Gmail bounces verification emails from a Spring Boot backend, analyzes the required SPF, DKIM, ARC, and DMARC configurations, and provides step‑by‑step instructions with example TXT records to ensure successful delivery.
Learn step‑by‑step how to install and configure Elasticsearch, Kibana, and Logstash, integrate them with a Spring Boot 2.4.12 application, and use Kibana to view logs, covering environment setup, service startup, configuration files, and sample code.
This guide explains how Spring Boot 2.6.12 uses @GetMapping with consumes and produces attributes to restrict request and response content types, demonstrates matching based on request parameters and headers, details the internal request mapping lookup process, compares PathPattern and AntPathMatcher URI patterns, and shows dynamic registration of request handlers.
The article examines how Spring Boot handles circular reference serialization with Jackson and Fastjson, demonstrates the role of @ControllerAdvice for global exception capture, explains why Jackson may emit both 200 and 500 responses, and provides practical solutions using annotations and configuration.
This article explains data desensitization concepts, common masking rules, and demonstrates how to use the Hutool library and Jackson annotations in Java to mask sensitive fields such as IDs, phone numbers, and passwords, while also comparing alternative tools.
Learn how to build a QR‑code login system using Spring Boot and WebSocket, covering database design, role analysis, API creation, front‑end integration, and full Java code examples for generating QR images, handling socket communication, and validating tokens with expiration logic.
This guide explains Spring Boot 2.4.12 logging fundamentals, covering default console output, customizable patterns, colored logs, file rotation, log levels, logger groups, and advanced Logback extensions, with practical YAML and XML examples for fine‑tuning your application's logging behavior.
This article presents a comprehensive collection of Spring Boot best practices, covering package organization, design patterns, starter usage, dependency management, Lombok integration, constructor injection, logging with SLF4J, controller responsibilities, service layer design, null‑safety, collection handling, pagination, caching, exception handling, response objects, code cleanup, naming conventions, formatting, and tooling such as SonarLint.
This article explains various web message‑push techniques—including short polling, long polling, iframe streaming, Server‑Sent Events, MQTT, and WebSocket—detailing their principles, advantages, and step‑by‑step Spring Boot and JavaScript implementations with complete code examples.
This article explains why @Transactional may fail in multithreaded Spring Boot scenarios, shows how to enable @Async with a custom thread pool, and demonstrates a pair of custom annotations together with AOP to achieve coordinated multithreaded transaction management.
This tutorial explains how to integrate Spring Security with JWT in a Spring Boot application, covering authentication and authorization concepts, filter chain principles, project setup, dependency configuration, security configuration classes, custom token filters, and the complete request‑authentication flow.
This tutorial explains how to protect sensitive Spring Boot configuration values by encrypting them and automatically decrypting them at runtime using Spring Cloud Context's DecryptEnvironmentPostProcessor, complete with dependency setup, code examples, and JCE installation guidance.
This guide demonstrates how to set up a Spring Boot 2.4.12 WebSocket server with custom message types, encoders, decoders, endpoint configuration, and a minimal HTML client, including complete Java code snippets and testing screenshots.
This article explains the concept of idempotency, identifies naturally idempotent HTTP methods, discusses why idempotency is essential for retries, async callbacks, and message queues, and provides a complete Spring Boot implementation using a custom @Idempotent annotation, AOP, and Redis for token storage.
This article explains multiple ways to read configuration properties in Spring Boot—including Environment, @Value, @ConfigurationProperties, @PropertySources, and custom YAML loading—detailing their underlying mechanisms, common pitfalls, and code examples so developers can choose the most suitable approach for their projects.
This article explains how to design and implement a unified exception handling framework in Spring Boot, covering background, annotation usage, custom assertions, enum-based error codes, detailed handler methods, response structures, and practical validation examples with code snippets.
This article explores how Spring Cloud Gateway (Hoxton.SR11) initializes predicate factories, binds configuration values, creates Route objects, and uses CachingRouteLocator and RouteDefinitionRouteLocator to locate and match routes at startup, detailing the underlying code flow and key classes involved.
This guide explains RabbitMQ fundamentals, its core components and four exchange types, and provides step‑by‑step Spring Boot examples—including configuration, code snippets, and testing procedures—to help developers effectively use fanout, headers, direct, and topic exchanges.
This article explains how to use CDC technology, particularly Debezium, to capture MySQL binlog changes and process them in a Spring Boot application without adding heavyweight middleware, providing code examples, configuration details, and typical use cases.
This article introduces the MyBatis‑Plus Generator UI, a web‑based code generation framework that supports multiple databases, offers highly customizable templates, and integrates seamlessly with Spring Boot to accelerate backend development through automated creation of entities, mappers, services, controllers, and SQL‑based code.
This tutorial walks through a complete, step‑by‑step setup of a one‑click CI/CD pipeline that installs Docker and Jenkins on CentOS, configures Maven, creates a Jenkins job, builds a Spring Boot JAR, packages it into a Docker image, and runs the container, providing all commands and screenshots for a seamless deployment experience.
MyBatis‑Plus 3.5.13 introduces dynamic SQL smart optimization, a richer code generator, significant heap‑memory reduction, Spring Boot 3 and JDK 17 native support, new database adapters, enhanced optimistic locking, multi‑parameter filling, and comprehensive SQL‑injection safeguards, all aimed at faster, more productive backend development.
Learn how to integrate external HTTP services in Spring Boot by using raw HttpClient, the RestTemplate utility, and declarative Feign clients, with detailed code examples, token handling, and configuration tips for each approach.
An in‑depth Spring Boot 3 tutorial explains WebSocket fundamentals, the HTTP upgrade handshake, core Spring APIs, configuration options, origin handling, and testing steps, enabling developers to build real‑time, bidirectional communication services for web applications.
This article introduces Spring Cloud Gateway as a unified entry point for microservices, explains its core functions, compares it with Zuul, provides Maven and YAML configuration examples, details route definitions, filter types and ordering, shows how to implement custom filters, and demonstrates CORS solutions using both YAML and Java code.
This guide walks through building a reusable Maven archetype scaffold from a Spring Boot template, covering template preparation, Maven configuration, archetype generation, publishing to a repository, and using the scaffold to quickly create new backend projects.
This tutorial explains how to create delayed and priority queues in RabbitMQ using Spring Boot, covering dead‑letter queue configuration, TTL settings, priority parameters, and provides complete Java code examples for sending and consuming prioritized messages.
This article explains three ways to inject a specific service implementation in Spring—using @Qualifier with @Autowired, using @Resource with type or name attributes, and naming @Service beans—detailing their semantics, bean‑matching rules, and providing complete code examples for each approach.
This article explains how to use HTTP Range headers for resumable downloads, how to detect server support, the relevant status codes, proper Range syntax, error handling, and provides a complete Spring Boot example that integrates with Ceph storage to serve partial file content.
Learn how to set up a Spring Boot 3.0.9 environment, define entities, repositories, services, and a GraphQL schema, then expose a GraphQL endpoint with sample queries, illustrating complete backend API development using GraphQL and JPA.
This guide shows how to use the open‑source Java diagnostic tool Arthas to attach to a running JVM, view real‑time metrics, and trace method execution without inserting manual timing code, enabling quick pinpointing and optimization of performance bottlenecks.
This article introduces MyBatis‑Flex, a lightweight yet high‑performance MyBatis enhancement framework, outlines its key features, compares it with similar tools, lists supported databases, and provides a step‑by‑step Spring Boot quick‑start tutorial with complete code examples.
This tutorial explains how to integrate Dataway—a UI‑driven API configuration tool based on DataQL—into a Spring Boot application by adding the required Hasor dependencies, configuring Dataway properties and database tables, setting up the data source, enabling Hasor, and finally creating and publishing APIs using both SQL and DataQL modes.
Learn how to enable and configure transparent caching in Spring Boot 2.3 using JSR‑107 annotations and Ehcache, covering annotation usage, custom key generators, service and controller implementation, Maven dependencies, YAML and XML settings, and practical testing of cache put, get, and removal operations.
This article introduces the Flowable workflow engine, compares it with other BPM solutions, explains its core concepts, APIs, system tables, BPMN 2.0 modeling, and provides a step‑by‑step quick‑start example with code snippets for building and executing an approval process in a Spring Boot environment.
This article walks through the importance of rate limiting in microservice architectures, compares Dubbo, Spring Cloud, and gateway approaches, explains token‑bucket, leaky‑bucket and sliding‑window algorithms, and provides step‑by‑step AOP implementations using Guava, Sentinel, and Redis with full code samples.
This article provides a step‑by‑step tutorial on integrating MyBatis‑Plus into a Spring Boot project, covering dependency setup, configuration of data sources, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, and multi‑datasource usage with complete code examples.
This article demonstrates how using Spring Boot's TransactionTemplate to programmatically control transactions can prevent long‑running non‑transactional operations from blocking database connections, thereby increasing system throughput compared to the traditional @Transactional annotation, with detailed code examples and performance observations.
This article explains how to implement reliable retry mechanisms in Java applications using Spring‑Retry and Guava‑Retry, covering Maven dependencies, template‑based and annotation‑based configurations, policy and back‑off options, code examples, test results, and a practical comparison of both frameworks.
