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.
The article analyzes why massive tables become a bottleneck in Spring Boot systems, outlines the drawbacks of sharding, and presents a layered solution—data archiving, read‑write separation with caching, heterogeneous source synchronization via Elasticsearch and Canal, and selective sharding—to enable high‑performance real‑time search.
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.
The article explains why rate limiting is essential for high‑traffic Spring Boot services, compares counter, sliding‑window, token‑bucket and leaky‑bucket algorithms, demonstrates implementations with plain Java, Guava RateLimiter, AOP, and distributed approaches using Redis‑Lua and Nginx‑Lua, and provides practical configuration examples.
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 article analyzes frequent scenarios where Spring's @Transactional annotation fails in Spring Boot projects—such as self-invocation, swallowed exceptions, misconfigured rollback rules, non‑public methods, wrong propagation settings, and long‑running transactions—and provides concrete fixes to prevent data inconsistency and performance issues.
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.
This article provides a step‑by‑step guide on integrating Spring Batch with Spring Boot, covering configuration, job and step setup, ItemReader/Processor/Writer implementations, database interactions, handling CSV and database sources, and troubleshooting common issues such as connection‑pool compatibility.
This article introduces a Java‑based private cinema reservation system built on Spring Boot and MyBatis, outlines its core technologies, provides step‑by‑step deployment instructions, and details all functional URLs and the source‑code download method.
This article introduces MyBatis‑Flex, a lightweight yet powerful MyBatis enhancement framework, outlines its key features and advantages, compares it with similar tools, presents performance benchmarks, lists supported databases, and provides a step‑by‑step quick‑start tutorial with code examples for Spring Boot integration.
This article explains the purpose of an API gateway, introduces Spring Cloud Gateway as a modern, WebFlux‑based solution, outlines its features, core concepts such as routes, predicates and filters, shows configuration examples, dynamic routing, and how to create custom predicates and filters for microservice architectures.
This article compares Nacos 2.0's encryption plugin with the Jasypt library for securely storing passwords and secret keys in configuration files, providing step‑by‑step Maven dependencies, configuration examples, encryption/decryption code, and practical advice for Spring Boot applications.
This article provides a comprehensive tutorial on integrating Dataway—a zero‑code API configuration tool based on DataQL—into a Spring Boot project via the Hasor framework, covering dependency setup, Dataway configuration, datasource binding, enabling Hasor, launching the application, and creating and testing API endpoints.
This article introduces MyBatis-Flex, a lightweight high‑performance MyBatis enhancement framework, outlines its key features, compares it with MyBatis‑Plus and Fluent‑MyBatis, lists supported databases, and provides a step‑by‑step quick‑start tutorial with code examples.
This guide walks through setting up a Spring Boot Admin server and client, adding security, configuring logging, displaying client IPs, and dynamically adjusting log levels via the SBA UI, providing complete Maven dependencies, Java configuration classes, and YAML settings for a secure, observable Spring Boot ecosystem.
This guide walks through setting up Seata's configuration and registry centers using Nacos, creating the required config files, initializing the database, and implementing account and storage services in a Spring Boot micro‑service project, complete with code samples and verification steps.
This tutorial explains how to use MyBatis interceptor mechanisms to dynamically modify SQL statements at runtime in a Spring Boot application, covering interceptor types, implementation steps, configuration, core code, testing, and common use cases such as SQL monitoring, pagination, and data permission filtering.
When upgrading Spring Boot to patch CVE‑2023‑34034 and CVE‑2023‑34035, applications using Spring Security may encounter a startup error indicating ambiguous pattern detection, which can be resolved by upgrading to patched versions and adjusting requestMatchers to use MvcRequestMatcher or AntPathRequestMatcher as appropriate.
This guide explains how to achieve reliable message consistency in a Spring Boot 2.3.9 application using RocketMQ 4.8.0 by outlining the transactional message flow, broker handling, project structure, code implementation, and testing procedures.
This article explains how to achieve graceful service publishing using Nacos as a registration center in a Spring Boot microservice architecture, covering environment setup, provider startup and shutdown, client-side load‑balancing with Ribbon, and configuration tweaks for both online and offline scenarios.
Spring Startup Analyzer is an open-source tool that captures Spring Boot startup data, generates interactive reports, and offers async bean initialization to speed up launches, with detailed statistics, bean timelines, method call metrics, unused JAR detection, and flame-graph visualizations, plus step-by-step usage instructions.
Spring Boot 3.1.2, released on July 20, 2023, upgrades to Spring Framework 6.0.6, adds Java 19 support, enhances Devtools, Micrometer metrics, REST Docs, and fixes several bugs including MongoDB test failures and Actuator metrics issues, requiring Java 17+.
This article explains how to design and implement a microservice permission system using Apache Shiro, Spring Boot, Dubbo, and Redis, covering challenges of integrating Shiro with gateways, shared session management, custom Cache and SessionDAO implementations, and provides complete code examples and configuration details.
This article provides an in‑depth overview of the Caffeine local cache library for Java, covering its concepts, configuration options, loading strategies, eviction policies, asynchronous usage, statistics collection, and step‑by‑step integration with Spring Boot including annotations and practical code examples.
The article explains how to achieve graceful shutdown of Spring Boot services by handling Linux signals, registering JVM shutdown hooks, using Spring's ContextClosedEvent and Actuator endpoint, and provides practical code examples for safely terminating thread pools, sockets, and other resources.
This guide walks through designing a User_Token table, defining roles and APIs, implementing QR‑code generation and validation endpoints, and wiring a Spring Boot WebSocket server with front‑end AJAX to achieve secure, real‑time QR‑code login for Android, web and PC clients.
This article demonstrates how to leverage MyBatis interceptor mechanism in a Spring Boot 3 application to dynamically modify SQL statements, showing step‑by‑step implementation, configuration, core code, testing, and common use cases such as SQL monitoring, pagination, and data permission filtering.
This article explains how Java's dynamic compilation can be applied to modularize and simplify code management in large projects, demonstrates a basic implementation with code examples, and shows how to integrate the technique into Spring Boot applications while addressing class‑loader and dependency challenges.
WeBlog is a front‑end/back‑end separated blogging platform built with Spring Boot, MyBatis‑Plus, MySQL, Spring Security, JWT, Minio, and Vue 3.2 + Element Plus, offering Markdown editing, category/tag management, dashboard statistics, and a complete set of admin and front‑end features.
This article introduces the smart-servlet web container, outlines its key features, provides step‑by‑step instructions for replacing Tomcat with smart-servlet in a Spring Boot fat‑jar project, and highlights the related smart-socket framework and ecosystem components.
The article explains how to perform a graceful shutdown of Spring Boot applications by handling Linux kill signals, using the JVM's SignalHandler and Runtime.addShutdownHook mechanisms, and leveraging Spring's ContextClosedEvent and the actuator shutdown endpoint, with detailed code examples and configuration tips.
This article outlines the design goals, architecture, and implementation details of a high‑performance distributed caching solution for Spring Boot applications, combining Redis as a first‑level cache with Caffeine as a second‑level cache, and provides configuration, usage examples, and future enhancement plans.
This article explains the dangers of using the Linux kill -9 command on Spring Boot applications, illustrates data loss scenarios, and provides multiple graceful shutdown methods—including SIGTERM, Spring's ConfigurableApplicationContext, Actuator endpoints, and custom Tomcat shutdown configurations—complete with code examples and best‑practice tips.
This article explains how MyBatis implements first‑level (session) and second‑level (cross‑session) caches, the conditions required for each to work, why the first‑level cache often fails in Spring Boot without transactions, how to enable and use the second‑level cache safely, and the hidden risks of stale data when different mappers share related tables.
This article explains how to invoke external services from a Spring Boot application using three approaches—raw HttpClient requests, Spring's RestTemplate utilities, and Feign clients—providing code examples, configuration steps, and tips for handling headers and tokens.
This guide walks through the technology stack, system design, UI screenshots, attendance rules, and step‑by‑step setup for a full‑stack HR management application built with Vue, ElementUI, and Spring Boot, enabling admins and employees to manage leave, salary, and attendance.
This article explains Project Loom’s virtual threads, shows how to enable them in a Spring Boot 3.1 application with Java 20, provides code samples and performance test results that demonstrate dramatically higher throughput under high concurrency.
