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.
This article introduces MapStruct, a powerful Java annotation‑based object‑mapping library, compares it with BeanUtils, shows how to integrate it into a Spring Boot project, and provides step‑by‑step examples for basic, collection, nested, composite, and advanced mappings including dependency injection, constants, custom processing, and exception handling.
This tutorial walks through the concepts of Single Sign‑On (SSO) and JSON Web Tokens (JWT), then provides a complete Spring Security integration with JWT—including project structure, RSA key handling, utility classes, custom authentication and verification filters, and step‑by‑step testing using Postman.
This article introduces a Spring Boot‑based open‑source project that demonstrates how to integrate Alipay's various payment modes—including QR code, PC, WAP, and app payments—by detailing the required tech stack, configuration files, deployment steps, and key code snippets.
This guide walks you through setting up a Spring Boot‑based logistics warehouse system, detailing required software versions, the project’s modular features, technology stack, database and backend configuration, frontend setup with Vue, and provides screenshots of key interfaces.
This article walks through creating a Spring Boot project, adding GraphQL dependencies, defining schema files, implementing resolvers and a controller, and testing queries and mutations, providing a quick and flexible way to integrate GraphQL into a Java backend.
Spring Boot 2.5.6, released on October 21, introduces 43 bug fixes, documentation improvements, and numerous dependency upgrades—including Dropwizard Metrics, Ehcache3, HttpCore5, MySQL, and Spring Framework 5.3.12—addressing issues such as R2DBC‑JDBC conflicts, JMX endpoint availability, and memory pressure from caching.
This tutorial explains why API rate limiting is essential for high‑traffic Spring Boot services, introduces counter, leaky‑bucket, and token‑bucket algorithms, shows how to use Guava's RateLimiter, and demonstrates a clean custom‑annotation AOP solution to decouple rate‑limiting logic from business code.
This tutorial explains the concept of idempotency in web APIs and demonstrates a complete Spring Boot solution using Redis, custom annotations, token validation, and interceptor configuration to ensure that each request modifies the database only once, even under repeated calls.
This article explains how to build a QR‑code based login system using Spring Boot, WebSocket, and JavaScript, covering database design, role analysis, API definitions, step‑by‑step implementation, and complete code examples for both backend and frontend components.
This article explains how to secure sensitive Spring Boot configuration properties such as database credentials by integrating the Jasypt library, configuring encryption keys, generating encrypted values through test code, and applying the encrypted strings in application.yml, including deployment‑time salt handling for enhanced security.
This article introduces SOFABoot, an Ant Financial open‑source framework built on Spring Boot that adds readiness health checks, class and log isolation, unified middleware integration, and modular development capabilities, and provides the project’s source repository for developers.
To handle distributed transactions in micro‑service systems, the article compares 2PC, TCC, maximum‑effort notification and reliable messaging, then shows how Spring Boot can use RabbitMQ delayed queues—leveraging dead‑letter exchanges, TTL and routing—to achieve eventual consistency for order‑payment workflows.
This article explains how to implement read/write separation in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, using AOP to switch between master and slave databases, and demonstrates the setup with Maven, MyBatis, and JUnit tests.
This tutorial introduces a music website project built with a Vue.js front‑end and a Spring Boot + MyBatis back‑end using MySQL, and provides step‑by‑step deployment instructions, configuration details, and commands to run the full‑stack application.
This article explains how Spring Boot 2.4.11 processes exceptions, routes them to the default /error endpoint, and uses BasicErrorController along with ContentNegotiatingViewResolver and StaticView to generate HTML or JSON error responses based on the Accept header, including code examples and configuration details.
This tutorial walks you through creating a complete music‑streaming site using Vue.js for the front‑end and Spring Boot/MyBatis for the back‑end, covering core features, required resources, configuration, and deployment commands in a clear, practical manner.
This article introduces EasyPoi, a Spring Boot-friendly library that uses annotations to streamline Excel import and export, covering simple and complex export scenarios, import handling, custom data processing, and provides full code examples for quick integration.
This article explains the difference between synchronous and asynchronous method calls in Java, demonstrates a simple Spring Boot Task class with three time‑consuming methods, shows how to convert them to asynchronous execution using @Async and @EnableAsync, and illustrates how to coordinate completion with Future objects.
This guide walks through integrating Alibaba's EasyExcel library into a Java project, covering Maven dependencies, environment setup, reading Excel files with less or more than 1000 rows (including custom sheet and row offsets), and exporting data using simple lists, model mapping, and multiple sheets, all illustrated with complete code examples.
This guide introduces mica-mqtt, a simple, low‑latency, high‑performance MQTT open‑source component built on t‑io, outlines its extensive feature set, provides Spring Boot and plain Java integration steps, showcases configuration examples, and explains monitoring and clustering capabilities for IoT back‑end development.
This article explains the motivations behind Spring WebFlux, introduces reactive programming concepts, compares annotated controllers with functional endpoints, discusses when to choose WebFlux over Spring MVC, and provides complete code examples for building a reactive CRUD service with Spring Boot.
This article introduces a lightweight Spring Boot‑based mini Tmall e‑commerce project, detailing its core features—from user registration and product browsing to cart, order processing, and admin management—along with the technology stack, UI screenshots, and a four‑step deployment guide for developers.
This tutorial explains how to embed Dataway—a DataQL‑based API configuration UI—into a Spring Boot application, covering Maven dependencies, property settings, database schema creation, datasource integration, Hasor module registration, enabling annotations, and step‑by‑step usage to publish and test APIs without writing traditional controller code.
This article provides a comprehensive overview of Spring MVC request‑mapping annotations, core Spring Bean annotations, dependency‑injection and scope configurations, container setup annotations, and essential Spring Boot annotations, each illustrated with clear code examples and usage tips.
This article explains how the spring-boot-maven-plugin creates a self‑contained executable JAR, describes its internal structure, the manifest configuration, and details the function of Spring Boot Loader classes such as JarLauncher and LaunchedURLClassLoader in launching the application.
This article introduces three MyBatis batch insertion techniques—looped single inserts, MyBatis‑Plus batch inserts, and native SQL batch inserts—provides complete implementation code, performance test results for inserting 100,000 records, analyzes the causes of differences, and offers practical solutions to common pitfalls such as MySQL packet size limits.
This article explains practical API security techniques—including access tokens, timestamps, cryptographic signatures, and anti‑replay measures—illustrated with Java Spring Boot code, Redis storage, custom annotations, and ThreadLocal usage to protect data exchange between services.
This guide explains how to use Spring Boot's @GetMapping attributes to restrict requests by content type, parameters, and headers, compares PathPattern and AntPathMatcher URI patterns, and demonstrates dynamic registration of request handlers through programmatic mapping configuration.
This article explains how to configure and use Spring Boot's ThreadPoolTaskExecutor for asynchronous service methods, shows the required @Configuration and @EnableAsync annotations, demonstrates custom thread‑pool monitoring by extending ThreadPoolTaskExecutor, and provides complete code snippets and log examples.
This guide walks you through upgrading to Alipay’s new transfer interface alipay.fund.trans.uni.transfer, updating the SDK to version 4.10.97, configuring certificates, adding Maven dependencies, creating configuration beans, and implementing utility classes for secure fund transfers in a Spring Boot application.
This tutorial walks through preparing a functional Spring Boot JAR, converting it to an EXE with exe4j, bundling a local JRE, and creating a single‑click installer using Inno Setup, enabling non‑technical users to install and run the application without a separate Java environment.
This article explains what JSON Web Tokens are, their structure and security best practices, and demonstrates a complete JWT‑based authentication example using Spring Boot on the backend, the JJWT library, and an Angular front‑end, including Maven configuration, Java filter, controllers, and client‑side code.
This guide walks through setting up a full‑stack web chatroom demo built with Spring Boot, Vue, WebSocket, MySQL, Redis, RabbitMQ and FastDFS, covering the technology stack, core features, database schema, configuration files, and step‑by‑step deployment instructions.
This article explains how to implement dynamic creation, deletion, start, and stop of scheduled tasks in a Spring Boot application by customizing the ScheduledTaskRegistrar and using a lightweight thread‑pool scheduler, providing full code examples and a complete runnable solution.
This tutorial walks you through setting up iText in a Spring Boot 2.3.10 project, creating a Word‑based PDF template, configuring Adobe Acrobat form fields, and implementing a Java utility class to generate and serve personalized PDFs via a REST endpoint.
This article explains how Spring Boot registers custom error pages with its embedded Tomcat container, covering default HTML/JSON error responses, the underlying auto‑configuration classes, BeanPostProcessor registration, and the BasicErrorController that serves the default /error endpoint.
This article explains the difference between synchronous and asynchronous method calls in Spring Boot, demonstrates how to convert simple task methods to asynchronous ones using @Async, shows how to coordinate multiple async tasks with CompletableFuture, and provides complete code examples and test results.
Microservice architecture introduces complexity, but using scaffolding tools such as Spring Boot and Spring Data lets developers focus on business logic by providing reusable components, reducing duplication, and simplifying data access, while avoiding the pitfalls of building custom persistence layers from scratch.
This article explains how to integrate the Dataway interface‑configuration tool into a Spring Boot project by adding Hasor dependencies, configuring Dataway properties, creating required database tables, setting up the data source, wiring Hasor modules, enabling Hasor in the application, and finally creating and testing a Dataway API without writing any business code.
This tutorial introduces PostgreSQL, compares its advantages over MySQL, shows how to download and install it, and provides a complete Spring Boot integration guide with detailed configuration, entity mapping, repository creation, and unit‑test driven CRUD operations.
This article provides a comprehensive guide to Spring Web MVC and Spring Bean annotations, detailing usage, attributes, and examples of @RequestMapping, @GetMapping, @PostMapping, @ControllerAdvice, @Autowired, @Scope, and various Spring Boot conditional annotations, helping developers understand and apply them effectively.
This article compares the three popular Redis Java clients—Jedis, Redisson, and Lettuce—explaining their core differences, then shows how to configure and use Spring's RedisTemplate, RedissonClient, and annotation‑based caching with practical code examples and configuration files.
This step‑by‑step guide shows how to set up Docker on CentOS 7, install Docker Compose, pull a Tomcat image, create a Spring Boot project, package it, and run it inside a Docker container using both Tomcat and OpenJDK images.
This article explains the difference between synchronous and asynchronous method calls in Java, demonstrates how to implement synchronous tasks, then shows how to convert them to asynchronous execution using Spring Boot's @Async annotation, @EnableAsync configuration, and Future-based callbacks to measure total execution time.
This article provides a comprehensive guide on using ShardingSphere-JDBC for read‑write splitting, configuring MySQL master‑slave replication with Docker, explaining redo log and binlog mechanisms, demonstrating two‑phase commit, and showing how to implement database sharding and distributed primary keys in a Spring Boot application.
This article explains the difference between synchronous and asynchronous calls, demonstrates a Java Spring Boot example that converts blocking methods into concurrent @Async tasks, and shows how to use Future for callback handling to measure total execution time.
This article introduces Spring Boot Actuator, explains how to create a demo project with Maven or Gradle, details the most important built‑in endpoints such as /health, /metrics, /loggers, /info, /beans, /heapdump, /threaddump and /shutdown, and shows how to secure them with Spring Security, providing configuration snippets and code examples.
Learn how to use Spring Boot’s AOP features to automatically fill creator, creation time, updater, and update time fields for any DAO insert or update operation, eliminating repetitive code and ensuring consistent audit logging across all database tables.
This article explains how Spring Boot’s auto‑configuration mechanism operates, covering configuration files, key annotations like @EnableAutoConfiguration, the role of spring.factories, conditional annotations, and how properties are bound to beans to become effective at runtime.
This article compares the Java Redis clients Jedis, Redisson, and Lettuce, explains their distinct features and thread‑safety, and provides detailed Spring Boot configurations and code examples for RedisTemplate, RedissonClient, and cache annotations to implement caching, distributed locks, and atomic operations.
This tutorial shows how to protect sensitive configuration values such as database passwords in a Spring Boot application by integrating the Jasypt library, configuring encryption keys, generating encrypted strings via unit tests or Maven plugin, and securely passing the secret at runtime.
This article explains the challenges of high‑concurrency inventory deduction, demonstrates why simple synchronized locks fail in distributed environments, and walks through multiple solutions—from basic SETNX locks to Redisson’s advanced distributed lock implementation—highlighting pitfalls, expiration handling, and trade‑offs with alternatives like Zookeeper.
This guide explains how Spring Boot 2.4.10 loads configuration files, how to rename and relocate them, use optional and wildcard locations, import additional data, handle profile‑specific files, and import files without extensions, with practical code examples.
This tutorial demonstrates how to leverage Spring AOP in a Spring Boot project to automatically fill common audit columns such as creator, creation time, updater, and update time for database tables, eliminating repetitive manual SQL handling and centralizing logging logic.
This article explains how to improve database insertion performance in Java by replacing per‑iteration inserts with MyBatis‑Plus’s saveBatch method, detailing dependency setup, schema creation, entity, controller, service, and mapper code for efficient bulk operations.
This article explains how to design robust Java backend APIs, covering interface definition, request/response formats, error handling, token generation, digital signing, interceptor chains, rate limiting, HTTPS migration, and strategies for high concurrency and high availability such as load balancing, clustering and caching.
This guide shows how to implement a custom EnvironmentPostProcessor in Spring Boot to decrypt sensitive configuration values such as datasource passwords, explains registration via META-INF/spring.factories, and details the execution order and related Spring Boot internals.
This article explains what JSON Web Tokens (JWT) are, describes their structure and security considerations, and provides a complete Spring Boot and Angular example—including Maven configuration, Java filter and controller code, Angular services and UI—to demonstrate how to generate, validate, and use JWTs for authentication and role‑based access control.
This article explains how to achieve read‑write splitting in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, managing routing keys with ThreadLocal, and using AOP to automatically switch between master and slave databases for different CRUD operations.
Spring Boot 2.5.5, released on September 23, introduces 41 bug fixes, numerous documentation improvements, and a comprehensive set of dependency upgrades, while also adding Java 17 support in Spring Initializr, offering developers a more stable and up‑to‑date backend framework.
This article curates a collection of popular open‑source e‑commerce projects on GitHub and Gitee, covering front‑end, back‑end, micro‑service, mobile, and cloud‑native architectures, with detailed technology stacks, core features, and direct repository links for developers to explore and adopt.
This guide shows how to configure Spring Boot 2.3.9 with RocketMQ 4.8.0, add the necessary dependencies, and implement two message‑filtering methods—tag‑based and SQL‑92 expression‑based—complete with code samples, configuration snippets, and testing steps.
This article introduces a comprehensive open‑source parking lot management system, detailing its five core functions, extensive feature set, modern Java‑Spring backend, Vue frontend, cloud‑ready architecture, and step‑by‑step deployment guide for developers.
This article demonstrates how a Spring Boot thread pool behaves when its core size, max size, and queue capacity are exceeded by multiple asynchronous tasks, explains the resulting TaskRejectedException, and shows how to configure built‑in or custom rejection policies to handle such scenarios.
Spring Boot 2.5.5, released on September 23, introduces 41 bug fixes, numerous documentation improvements, and a comprehensive set of dependency upgrades—including updates to Ehcache3, Kotlin, Netty, and Spring Framework—providing developers with enhanced stability, performance, and compatibility across the ecosystem.
