This article explains Redis' client‑server request model, introduces the pipeline technique, compares normal and pipelined requests, and provides Spring Boot code examples that demonstrate a three‑fold speed improvement when writing 100,000 keys.
This article introduces Java 21’s major enhancements—including lightweight virtual threads and generational ZGC—provides code samples for creating virtual threads and enabling ZGC, demonstrates a Spring Boot 3.x application using record patterns, and explains how to monitor Java 21 services with Alibaba Cloud ARMS on ACK.
This article walks through the theory behind RSA, illustrates two battlefield‑style scenarios for encryption and signing, and then shows how to integrate RSA‑based request/response encryption into a Spring Boot application using Maven, annotations, configuration files, and a JavaScript front‑end, complete with code snippets and troubleshooting tips.
This article explains how to merge multiple user requests on the server side, batch them into a single SQL query using a blocking queue and CompletableFuture, and handle high‑concurrency scenarios with scheduled tasks and timeout‑aware queues to save database connection resources.
This tutorial explains how to configure Spring Cloud Gateway, set up static routes, and then use Nacos for dynamic route management by adding dependencies, configuring bootstrap.yml, defining JSON route data, and implementing a listener bean to refresh routes without restarting the service.
This tutorial provides an in‑depth guide to Spring Boot covering core concepts such as project setup, configuration files, logging frameworks, MVC architecture, CRUD examples, error handling, embedded servlet containers, Docker integration, JDBC/MyBatis/JPA data access, startup process, and how to create custom starter modules.
This article explains the purpose and differences of Spring's @ConfigurationProperties and @PropertySources annotations, provides step‑by‑step guidance for creating POJOs, configuration classes, property files, and demonstrates how to bind and inject configuration values in a Spring Boot application with code examples.
mica-auto is a Spring Boot starter tool that uses annotation processing to automatically generate configuration files such as spring.factories, AutoConfiguration.imports, and spring-devtools.properties, supporting Kotlin meta‑annotations and Java SPI, with Maven and Gradle integration instructions and version compatibility details.
This guide explains why asynchronous request interfaces are essential for high‑concurrency Spring Boot applications, outlines their advantages and typical use cases, and provides step‑by‑step code examples for DeferredResult, Callable, ResponseBodyEmitter, StreamingResponseBody, and reactive Mono implementations.
This article walks through multiple ways to add real‑time in‑site notifications—such as the familiar red‑dot badge—to a web application, covering short and long polling, iframe streaming, Server‑Sent Events, MQTT and WebSocket, with complete Spring Boot code examples and client‑side snippets.
This article explains the essential Spring Boot annotations—including @SpringBootApplication, @EnableAutoConfiguration, @ComponentScan, and the various @Conditional family—detailing their purposes, composition, and usage with clear code examples for Java backend development.
This article explains the core Spring Boot annotations—@SpringBootApplication, @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan—detailing their combined functionalities, usage patterns, and providing Java code examples to illustrate how they simplify application configuration and startup for developers.
This article explores JDK 21's major features including virtual threads, generational ZGC, and new APIs, comparing their performance with traditional threading models and demonstrating practical implementations in Spring Boot.
This article walks you through implementing RSA‑based encryption and digital signatures in a Spring Boot application, covering the theory of asymmetric cryptography, practical code snippets for Maven, configuration, controller annotations, and a JavaScript client that encrypts requests and verifies responses to protect API data from eavesdropping and tampering.
This article dissects how Spring Cloud Config Center integrates with Spring Boot, detailing the startup phases, the prepareEnvironment logic, the bootstrap container that fetches remote configurations, and the @RefreshScope mechanism that enables dynamic property refreshes.
This article explains the principles of RSA asymmetric encryption, illustrates two communication scenarios, and provides a step‑by‑step Spring Boot implementation with Maven dependencies, configuration, annotations, and front‑end JavaScript code to encrypt API requests and decrypt responses, helping developers secure their APIs.
This article explains how to use Redis BitMap to build a memory‑efficient sign‑in feature and continuous‑sign‑in statistics in a Spring Boot microservice, covering basic BitMap commands, key design, core Java code, testing steps, and a bitmap‑based solution for cache‑penetration protection.
This article explains Java memory concepts, demonstrates how to set JVM memory parameters for Spring Boot via startup scripts and configuration files, lists common memory flags, and provides practical tips for reducing memory consumption and improving application performance.
This tutorial explains how to enable and use Spring Cache with annotations like @Cacheable, @CacheEvict, and @CachePut, integrates JSR‑107 and Ehcache, provides full Maven and configuration examples, and demonstrates caching behavior through a series of practical code snippets and tests.
This article walks through the complete Spring Boot startup sequence, starting with the SpringApplication.run entry point, detailing the preparation, application context creation, and refresh phases, and shows how the embedded Tomcat server is instantiated and started, illustrated with code snippets and diagrams.
This article explains why using kill -9 to terminate Linux processes can cause data loss, demonstrates how to gracefully stop Spring Boot services with kill -15, the Actuator shutdown endpoint, and custom shutdown configurations, and shows how to add pre‑destroy hooks for backup tasks.
The article explains the drawbacks of field injection in Spring Boot—such as poor testability, loss of immutability, tighter framework coupling, risk of NullPointerExceptions, and hidden circular dependencies—and demonstrates how constructor injection provides a cleaner, more maintainable alternative with clear code examples.
This article presents a complete Netty TCP client demo built with Spring Boot, detailing the project architecture, module layout, business flow, key code implementations—including a local BlockingQueue, message processing with Redis locks, client initialization, handler logic, and testing endpoints—providing a practical reference for backend developers.
This guide explains why Spring Boot emails may show the default no‑reply address instead of a custom product name and demonstrates how to configure the sender alias using SimpleMailMessage or MimeMessage with code examples.
This article details how a hidden 100 ms delay in a Spring Boot channel system was traced to Tomcat‑embed’s handling of Swagger‑UI resources, diagnosed with Arthas, and resolved by upgrading the embedded Tomcat version.
This article demonstrates how Spring Boot’s connectionTimeout setting influences server‑client connections, using three experiments—controller sleep, HttpURLConnection requests, and raw socket communication—to reveal that the timeout only terminates idle client connections, not the duration of request processing.
Learn how to launch Spring Boot applications with custom JVM and Spring options, understand common parameters like server port, profiles, and property overrides, explore code examples for retrieving values, and grasp the loading order and priority of configuration sources.
Learn how to integrate Elasticsearch 7.8 with Spring Boot 2.4, covering essential dependencies, index management, document CRUD, bulk operations, and advanced queries such as pagination, sorting, filtering, highlighting, aggregations, and grouping, all demonstrated with concise Java High-Level REST client code examples.
This article presents a complete Netty TCP long‑connection demo built with Spring Boot 2.2.0 and Redis, explains the project architecture, module layout, business flow using a local BlockingQueue instead of RocketMQ, and provides detailed source code for the queue holder, processing logic, client implementation, handler, and test controllers.
This article introduces Spring Boot’s core “magic” features—including auto‑configuration, starter dependencies, embedded servers, externalized configuration, Actuator, DevTools, testing support, ecosystem components, performance tips, and continuous learning—providing a comprehensive guide for building efficient Java backend applications.
This article explains how to combine multiple user queries into a single database request using a queue, ScheduledThreadPoolExecutor, and CompletableFuture in Spring Boot, demonstrating code implementations, handling Java 8 CompletableFuture timeout limitations, and showing performance gains through request merging under high concurrency.
After a sudden 500 error crippled an online service, the author traced the issue to Spring Cloud Gateway’s HttpMessageReader creating temporary directories for every request, eventually exhausting inode space; the article explains the root cause, inode basics, and how upgrading to version 5.2.16 resolves the problem.
This article provides a comprehensive guide on implementing WebSocket in Spring Boot, covering three native approaches (Javax, WebMVC, WebFlux) with server‑ and client‑side configurations, and briefly introducing four third‑party libraries (Java‑WebSocket, SocketIO, Netty) for advanced use cases.
This article explains why field injection in Spring Boot should be avoided, highlighting its drawbacks such as poor testability, mutability, tight coupling, risk of null‑pointer exceptions, and circular dependencies, and demonstrates how constructor injection offers a cleaner, more maintainable alternative with code examples.
This article demonstrates how to secure Spring Boot API data using RSA asymmetric encryption, covering the theory of RSA, step‑by‑step project setup, Maven dependencies, annotations for automatic encryption/decryption, Java and JavaScript client implementations, and practical testing of encrypted endpoints.
This guide walks through installing Apache Ignite via Docker, configuring it alongside MySQL in a Spring Boot project, setting up data sources and MyBatis, and performing benchmark tests to illustrate Ignite’s superior in‑memory SQL performance compared to traditional MySQL setups.
This article explains how to enable fuzzy searches on encrypted sensitive fields such as names, phone numbers, and ID numbers in a Spring Boot backend by using a tokenized ciphertext mapping table, outlining four possible solutions, recommending the tokenized approach, and providing complete configuration and code examples.
This article explains practical methods to protect sensitive API data in Spring Boot applications, covering encryption, masking, access control, logging, HTTPS, and database security, and demonstrates three implementation approaches: SQL‑level masking, field‑level encryption, and custom Jackson serialization using annotations and a contextual serializer.
This article explains the fundamentals of microservice architecture, introduces Spring Cloud and its core components, and provides a step‑by‑step tutorial for building a distributed e‑commerce system using Spring Boot, Eureka, Ribbon, Feign, and related Spring Cloud features.
This tutorial demonstrates how to integrate a custom MyBatis TypeHandler in a Spring Boot 2.6.12 application to automatically encrypt sensitive fields before persisting them to MySQL and decrypt them on retrieval, covering dependencies, configuration, entity definition, encryption utilities, mapper XML, and test cases.
This article introduces Spring Native, explains how it uses GraalVM to compile Spring Boot apps into native executables with sub‑100 ms startup and lower memory usage, provides step‑by‑step setup and Docker build instructions, and compares its performance against traditional Spring Boot launches.
This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes key concepts such as pointcuts, advice, aspects, and weaving, and provides step‑by‑step code examples—including simple and advanced use cases and detailed annotation usage—to help developers integrate AOP effectively into their Spring Boot applications.
This step‑by‑step guide shows how to install and configure Docker on CentOS 7, optionally set up docker‑compose, pull a Tomcat image, build a Spring Boot project, package it, and run it inside a Docker container, including commands for mounting, port mapping, and verifying the deployment.
This article demonstrates how to implement a captcha‑based login mechanism in a Spring Boot application with a front‑end/back‑end separation, detailing the traditional session‑based approach, the new Redis‑backed token solution, and providing complete code examples for configuration, service, controller, and data objects.
This guide explains what Swagger is, why it’s useful for RESTful APIs, and provides step‑by‑step instructions for integrating Swagger 3.0 with Spring Boot 2.7, handling version conflicts, customizing documentation, adding security, and using annotations to enrich API metadata.
This article presents a comprehensive set of Spring Boot best practices for developers, covering proper package structuring, design patterns, starter dependencies, production-ready versions, Lombok usage, constructor injection, slf4j logging, controller responsibilities, service layer logic, null‑pointer avoidance, collection handling, pagination, caching, custom exception and response handling, code cleanup, meaningful naming, case conventions, simplicity, formatting standards, and tooling such as SonarLint.
An in‑depth guide explains three rate‑limiting algorithms—counter, leaky bucket, and token bucket—demonstrates their implementation in Spring Boot using Guava’s RateLimiter and Baidu’s ratelimiter‑spring‑boot‑starter, provides full Maven dependencies, configuration snippets, and Java code examples, and shows testing results.
This article explains how to structure a Spring Boot controller by describing the four parts of a request, demonstrating elegant parameter validation, implementing a unified response wrapper with status codes, and handling both validation and business exceptions through centralized advice and custom exception classes.
This article demonstrates how to merge multiple user‑info requests on the server side using a blocking queue, ScheduledThreadPoolExecutor, and CompletableFuture in Spring Boot, thereby consolidating SQL queries into a single batch call to save database connection resources while handling high concurrency.
This guide explains how to implement delayed and priority queues in RabbitMQ 3.8 using Spring Boot 2.6, covering dead‑letter exchange configuration, message expiration, priority settings, code examples for sending and consuming messages, and practical considerations such as priority limits and ordering behavior.
This article explains how to standardize API return formats with a generic Result object, define error codes and custom exceptions, implement a global exception handler, use ResponseBodyAdvice for automatic response wrapping, and package these utilities into a reusable Spring Boot starter for cleaner backend code.
Spring Boot 3.0.0 M1 introduces a Java 17 baseline, requires migration of all Java EE APIs to Jakarta EE, removes support for several third‑party libraries, updates numerous Spring project dependencies, and outlines the upcoming release cadence, while also highlighting community resources and promotional offers.
Learn how to capture MySQL data changes using Debezium's CDC capabilities within a Spring Boot application, avoiding heavyweight message brokers by leveraging binlog monitoring, configuring connectors, handling snapshots, and processing change events for use cases like cache invalidation, data integration, and simplifying monolithic architectures.
This article provides a detailed guide on implementing unified exception handling in Spring Boot applications, covering background concepts, the use of @ControllerAdvice and @ExceptionHandler, custom assertion utilities, error response structures, and practical examples for handling various controller and service layer exceptions efficiently.
This article compares Server‑Sent Events, WebSocket, and long‑polling for real‑time data push in Spring Boot, explains their communication models, performance trade‑offs, and provides complete server‑side and client‑side code examples for implementing SSE and custom event types.
This article provides a detailed overview of Spring MVC and Spring Boot annotations such as @RequestMapping, @GetMapping, @PostMapping, @RequestBody, @ControllerAdvice, @Component, @Bean, @Scope, @Autowired, and others, explaining their purposes, attributes, usage patterns, and offering practical code examples for each.
This guide walks through installing MySQL in Docker, configuring master‑slave replication, verifying synchronization, deploying a Canal server, and integrating it with a Spring Boot application to automatically push database changes into Redis.
This tutorial shows how to activate Java 21 virtual threads in Spring Boot 3.1 (and earlier versions), provides full configuration code for Tomcat, Undertow and Spring async, and demonstrates a performance test where concurrency gains reduce total execution time by over five times.
This article explains how to integrate feign-reactor with Spring Boot 2.7, covering OpenFeign features, reactive client setup, code examples, timeout configuration, and programmatic usage to enhance microservice communication.
This article explains how to replace repetitive try‑catch blocks with a unified exception handling framework in Spring Boot, using @ControllerAdvice, custom Assert utilities, and enum‑based error codes, while showing concrete code examples, configuration steps, and runtime results.
This article demonstrates how to create a custom HttpMessageConverter in Spring Boot 2.6.12 to parse a simple “name:张三,age:20” string into a Users object, configure it in WebMvc, and explains the underlying Spring MVC request‑handling flow that invokes the converter.
Oracle's Java 21 release introduces virtual threads, record patterns, ordered collections and a preview FFM API, while Eclipse survey data shows rising Spring and Spring Boot usage and accelerating cloud‑native adoption among Java developers.
This guide walks through setting up a Spring Boot project with JDK 8, Atomikos, and JPA to manage two MySQL data sources, configure JTA transaction handling, define entity managers, services, and a controller, and demonstrates successful and failing transaction scenarios with code snippets and screenshots.
This article introduces the Erupt framework—a pure‑Java, annotation‑driven backend admin solution that requires no front‑end code, generates CRUD interfaces automatically, and can spin up a complete management system in just a few minutes, with step‑by‑step setup, configuration, and customization examples.
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.
