Spring Boot loads configuration files in a defined order, giving higher priority to application.properties over application.yaml, and searches locations such as file:./config/, file:./, classpath:/config/, and classpath:/, with merging behavior that interviewers often test.
This article walks through integrating Spring Boot with Netty and using Google Protobuf for binary data exchange, covering Protobuf basics, Maven setup, code generation, server and client implementations, heartbeat handling, reconnection logic, and testing results, all with complete Java examples.
This tutorial walks you through downloading RuoYi-Vue 3.1, creating a MySQL database, importing required SQL files, configuring Redis and application settings, and then launching the Spring Boot back‑end and Vue front‑end so you can access the admin console at http://localhost:81/.
This article provides a detailed overview of common Spring Boot, Spring MVC, and JPA annotations—including @SpringBootApplication, @RestController, @RequestMapping, and JPA mapping annotations—explaining their purposes, usage patterns, and example code snippets for building Java backend applications.
This article explains how to design and build a simple two‑level caching solution in Java, covering generic cache interfaces, local caching with Guava, distributed caching with Redis, configuration details, version‑controlled cache keys, and practical usage within a Spring Boot application.
This article introduces a Spring Boot API project seed that combines MyBatis, a generic Mapper plugin, and PageHelper, offering ready‑made project structure, unified response handling, exception processing, code generation utilities, signature authentication, and integration guides to accelerate backend development.
This article explains the fundamentals of message queues, why they are needed for decoupling, asynchronous processing and throttling, introduces JMS concepts, details ActiveMQ storage options and protocols, and provides practical Java and Spring Boot code examples for producers, consumers, and advanced features such as transactions, persistence, and delayed delivery.
This article demonstrates how to build a robust email‑sending service using Spring Boot and RabbitMQ, covering message confirmation, consumer idempotency, retry mechanisms, configuration details, and complete source code examples for producers, consumers, and scheduled re‑delivery tasks.
This article provides a detailed overview of common Spring Boot annotations, their purposes, usage examples, and related code snippets, helping developers understand how to configure and build RESTful Java applications efficiently.
An open-source Java Spring Boot project demonstrates license plate detection and recognition using OpenCV, supporting multiple plate colors, with SVM and ANN training, detailed architecture, feature list, installation guide, and visual processing steps, offering a beginner-friendly tutorial for image recognition enthusiasts.
This tutorial walks you through registering a QQ Connect application, adding the required Maven dependency, creating the login page, implementing the Spring Boot controller and AuthComment utility class, configuring Freemarker, and handling the OAuth flow to achieve seamless QQ authentication in a Java backend.
Learn how to accelerate Java applications on Google Cloud Run by minimizing container image size, leveraging container-aware JVM settings, reducing thread usage, and applying Spring Boot-specific tweaks such as layered JARs, lazy initialization, and avoiding background tasks to cut startup latency and memory consumption.
This article demonstrates how to construct a well‑structured Spring Boot backend API by integrating request validation with Hibernate Validator, implementing global exception handling, defining custom exceptions, and standardizing responses using a unified response object and response‑body advice.
This article explains the three primary ways to launch a Spring Boot application—running a class with a main method, using the java -jar command, and leveraging the spring-boot-maven-plugin—along with code examples, configuration details, and Maven command options.
This tutorial walks through integrating MyBatis with Spring Boot, covering Maven dependencies, datasource configuration, mapper scanning, basic CRUD XML mappings, the differences between #{ } and ${ }, auto‑generated key handling, SQL fragments, and enabling camel‑case mapping for seamless Java‑to‑database interaction.
The article details a step‑by‑step investigation of abnormal swap memory consumption in a Spring Boot project, revealing that native memory allocated by the Inflater during JAR scanning was not released promptly, leading to apparent memory leaks that were ultimately resolved by configuring package scanning and updating Spring Boot.
This article describes how a team released resources after shutting down a business line, focusing on the difficulties of deleting Redis keys from a shared cluster, the step‑by‑step approach using code search, Python scripts, SCAN and DEBUG OBJECT commands, and the implementation of a custom key‑prefix serializer to prevent future issues.
This article explains the high‑severity CVE‑2020‑24616 deserialization flaw in jackson‑databind, identifies affected Jackson and Spring Boot versions, and provides Maven‑based remediation steps such as version pinning, dependency exclusions, and dependencyManagement configuration to prevent remote code execution.
This article explains why the HTTP trace feature disappears in Spring Boot Admin after version 2.2.x, details the investigation steps that reveal the default disabling of the InMemoryHttpTraceRepository, and recommends using third‑party tracing solutions such as Prometheus with Grafana for observable metrics.
This article explains the core purposes of message queues such as converting synchronous operations to asynchronous, decoupling services, and handling traffic spikes, then details RabbitMQ architecture, various exchange types (Direct, Topic, Fanout), provides Spring‑Boot code examples for producers and consumers, and discusses persistence, acknowledgment mechanisms, and best‑practice configurations for reliable messaging.
This article provides a thorough tutorial on Spring Validation, covering basic usage with requestBody and requestParam, dependency setup, group, nested, collection and custom validations, programmatic validation, fail‑fast mode, differences between @Valid and @Validated, as well as the underlying implementation mechanisms in Spring MVC and method‑level AOP validation.
This article introduces MyBatis‑Plus, a powerful Java ORM that eliminates the need for manual XML mappings by providing ready‑made CRUD APIs, demonstrates how to configure Maven dependencies, define entity and mapper classes, and implement common database operations such as insert, delete, update, select, pagination, and complex conditional queries within a Spring Boot controller, all while showing the generated SQL statements.
This article explains how to use Apache RocketMQ's 2PC-based transactional messaging feature, covering the overall workflow, key concepts such as half messages and compensation, and providing complete Java/Spring Boot code examples for producers, transaction listeners, and consumers.
This guide explains the fundamentals of email protocols, shows how to configure Spring Boot’s mail starter, and provides complete code examples for sending plain‑text and HTML emails—including dependency setup, property configuration, and unit‑test snippets—so developers can quickly integrate reliable email functionality into their Java backend applications.
This tutorial demonstrates how to generate simulated web access logs in Python, schedule them with Crontab, collect them in real time using Flume, forward them to Kafka, process the streams with Spark Streaming, store results in HBase, and visualize the data via a Spring Boot application with ECharts.
This guide explains how to use Spring Boot's ActiveMQ starter to configure, code, and test both queue (point‑to‑point) and topic (publish‑subscribe) messaging, covering JMS fundamentals, project setup, bean definitions, listener annotations, and dual‑mode container factories.
This article walks through implementing message confirmation in a Spring Boot application using RabbitMQ, covering environment setup, configuration, producer and consumer callback implementations, acknowledgment methods, common pitfalls such as missed acks and infinite redelivery, and practical debugging and retry strategies to ensure reliable messaging.
This article explains how to achieve API idempotency in a Spring Boot application by generating unique tokens, storing them in Redis, and using a custom @ApiIdempotent annotation with an interceptor to prevent duplicate requests, including code examples, configuration, and testing procedures.
Spring Boot 2.4.0-M2 has been released, bringing a host of backend enhancements such as non‑reflection configuration processing, optional cookie tracing, HTTP/2 improvements, new r2dbc support, Redis Cluster controls, and added authentication for Prometheus, all detailed in the official release notes.
Spring Boot 2.3.3 has been released with 67 bug fixes, new features like Jetty HTTP/2 support without Conscrypt, and a long list of library upgrades, all available via Maven Central and repo.spring.io for Java backend developers.
This article explains why identifying a user's city via IP is crucial for operations, outlines various IP-to-city methods, and provides a complete Spring Boot implementation—including IP extraction, QQWry library integration, custom interceptors, and REST endpoints—to count visits per city.
This article demonstrates how to integrate the Apache Shiro security framework into a Spring Boot application, covering Maven dependencies, Shiro configuration, custom Realm implementation, login authentication, controller-level access control, and Thymeleaf front‑end button visibility based on roles and permissions.
This guide compares four Java scheduling options—Timer, ScheduledExecutorService, Spring Task, and Quartz—showing how to implement each in Spring Boot, configure cron expressions, enable async execution, and choose the right tool for your needs.
This guide explains how to integrate Retrofit into a Spring Boot project using the retrofit‑spring‑boot‑starter, covering dependency setup, annotation configuration, custom interceptors, connection pool management, logging, exception formatting, call adapters, converters, and global interception to make HTTP client development more elegant and maintainable.
Mica, originally derived from the internal lutool project, is a lightweight Java 8‑based microservice core that supports both traditional Servlet and Reactive WebFlux, auto‑generates Spring configuration, adds metrics, Redis utilities, RSA helpers, and integrates with Prometheus and Grafana, with its source available on GitHub and Gitee.
This guide walks you through creating a three‑node Kafka cluster with Zookeeper using Docker‑Compose, configuring the necessary YAML, launching the containers, and then integrating the cluster into a Spring Boot application by adding dependencies, setting Kafka properties, defining message, sender, and receiver classes, and testing the message flow.
ElasticJob 3.0.0‑alpha introduces a Spring Boot starter for ElasticJob‑Lite, one‑time tasks, expanded database support for execution logs, environment‑variable IP declaration, and several API changes including a new Maven groupId, package name, namespace, SPI‑based job types, and modular UI separation.
This tutorial explains how to build a custom Spring Boot starter in four steps—setting up a Maven project, defining auto‑configuration with AOP, registering the starter via spring.factories, and packaging it—so that methods annotated with a custom @AspectLog annotation automatically log their execution duration.
This article explains how Spring Boot automatically starts an embedded Tomcat server, detailing the main entry point, context creation, refresh process, and the internal Tomcat components that are instantiated and started during application startup.
Learn how to create a custom Spring Boot starter named aspectlog-spring-boot-starter that automatically logs method execution times using AOP, covering project setup, Maven configuration, conditional loading, annotation definition, auto‑configuration class, META‑INF registration, and packaging for reuse in other projects.
This article explains how to use RocketMQ with Spring Boot to implement peak‑shaving, covering core components, consumer configuration, Maven setup, code examples, performance testing, and strategies for dynamic scaling and batch consumption.
This guide shows how to set up a Docker‑Compose Kafka cluster with Zookeeper, run it, and integrate the cluster into a Spring Boot application using Spring Kafka, including required dependencies, configuration, and sample producer‑consumer code, plus testing via a REST endpoint.
This article explains how to implement automatic idempotency for Spring Boot APIs using Redis, a custom @AutoIdempotent annotation, token generation and validation, and an interceptor, providing step‑by‑step code examples, configuration details, and testing procedures to ensure each request is processed only once.
This article explains how to design a high‑frequency like/unlike feature by caching operations in Redis, persisting data to a relational database at regular intervals, and orchestrating the process with Spring Boot, Spring Cloud, and Quartz scheduled jobs, complete with code examples and schema design.
This guide demonstrates how to integrate Apache Shiro into a Spring Boot application, covering project setup, Maven dependencies, configuration of Redis-backed session and cache management, creation of utility and realm classes, and implementation of role‑based permission controls with example controllers and Postman testing.
This article explains how Spring Boot simplifies Java application development by providing out‑of‑the‑box starters, automatic configuration via spring.factories, and convention‑over‑configuration rules, covering the underlying annotations, Maven structure, starter dependencies, main class, and the use of @ConfigurationProperties to bind YAML settings.
This article introduces an open‑source Java Spring Boot project that implements a license‑plate detection and recognition system with training capabilities, detailing its features, architecture, supported plate types, software requirements, processing steps, installation guide, and reference resources.
This guide walks you through creating a Spring Boot application that uses WebSocket and STOMP to exchange JSON messages between a browser client and a server, covering project setup, dependencies, Java POJOs, controller logic, WebSocket configuration, client‑side JavaScript, and how to build and run the executable JAR.
This article dissects the processing flow of Spring Boot's @EnableAutoConfiguration annotation, revealing how AutoConfigurationImportSelector and DeferredImportSelector collaborate to load, filter, and order auto‑configuration classes based on metadata, conditions, and explicit exclusions.
This article evaluates popular Java microservice frameworks—Spring Boot, Micronaut, Quarkus, and Helidon MP—by measuring their ease of development, compilation time, startup latency, memory usage, and high‑load request handling, using identical CRUD applications deployed on Docker and GraalVM.
This tutorial shows how to integrate the FastDFS distributed file system into a Spring Boot application, covering Maven dependencies, configuration files, utility classes, core client initialization, and controller code for uploading, downloading, retrieving, and deleting files, with complete code examples and a GitHub source link.
Spring Boot Admin 2.2.4 introduces a series of bug fixes and adds compatibility with Spring Boot 2.3.x, providing updated Maven dependencies, a detailed improvement list, and links to the GitHub repository for developers to upgrade their monitoring dashboards efficiently.
The article details a step‑by‑step forensic analysis of why a Spring Boot application migrated to the MDP framework consumed far more physical memory than its configured 4 GB heap, uncovering off‑heap allocations caused by native code, package‑scanning, and glibc memory‑pool behavior, and explains how limiting scan paths or upgrading Spring Boot resolves the issue.
This tutorial walks you through building a complete SMS‑based captcha authentication flow in Spring Security, covering cache lifecycle, service implementation, custom authentication token, provider, filter, and configuration, and shows how to integrate it without affecting existing login methods.
This article explains Spring Boot's auto‑configuration mechanism, detailing the roles of starters, spring.factories, @EnableAutoConfiguration, related annotations, and the AutoConfigurationImportSelector, while showing source code examples and how to customize or disable specific auto‑configurations.
Spring Boot 2.3.2, now available via repo.spring.io and Maven Central, introduces 88 bug fixes, enhanced health monitoring, configurable Docker image builds, reactive Elasticsearch checks, and resolves critical issues like reactor‑netty file descriptor limits and Redis Cluster health checks, urging users of 2.3.1 or 2.2.8 to upgrade.
This article explains the core principles of Spring Boot’s auto‑configuration mechanism, details the roles of @EnableAutoConfiguration, spring.factories, AutoConfiguration classes and related annotations, and demonstrates how to customize or disable auto‑configuration with code examples.
This article explains how to prevent duplicate form submissions in a single‑node Java Spring Boot application by first simulating the user scenario, then showing front‑end button disabling, and finally presenting five back‑end idempotency implementations ranging from a simple HashMap to a reusable LRUMap‑based utility.
This guide demonstrates how to integrate the lightweight Apache Shiro security framework into a Spring Boot application, covering environment setup, Maven dependencies, Redis-backed session and cache configuration, utility classes, core Shiro components, annotation‑based permission control, and Postman testing for token handling and dynamic permission updates.
This article explores practical methods to prevent duplicate submissions in Java applications, starting with a simple front‑end button disabling technique and progressing through several backend strategies—including HashMap, fixed‑size array, double‑checked locking, and Apache Commons LRUMap—complete with code samples and performance considerations.
This article introduces Spring Cloud Gateway, explains its core concepts such as routes, predicates, and filters, demonstrates how to quickly set up a gateway with both Java‑based and configuration‑based routing, and shows how to create custom global and route‑specific filters for advanced request handling.
The article argues that, unless required for legacy projects, learning JSP is unnecessary today because modern frontend frameworks, Spring's shift away from JSP, and microservice architectures all render JSP obsolete for contemporary Java web development.
This tutorial explains how to configure EhCache for distributed caching in a Spring Boot application, covering serialization, XML cluster settings, deployment parameters, REST endpoints for testing, and strategies to keep cache data consistent across multiple JVM instances.
This article introduces SpringFox 3.0.0, highlights its new features such as Spring 5 WebFlux support, OpenAPI 3 compatibility, and zero‑configuration starter, then provides a step‑by‑step guide with Maven dependencies, annotations, controller examples, and notes on updated Swagger UI endpoints.
This article explains how Spring Boot uses Tomcat by default, shows how to replace it with Undertow, and presents benchmark results that demonstrate Undertow's superior throughput and lower memory consumption for high‑concurrency Java web applications.
This article explains how Spring Boot automatically detects cache providers, shows how to replace the default ConcurrentHashMap with EhCache by adding the dependency, configuring ehcache.xml, and verifying the CacheManager type through unit tests, providing complete code examples and step‑by‑step instructions.
This guide explains the background of object storage services, shows SDK upload examples for Alibaba Cloud, Huawei Cloud, and Qiniu, introduces the Amazon S3 protocol as a universal solution, lists compatible Chinese cloud providers, and demonstrates how to configure and use a Spring Boot OSS starter—including support for self‑hosted MinIO—by setting appropriate parameters and invoking OssTemplate.
This article explains how Spring Boot 2.3 provides built‑in graceful shutdown for embedded web servers, how to enable it with configuration, the role of the Shutdown enum and timeout settings, and additional techniques such as Actuator endpoints and signal handling to ensure safe application termination.
This tutorial explains why caching is essential for growing Spring Boot applications, walks through adding Spring's annotation‑based cache support to an existing Spring Data JPA project, and details the key cache annotations, configuration steps, and observable performance improvements.
This article presents sixteen practical Spring Boot best‑practice recommendations—from using custom BOMs and auto‑configuration to structuring code, handling concurrency, externalizing configuration, and testing—aimed at building clean, maintainable, and production‑ready Java microservices.
This article explains how to replace Spring Boot's default embedded Tomcat with Undertow, compares their architectures, presents benchmark results showing Undertow's superior throughput and lower memory usage, and concludes that Undertow is the better choice for high‑concurrency Java web applications.
This article walks through creating a robust email‑sending system using Spring Boot and RabbitMQ, covering message confirmation, consumer idempotency, retry mechanisms, scheduled re‑delivery, and detailed code examples to ensure reliable delivery even under failure conditions.
This article explains what database transactions are, demonstrates how to use Spring Boot’s @Transactional annotation with unit tests, and dives into transaction isolation levels and propagation behaviors, providing code examples and guidance for effective transaction management in Java backend applications.
This guide lists the Apache Tomcat versions vulnerable to CVE-2020-11996, shows which Spring Cloud and Spring Boot releases are affected, and provides step‑by‑step upgrade instructions to secure your applications against the HTTP/2 denial‑of‑service attack.
The article introduces kk-anti-reptile, a Spring Boot‑based anti‑crawler component that uses servlet filters, Redis, and configurable rule chains (IP and User‑Agent), explains its workflow, shows Maven and property configurations, and provides front‑end Axios interception code for handling 509 responses.
This guide explains why Docker images become large, identifies the three main factors—base image size, Dockerfile layer count, and application JAR size—and demonstrates how to use Spring Boot's layered packaging and Dockerfile tricks to reduce image size from megabytes to a few kilobytes.
This guide explains monolithic and microservice architectures, compares their advantages and drawbacks, outlines suitable scenarios, and reviews popular Java backend frameworks and versioning strategies to help developers choose the right approach for scalable applications.
This guide walks through adding Spring Boot i18n support, covering Maven dependencies, project structure, locale resolver and interceptor configuration, message file setup, a utility class, and a sample controller that returns localized responses based on a language query parameter.
After migrating a project to the MDP framework based on Spring Boot, the author observed excessive swap usage and physical memory consumption of 7 GB despite a 4 GB heap limit, and through a series of JVM, system, and native‑code diagnostics identified Spring Boot’s ZipInflaterInputStream native‑memory leak caused by unchecked package scanning.
The article recounts the author's evolution from avoiding source code to actively reading JDK, Spring, MyBatis, Shiro and Quartz implementations, explains why reading code matters for interviews and personal growth, and shares practical methods—including official docs, books, blogs, and IDE breakpoint debugging with concrete Spring Boot‑Quartz examples.
The article details a step‑by‑step investigation of why a Spring Boot service migrated to the MDP framework consumed far more physical memory than its 4 GB heap, revealing native‑code allocations, memory‑pool behavior of glibc and tcmalloc, and how limiting MCC scan paths or upgrading Spring Boot resolves the off‑heap leak.
The article details a step‑by‑step investigation of a Spring Boot application that unexpectedly used 7 GB of physical memory despite a 4 GB heap limit, revealing how native memory allocations, the Inflater class, and glibc memory pools caused off‑heap leaks and how proper configuration and library updates resolved the issue.
Spring Boot’s shift from Maven to Gradle, introduced in version 2.3.0.M1, dramatically cuts build times—from over an hour with Maven to under ten seconds on average with Gradle—by enabling incremental and parallel builds, while still supporting Maven for dependency management.
This article explains how to integrate Spring Boot Actuator for exposing health and metrics endpoints, configure security, disable specific endpoints, and visualize monitoring data using JConsole and Spring Boot Admin, including necessary Maven dependencies and code examples, while also noting a promotional interview‑question PDF resource.
This article demonstrates how to set up Sharding-JDBC in a Spring Boot project, covering project structure, Maven configuration, entity, controller, service, mapper code, database DDL for multiple shards, sharding rules in application.properties, and API testing with Postman.
This article explains how to use RocketMQ for traffic‑shaping in a Spring Boot application, covering its core components, consumer pull configuration, integration via rocketmq‑spring‑boot‑starter, a practical like‑praise use case, a Maven setup, YAML configuration, and advanced topics such as dynamic scaling and batch consumption.
This article explains how to use Spring Initializr and Alibaba's start.aliyun.com to generate Spring Boot projects, covering basic dependency setup, configuration of packagings, Java versions, languages, project types, advanced features like caching and demo code injection, and the underlying startup and generation phases of the framework.
This article explains Java's throw‑catch mechanism, the three core principles of exception handling, and demonstrates how to design a custom exception hierarchy and a Spring Boot @ControllerAdvice‑based global handler to simplify error processing and improve code maintainability.
This article explains a lightweight transactional message solution for microservices that leverages RabbitMQ, MySQL, and Spring Boot to achieve eventual consistency, detailing design principles, compensation mechanisms, table schemas, and deployment considerations for high‑throughput asynchronous processing.
Learn step-by-step how to set up and test multiple data sources in a Spring Boot application using MyBatis, covering property configuration, DataSource beans, mapper scanning, entity definitions, and verification through unit tests with complete code examples and key configuration notes.
This article explains a lightweight, low‑intrusive transactional message solution for microservices using Spring Boot, RabbitMQ, and MySQL, covering design principles, table schemas, transaction synchronization, compensation mechanisms, code implementation, and deployment considerations to achieve eventual consistency without sacrificing performance.
This article explains the concept of reentrant distributed locks and provides two Java implementations—one using ThreadLocal for local counting and another using Redis Hash with Lua scripts—detailing the code, pitfalls, and integration with Spring Boot.
This guide explains step‑by‑step how to set up two separate databases in a Spring Boot application, configure Spring Data JPA for each, create the necessary configuration classes, and verify the setup with a simple integration test.
In Spring Cloud projects, adding @RefreshScope to a custom RabbitMQ ConnectionFactory can clash with @ConditionalOnSingleCandidate, preventing RabbitTemplate from being auto‑wired; this article explains the root cause, demonstrates how to diagnose the issue, and provides a solution to avoid such bean conflicts.
This article explains practical methods for protecting API data exchange—including token usage, timestamp validation, signature generation, duplicate‑submission prevention, and ThreadLocal context—provides implementation details with Spring Boot, Redis, and Java code examples, and discusses related security considerations such as DoS attacks.
This article explains how to design a secure token mechanism with timestamp validation, describes common DoS attack types, and provides practical Spring Boot code examples—including Redis configuration, token generation, interceptor logic, MD5 signing utilities, and ThreadLocal usage—to prevent repeat submissions and protect APIs.
This article introduces Soul 2.2.0’s fully plugin‑based architecture, walks through downloading and running soul‑admin, shows how to build a Spring Boot gateway with required dependencies and configuration, demonstrates hot‑swap plugins for Dubbo, circuit‑breaker and rate limiting, and highlights its key features and typical use cases.
This tutorial walks through adding and initializing multiple Spring Boot data sources for JdbcTemplate, Spring Data JPA, and MyBatis, including property setup, configuration classes, bean definitions, testing code, and repository links for complete examples.
This article explains how to implement adaptive global exception handling in Spring Boot, demonstrates default behavior, walks through key code examples, highlights common pitfalls such as interceptor loops, and offers practical solutions for robust error management in backend services.
This article explains why redoing a system can be simpler than refactoring, then dives into implementing a reentrant distributed lock using Redis with both ThreadLocal and Redis Hash approaches, providing detailed Java code, Lua scripts, and practical tips for handling lock expiration and multi‑process reentrancy.
