This article explains how to configure a Spring Boot ThreadPoolTaskExecutor, enable asynchronous execution with @Async, create a custom visible executor to log pool statistics, and demonstrates the complete workflow with code examples and runtime logs for improving database insert performance.
This guide explains the principle and step‑by‑step implementation of reliable transactional messaging using Spring Boot 2.3.9 and RocketMQ 4.8.0, covering execution flow, broker handling, project structure, code examples for entities, repositories, services, listeners, and testing.
This article shares a developer’s experience converting a Java Spring Boot microservice to Kotlin, covering why Kotlin is attractive, required Maven plugins and dependencies, code‑migration quirks such as open classes and @Jvm annotations, testing hurdles, and the final decision to revert to Java.
This article provides a comprehensive guide to Spring MVC request‑mapping annotations, Spring Bean lifecycle and dependency‑injection annotations, as well as Spring Boot conditional and configuration annotations, illustrating each with code examples and usage notes for Java backend development.
This guide walks through installing OpenOffice on a Windows server, launching its headless service, adding jodconverter dependencies to a Spring Boot project, configuring conversion settings, writing a controller to transform DOC files into HTML, and invoking the endpoint from a Vue front‑end, with troubleshooting tips.
This tutorial explains why the default shared thread pool for @Async tasks can cause unrelated services to block each other, and shows step‑by‑step how to configure separate thread pools for different async tasks in Spring Boot, complete with code examples and a unit test.
This guide shows how to configure a Spring Boot 2.3.12 application with Elasticsearch 7.8, create index templates, implement a reusable bulk operator service, and test bulk insertion of task data into dynamically named indices, ensuring automatic index creation and proper mapping.
This article explains why using @Async in Spring Boot can cause memory overflow when many requests trigger parallel tasks, examines the default thread‑pool settings that lead to unbounded queues, and provides step‑by‑step configuration of a safe thread pool to prevent out‑of‑memory failures.
This article walks through building a web‑based, high‑efficiency image captcha labeling system using a Vue admin template for the frontend and Spring Boot for the backend, detailing functional modules, technology stack, deployment steps, and demo results to streamline data annotation before AI model training.
This article introduces the Micrometer metrics library for JVM applications, explains its core Meter types and registries, demonstrates how to instrument Spring Boot services with counters, timers, gauges, and other meters, and shows end‑to‑end integration with Prometheus and Grafana for monitoring.
The SpringOne conference announced that Spring Framework 6 and Spring Boot 3 will reach production‑ready GA status in Q4 2022, outlined their milestone and release‑candidate schedule, required JDK 17 and Jakarta EE 9 compatibility, detailed Spring Native's native‑image support, and previewed upcoming Spring Boot 2.6 and 2.7 releases.
This article explains how to implement delayed message delivery in RabbitMQ using the official delayed‑queue plugin and Spring Boot, compares traditional approaches such as Redis expiration and database polling, and provides complete configuration and code examples for producers and consumers.
This article explains how to handle multi‑gigabyte video uploads by splitting files into chunks, using MD5 for identification, implementing resumable and instant uploads with Spring Boot and Redis, and leveraging Java's RandomAccessFile and memory‑mapped I/O for efficient merging.
This guide demonstrates how to set up Spring Boot 2.3.12 with Elasticsearch 7.8, configure separate JPA and Elasticsearch repositories, and implement two batch insertion methods—using ElasticsearchRestTemplate and repository saveAll—while measuring performance, showing comparable execution times for inserting 10,000 records.
This article explains the difference between synchronous and asynchronous method calls in Spring Boot, shows how to convert blocking tasks into @Async methods, demonstrates unit‑test setups with CompletableFuture for proper coordination, and provides complete code examples to reduce overall execution time.
This article demonstrates how to use the Jasypt library to encrypt sensitive Spring Boot configuration properties such as database credentials, showing Maven dependency setup, encryption password configuration, test code for generating encrypted values, and how to replace plaintext with ENC() placeholders in application.yml, including deployment salt handling.
This article explains how to use RabbitMQ as a message middleware in a Spring Boot application to achieve distributed transactions between order and dispatch services, detailing environment setup, configuration, code implementation, testing, and verification of data consistency across systems.
The article explains how to protect a flash‑sale inventory using Redis locks in a Spring Boot service, starting with a simple synchronized lock, moving to distributed locks with setIfAbsent, handling lock expiration issues, extending TTL, and finally simplifying the implementation with Redisson.
The SpringOne conference highlighted the upcoming Spring Framework 6.0, detailing its Java 17 and Jakarta EE 9 foundation, roadmap milestones, key migration points, Spring Boot 3 integration, and the imminent Java 17 release, offering developers a clear view of the next decade of Spring development.
This article explains how to achieve database read‑write separation in high‑concurrency scenarios using Spring Boot, covering the concepts of master‑slave architecture, configuration of multiple data sources, routing logic with AbstractRoutingDataSource, context management, custom annotations, AOP handling, and practical usage examples with code snippets.
The article introduces retrofit-spring-boot-starter, a Spring Boot‑compatible lightweight HTTP client library that integrates Retrofit with extensive features such as custom OkHttpClient injection, annotation‑driven interceptors, logging, retry, error decoding, circuit‑breaker support, connection‑pool management, call adapters and data converters, providing a concise way to perform HTTP calls in Java backend projects.
This article demonstrates how to use Spring Boot's AOP features to automatically populate common audit columns such as creator, creation time, updater, and update time during DAO insert and update operations, eliminating repetitive manual SQL handling.
This guide explains how to implement periodic tasks in Spring Boot 2.2.11 using the built‑in @EnableScheduling/@Scheduled approach and the Quartz library, covering configuration, cron expressions, core Quartz concepts, and complete code examples for both methods.
This article demonstrates how to construct a full‑text site search solution by selecting Elasticsearch as the search engine, Spring Boot for the backend service, and the IK analyzer for Chinese tokenization, covering environment setup, project architecture, key code implementations, UI pages, and a concise conclusion on the effectiveness of the approach.
This article demonstrates how to replace complex if‑elseif logic with the Strategy pattern combined with simple and reflection‑based factories in a Spring Boot application, enabling clean, extensible handling of multiple advertising page types.
This guide explains how to add the mica-ip2region starter to a Spring Boot project, covering Maven and Gradle dependencies, built‑in configuration, custom Maven settings for the ip2region.db file, bean injection, available lookup methods, and a complete service example.
This article introduces Sharding-JDBC (now ShardingSphere), explains core sharding concepts such as shards, data nodes, logical and physical tables, sharding keys, algorithms and strategies, shows how it extends JDBC, and provides a step‑by‑step Spring Boot + MyBatis‑Plus example for building a sharded database application.
The article explains the concept of software scaffolding, why it is needed for microservice development, outlines key design principles, shares a real‑world case of replacing a custom persistence layer with Spring Data, and reviews popular scaffolding tools such as Vue CLI, Maven, Netty, Java EE, Dropwizard and Spring Boot.
This tutorial walks you through installing and configuring the ELK stack—Elasticsearch, Logstash, and Kibana—on Ubuntu, then shows how to integrate Spring Boot Logback and Nginx logs for centralized, real‑time log analysis and visualization.
This article explains why developers should switch from JUnit4 to JUnit5, outlines the JUnit5 architecture, shows how to add the proper Maven dependency, and provides practical examples of common annotations, assertions, repeated, parameterized, and nested tests for Spring Boot projects.
This article explains Spring Boot's default logging setup using SLF4J and Logback, demonstrates how to view log levels in a test class, shows how to modify log levels via application properties, and details the underlying XML configuration files and how to customize them for different environments.
The SpringOne conference went online and revealed the upcoming Spring Framework 6.0 built on Java 17 and Jakarta EE 9, outlining its development milestones, key changes from 5.3, cloud‑native enhancements, Spring Boot 3 integration, and the imminent release of Java 17 that will usher in a new era for Java developers.
Knife4j is a lightweight, feature‑rich solution that enhances Swagger UI for Java MVC frameworks, offering customizable configurations, offline document export, and seamless integration with Spring Boot and Spring Cloud micro‑service architectures, while providing open‑source repositories and clear usage instructions.
This guide explains how to replace the deprecated Alipay transfer API with the new alipay.fund.trans.uni.transfer interface by upgrading the SDK, configuring certificates, adding Maven dependencies, and implementing Spring‑Boot beans, configuration classes, and utility methods for secure fund transfers.
This guide walks through the complete backend workflow for generating, sending, and validating SMS verification codes in a Spring Boot application, covering code generation, API integration, session handling, and utility classes with full Java examples.
This article explains how to protect sensitive information in Spring Boot applications by encrypting configuration files with jasypt‑spring‑boot, masking API response fields using a custom Jackson annotation, and filtering log output with a custom Log4j2 PatternLayout, providing complete code examples for each method.
This tutorial demonstrates how to set up a CentOS 7.5 environment, install RabbitMQ, and use Spring Boot to create a distributed transaction system that ensures data consistency across order and dispatch services by leveraging RabbitMQ's confirm and ACK mechanisms, complete with database schema, configuration, and code examples.
This article explains the role of Spring's MergedBeanDefinitionPostProcessor, showing how it merges bean definitions, invokes post‑processors during bean creation, and enables @Autowired‑related dependency injection with code examples and detailed workflow steps.
This article compares synchronous and various asynchronous approaches for invoking multiple third‑party services in a Spring Boot order‑creation workflow, demonstrating plain sequential calls, manual thread creation, thread‑pool execution, CompletionService handling, and CompletableFuture composition, and shows their performance impact through timing results.
This article describes how to model a complex Uber‑style ride‑hailing system using Domain‑Driven Design, implement it with Java Spring Boot microservices, instrument it with OpenTelemetry for full observability, and validate the observability pipeline through a gamified chaos‑engineering approach that reduces MTTR.
This tutorial explains why parameter validation is essential in Spring Boot APIs, shows how to integrate the JSR‑303 Validator, demonstrates custom annotations, group validation, and simplifies error responses with a global exception handler, providing complete code examples for each step.
This guide explains the purpose of Spring Boot's @Enable* annotations, how they rely on @Import, and walks through creating a custom @EnablePack annotation with accompanying configuration and usage in a Spring Boot application.
This article presents a comprehensive GitHub collection of Spring Boot vulnerabilities, explains how to identify information‑leakage and remote‑code‑execution flaws via exposed Swagger and Actuator endpoints, and provides step‑by‑step verification commands for security testing.
This guide demonstrates how to integrate RocketMQ 4.8.0 into a Spring Boot 2.3.9 application, covering dependency setup, configuration, sending and receiving plain, ordered, clustered, broadcast, and transactional messages, with complete code examples and execution results.
This article explains the history, recent updates, and step‑by‑step usage of the Spring Boot Swagger starter, including dependency setup, detailed configuration options, grouping, JSR‑303 validation support, custom response messages, UI tweaks, ignored parameter types, and authorization settings.
This article explains four approaches to adding a generic appkey whitelist check in a Spring Boot web framework—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order and extensibility.
This article demonstrates how to set up comprehensive monitoring for a Spring Boot application by integrating Spring Actuator, Micrometer, Prometheus, and Grafana, covering component introductions, sample code creation, Docker-based Prometheus and Grafana deployment, and dashboard configuration for real‑time metrics visualization.
This guide explains RabbitMQ dead‑letter queues, covering the conditions that turn messages into dead letters, how to configure exchanges and queues with x‑dead‑letter‑exchange, TTL, and max‑length, and provides step‑by‑step Spring Boot code examples for testing each scenario.
This article examines the advantages and hidden risks of using Lombok in Java projects, illustrating how its annotations can dramatically reduce boilerplate code while also introducing version compatibility issues, forced dependencies, reduced readability, increased coupling, and technical debt, and suggests alternative approaches for cleaner code.
This guide walks through converting a Spring Boot JAR into a Windows executable using exe4j, configuring the EXE for 32/64‑bit compatibility, adding VM parameters, and then packaging the EXE together with a local JRE into an installer with Inno Setup, providing step‑by‑step screenshots and script details.
This article explains six practical techniques for executing custom logic during Spring Boot startup, covering ApplicationListener events, CommandLineRunner, ApplicationRunner, @PostConstruct, @Bean initMethod, and InitializingBean, with code examples and brief analysis of each approach.
This article walks through the evolution of Redis‑based distributed locks, illustrating common pitfalls and step‑by‑step improvements—from simple set‑if‑absent locks to atomic UUID checks and Lua‑scripted releases, culminating in a robust Redisson solution.
This guide walks through creating a Spring Boot 2.2.11 OAuth2 authorization server that stores tokens in Redis, defines custom client and user entities, configures grant types, and demonstrates testing each flow, complete with code snippets and configuration files.
This step‑by‑step tutorial explains how to create Restful file upload and download APIs using Spring Boot 2.2.6, covering environment setup, project structure, interface and implementation details, size‑limit configuration, global exception handling, and testing the endpoints with Postman.
This guide explains how to integrate OAuth2 with Spring Boot 2.3.10, troubleshoot missing OAuth2AuthorizationRequest in the session, and resolve the issue by adjusting host configuration and domain settings, providing full code snippets and configuration details.
This tutorial walks through setting up Spring Authorization Server 0.2.0 on Spring Boot 2.5.3, covering required dependencies, security configuration, SAS server setup, testing the authorization code flow, token exchange, refresh, and revocation, with complete code snippets and curl commands.
This article explains how Spring Boot's auto‑configuration works by loading configuration classes from spring.factories, using @EnableAutoConfiguration and conditional annotations to bind properties from application.properties or application.yml to beans such as ServerProperties, enabling rapid backend development without extensive manual setup.
Learn how to configure a Spring Boot 2.3.11 project with MyBatis 3.5.6, set up dependencies, pagination, mapper scanning, define mapper interfaces with annotations, implement dynamic SQL providers, and write comprehensive unit tests to verify CRUD operations.
This guide walks through setting up WeChat web authorization, customizing Spring Security's OAuth2 flow, handling token exchange, and retrieving user info, providing a complete backend solution for secure WeChat-enabled applications.
This article explains why a DecryptionException occurs when using Jasypt in Spring Boot, outlines the typical reasons such as mismatched passwords or missing Unlimited Strength JCE, and provides step‑by‑step instructions to resolve the issue.
This article walks through setting up Spring Boot Actuator for microservice monitoring, explains the most important endpoints such as /health, /metrics, /loggers, shows how to expose and secure them, and demonstrates dynamic log level changes, custom health indicators, and integration with Spring Security.
The article introduces mica-mqtt, an open‑source MQTT component built on t‑io that offers simple, low‑latency, high‑performance messaging, outlines its features, provides Spring Boot and plain Java integration steps, shows configuration examples, and explains monitoring and clustering capabilities for IoT applications.
This step‑by‑step guide shows how to configure a Spring Boot application with Log4j2, ship logs via Filebeat to Kafka, process them with Logstash, and visualize the data in Elasticsearch and Kibana, covering server setup, Maven dependencies, configuration files, and deployment commands.
The article explains why traditional polling methods fall short for real‑time data, introduces the WebSocket protocol’s full‑duplex handshake and heartbeat mechanisms, and demonstrates how a Java‑based WebSocket service efficiently streams audio to an ASR engine for low‑latency speech recognition.
The article explains how to implement distributed tracing in a microservice architecture using Spring Cloud Sleuth and Zipkin, covering the concepts of spans and traces, configuration steps, code examples, deployment methods, sampling considerations, and persistence options such as MySQL and Elasticsearch.
This article provides a detailed walkthrough of ShardingSphere‑Jdbc read/write splitting, MySQL master‑slave replication setup with Docker, the differences between redo log and binlog, two‑phase commit, and practical sharding configurations using inline strategies and distributed primary keys in a Spring Boot project.
Learn how to integrate Spring Data Redis with Spring Boot, replace Jedis with Lettuce, define data models using @RedisHash and @Indexed, configure connection properties, implement CRUD and example queries, and understand the underlying key-value storage patterns illustrated with practical code and visual examples.
This guide walks through setting up Kafka Streams with Spring Boot 2.3, covering environment configuration, core concepts, topology design, and multiple practical examples—including message sending, listening, transformations, aggregations, filtering, branching, and multi‑field grouping—complete with full code snippets and execution results.
This article explains the inner workings of Spring Cloud's RefreshScope, covering its annotation definition, registration in the auto‑configuration, the refresh endpoint workflow, event handling, and how beans annotated with @ConfigurationProperties or @RefreshScope are dynamically refreshed at runtime.
This article explains how Spring Boot’s auto‑configuration works, covering configuration files, key annotations like @EnableAutoConfiguration, conditionals, and the role of XxxxProperties and XxxxAutoConfiguration classes in binding properties and loading beans into the Spring container.
This article explains why a custom AOP annotation like @MyMonitor may not trigger advice in Spring Boot, analyzes the proxy‑based limitation of Spring AOP, and provides practical solutions such as self‑injection or AspectJ mode to ensure the advice executes correctly.
This guide demonstrates how to create a custom request‑handling method, register it programmatically with Spring MVC's RequestMappingHandlerMapping, and explains the underlying handler detection and mapping process in Spring Boot 2.2.
The article introduces mica-mqtt, a lightweight, low‑latency, high‑performance MQTT component built on t‑io, detailing its features, configuration for Spring Boot and plain Java projects, custom interfaces, clustering, monitoring with Prometheus‑Grafana, and provides code examples for both server and client integration.
This article recounts the author’s experience building a simple Java web application for a university anniversary, covering planning, environment setup, documentation, database design, coding challenges with Spring Boot, Redis, and session handling, deployment on Alibaba Cloud, and the lessons learned about architecture, logging, and monitoring.
This article demonstrates how to create a custom @AccessLimit annotation in Spring Boot, implement a rate‑limiting interceptor that checks request frequency via Redis, register the interceptor, and apply the annotation to controller methods to enforce request limits with optional login verification.
This comprehensive guide dives deep into Spring Validation, covering basic usage, dependency setup, requestBody and requestParam validation, group and nested validation, custom constraints, fail‑fast mode, and the underlying implementation in Spring MVC and AOP, all with practical code examples.
By illustrating how to replace simple HashMap caching with Redis‑based distributed caches and locks—using SETNX, Lua scripts, and Redisson—the article shows Spring Boot developers how to prevent cache breakdown, ensure data consistency, and dramatically improve throughput in high‑concurrency web applications.
This tutorial explains step‑by‑step how to add Keycloak authentication to a Spring Boot application using the Spring Security adapter, covering Maven dependencies, configuration files, custom resolvers, role mapping, session strategies, and the typical authorization code flow.
This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring Boot interceptor that checks Redis for request counts, register the interceptor, and apply the annotation to a controller method to enforce rate‑limiting with optional login verification.
Learn how to configure Spring Boot Security's remember‑me feature with a persistent token repository, set up the necessary SQL, customize the login page, and understand the underlying authentication flow to prevent duplicate logins and maintain user sessions across browser restarts.
This article walks through the Spring Security authentication flow in a Spring Boot 2.2.11 application, detailing filter execution, token creation, provider selection, custom DaoAuthenticationProvider configuration, and session management, complemented by code snippets and diagrams for each step.
This article introduces WebSocket, explains why it is preferred over HTTP for real‑time communication, and provides a complete Spring Boot integration tutorial with Maven dependencies, configuration, server endpoint code, controller, and a simple HTML client, all illustrated with runnable examples.
This article explains the challenges of distributed locking, compares existing lock services, and details the design, implementation, and monitoring features of the ylock framework, which provides reentrant read‑write locks over Redis and Zookeeper with unified APIs and Spring Boot integration.
This article explains how to use Spring Boot's @ControllerAdvice and @ExceptionHandler annotations to implement clean, global exception handling, covering basic usage, controller‑specific handlers, and ordered advice for multiple handlers, with practical code examples and diagrams.
This article walks through configuring Spring Boot 2.2.11 with Seata 1.3.0, detailing environment setup, dependency configuration, global transaction activation, proxy bean creation, data source proxying, transaction interceptor mechanisms, XID propagation via RestTemplate and Feign, and the complete commit‑and‑rollback workflow.
This article explains how to implement graceful shutdown and startup for microservices using JVM shutdown hooks, Spring Boot listeners, Docker stop signals, and external container scripts, providing code examples and best‑practice recommendations for both built‑in and external containers.
Learn how to configure and use the open‑source time‑series database InfluxDB in a Spring Boot application, covering essential concepts, dependency setup, property configuration, scheduled data writing, and verification via InfluxDB CLI, with complete code examples.
This article explains how Spring Boot’s @SpringBootApplication annotation combines several meta‑annotations, how auto‑configuration classes are loaded from META‑INF/spring.factories, and demonstrates building a custom starter that configures a Tomcat web server, with full code examples and Maven setup.
Magic-API is a Java-based rapid development framework that enables developers to create HTTP API interfaces without writing traditional controller, service, DAO, or XML code, offering extensive features, quick-start Maven integration, configurable properties, and a visual UI for managing endpoints.
This tutorial demonstrates how to combine Spring Boot, WebMagic, and MyBatis to crawl Zhihu pages, configure Maven dependencies, set up MySQL data sources, define entity and mapper classes, and schedule the crawler to run periodically, providing a complete Java web‑crawling scaffold.
This guide explains how to replace the old Alipay transfer interface with the new certificate‑based alipay.fund.trans.uni.transfer API, upgrade the SDK, configure certificates, add Maven dependencies, and implement Spring‑Boot beans and utility classes for secure payment and transfer operations.
This article compares four Spring Boot techniques—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—for implementing a generic appkey whitelist validation, explains their implementation steps with code examples, and clarifies their execution order within the request processing pipeline.
This article explains four Spring‑Boot techniques—traditional AOP, HandlerInterceptor, HandlerMethodArgumentResolver, and Servlet Filter—to implement a reusable appkey whitelist validation, provides complete code examples for each, and clarifies their execution order within the request processing pipeline.
This article introduces wx‑manage, an open‑source WeChat public‑account management system that supports multiple accounts, offering menu, auto‑reply, material management, and a simple CMS, and details its Spring Boot‑based tech stack, required environment, and where to obtain the source code.
This guide walks through configuring Seata’s registry and configuration centers with Nacos, setting up MySQL storage, defining service modules, writing transactional code with @GlobalTransactional, and verifying rollback behavior in a Spring Boot 2.3 microservice project.
This guide explains how to upgrade Spring Boot projects to Nacos‑Spring‑Boot 0.2.10, covering new features such as full Nacos 2.0 compatibility, automatic config‑type detection, SpEL support, and high‑concurrency fixes, and provides step‑by‑step client and server deployment instructions with verification.
This guide explains the fundamentals of JSON Web Tokens, their structure and claim types, typical use cases such as authorization and secure data exchange, and provides a step‑by‑step Spring Boot implementation including dependency setup, token generation, interceptor validation, and protected endpoint testing.
This step‑by‑step guide shows how to set up the Sentinel dashboard, add the Sentinel client to a Spring Boot project, define protected resources programmatically or with annotations, start the dashboard, and configure flow‑control and degradation rules to limit API traffic.
This article explains Aspect‑Oriented Programming (AOP) in Spring Boot, covering its core concepts, why it simplifies cross‑cutting concerns like logging and permission checks, provides step‑by‑step code examples of simple and advanced AOP implementations, and details the most commonly used AOP annotations.
This article walks through setting up GitLab CI to automatically build a Spring Boot JAR, create Docker images for Java 8 and Java 11, push them to a private registry, and deploy them to a server, covering required Dockerfiles, .gitlab-ci.yml configuration, environment files, and necessary GitLab variables.
