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.
Learn how to package a Spring Boot application into a Docker image using three Maven plugins—spring-boot-maven-plugin's build-image, Google's jib-maven-plugin, and the dockerfile-maven-plugin—complete with setup steps, command examples, and tips for container testing.
This article explains the inner workings of Spring Boot’s @SpringBootApplication annotation, the loading of auto‑configuration classes from META‑INF/spring.factories, the refresh of the application context, the creation of the embedded Tomcat server, and demonstrates how to create a custom starter with configuration properties.
The article walks through creating a test management platform using Spring Boot, mockJS, and custom MyBatis TypeHandlers to store public data as JSON arrays, detailing the data model, handler implementations, and full mapper XML configuration for CRUD operations.
This article explains how to integrate the Quartz scheduler into a Spring Boot application to create, update, delete, pause, and resume dynamic scheduled jobs without restarting the service, covering Quartz fundamentals, storage options, configuration steps, job implementation, and deployment considerations.
Spring Boot’s 2.3.0 release marked a major shift from Maven to Gradle, driven by the need to reduce build times, leverage incremental and parallel builds, and improve CI efficiency, resulting in average build times dropping from over an hour to just over nine minutes.
This guide walks through installing the RabbitMQ delayed‑message‑exchange plugin, configuring it in a Spring Boot application, and building Java components to send and receive delayed order‑cancellation messages, comparing the plugin approach with dead‑letter queues and providing complete code snippets and deployment steps.
Spring Boot parses @SpringBootApplication by combining @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan, then processes @Import, @Conditional, and bean post‑processors, uses SpringFactoriesLoader for auto‑configuration, and follows an eight‑step configuration‑class parsing flow to register beans during startup.
This article demonstrates how to set up a Redis cluster, connect it with Spring Boot 2.3 using Lettuce, simulate a node failure, and configure Spring Boot's adaptive topology refresh to achieve automatic failover without application downtime.
This article explains how to integrate RocketMQ with Spring Boot to implement peak‑shaving, detailing core components, consumer pull parameters, one‑way sending, batch consumption configuration, and practical performance testing with code examples and deployment tips.
This article provides a comprehensive tutorial on how to integrate Dataway—a DataQL‑based API configuration tool—into a Spring Boot project, covering dependency setup, configuration properties, datasource wiring, Hasor module creation, enabling Hasor, and using the Dataway UI to create and publish APIs without writing any Java code.
This article explains how to enable and use Spring Boot's graceful shutdown feature in version 2.3, including configuration of the embedded web server and Actuator, and also provides a custom solution for older Spring Boot releases to achieve smooth termination of ongoing requests.
This article explains why graceful shutdown is essential for Spring Boot and Spring Cloud applications, outlines key precautions, shows how Spring Boot 2.3 adds built‑in support, and provides configuration steps, code examples, and container‑specific behaviors to ensure clean service termination.
Through a 30‑minute Apache JMeter load test on the Spring Boot Petclinic sample, we captured heap dumps and used HeapHero to reveal that 65% of memory is wasted due to string duplication, inefficient collections, and poor initialization, offering concrete code‑level recommendations to improve memory efficiency.
After moving a project to Spring Boot, the system reported unusually high swap usage despite a 4 GB heap, prompting a detailed investigation using JVM native‑memory tracking, pmap, gperftools, strace, and GDB, which ultimately identified Spring Boot’s JAR scanning and glibc memory arenas as the root causes and led to a configuration fix and an upgrade to resolve the off‑heap memory leak.
This article explains how MyBatis-Plus adds data-security protection to Spring Boot applications by encrypting datasource and property file values, details the custom EnvironmentPostProcessor implementation, loading mechanisms, and offers extension ideas and alternatives such as jasypt-spring-boot-starter.
This article explains the purpose, differences, default settings, and practical verification of MyBatis first‑level and second‑level caches in Spring Boot, showing how cache scope, transaction boundaries, and mapper configuration affect cache behavior and performance.
This article explains how Spring Boot 2.3 implements graceful shutdown, showing configuration properties, code examples, container-specific behaviors, and how to trigger shutdown via the actuator endpoint, while also noting differences among Tomcat, Reactor Netty, and Undertow.
This tutorial walks through building a Spring Boot application that uses Alibaba's Dubbo framework, covering the RPC workflow, project structure, Maven dependencies, Spring Boot and XML configurations, service interface definition, provider and consumer implementations, and a RESTful endpoint for testing.
This article details a lightweight transactional message solution for microservices that stores pending messages in a local MySQL table, defers RabbitMQ publishing until after transaction commit, and includes compensation logic with exponential back‑off to ensure reliable asynchronous communication.
This article explains how RocketMQ’s decoupling, asynchronous and peak‑shaving features can be applied in a Spring Boot project to buffer massive like‑click traffic, reduce database pressure, and dynamically tune consumer pull parameters for optimal throughput.
This article provides a step‑by‑step guide to using Google's open‑source gRPC framework in Java, covering Protocol Buffers service definitions, Maven configuration, Spring Boot server implementation, client creation, and unit testing to demonstrate cross‑language RPC communication.
This article demonstrates how to integrate Redisson with Spring Boot to create Redis‑based distributed locks, covering Maven dependencies, YAML configuration, a Redisson configuration class, utility methods for locking and unlocking, and a sample controller that simulates concurrent access to verify lock behavior.
This article explains why traditional @ControllerAdvice fails in Spring Cloud Gateway, introduces the built‑in ExceptionHandlingWebHandler and DefaultErrorWebExceptionHandler, and shows how to override them with a custom GlobalExceptionConfiguration for robust reactive error handling.
This guide explains how to reduce Docker image size by separating Spring Boot application classes from third‑party libraries into distinct layers, using the Maven plugin and layertools, resulting in rebuilds that change only a few kilobytes instead of megabytes.
This article explains common API security mechanisms such as token, timestamp, signature, and anti‑replay techniques, demonstrates how to prevent duplicate submissions, and provides complete Java Spring Boot code examples including interceptors, Redis configuration, and utility classes for secure API design.
Spring Boot 2.3 introduces major core component upgrades—including Spring Data Neumann, Spring HATEOAS 1.1, and Spring Security 5.3—adds Java 14 compatibility while retaining Java 8/11 support, enhances Docker integration with Cloud Native Buildpacks and layered jars, and provides graceful shutdown and health‑probe features for improved application reliability.
This article lists the Maven dependencies for Spring Boot Admin 2.2.3 and outlines the upgrade changes, including Spring Boot 2.2.7, Spring Cloud Hoxton.SR4, Portuguese language support, customizable pages, language set extensions, InstanceEvents deserialization improvements, and fixes for custom CSS/JS loading issues.
Discover Mica, a lightweight Java microservice core built on Spring Boot and Spring Cloud, its dependencies, versioning scheme, ip2region integration, configuration tips, and usage examples, providing a streamlined foundation for cloud-native applications.
This tutorial walks through integrating Dataway into a Spring Boot project, covering dependency setup, Dataway configuration, database table creation, data source integration, Hasor module registration, enabling Hasor, running the application, accessing the UI, and creating APIs using SQL or DataQL, all without writing custom code.
This tutorial walks through installing the EasyCode and Lombok plugins, creating a MySQL table, configuring IDEA database connections, generating entity, DAO, service, controller, and mapper code for a Spring Boot project, and setting up the required Maven dependencies and application.yml configuration.
