This article provides a comprehensive overview of the Caffeine local cache library, covering its fundamentals, configuration options, loading strategies, eviction policies, statistics, and detailed steps for integrating Caffeine with Spring Boot using annotations and custom cache managers.
This guide walks through migrating services from Alibaba Cloud to AWS by containerizing Tomcat and SpringBoot applications with Docker, covering environment checks, Dockerfile creation, image building, container deployment, troubleshooting, and best‑practice summaries for reliable production rollout.
This article demonstrates how to build a real-time equipment monitoring solution by using WebSocket for server‑client communication, a Vue.js front‑end to display device status on a map, and a SpringBoot back‑end that broadcasts abnormal alerts to connected browsers.
This tutorial shows how to build a lightweight request‑tracing solution in SpringBoot 3.2 using SLF4J, MDC, custom filters, logback configuration, and a global ResponseBodyAdvice to log and return trace IDs for improved debugging and observability.
This article explains why upgrading to JDK 17 is essential, outlines the long‑term support, performance gains from modern garbage collectors like ZGC, new language features such as switch expressions and records, and provides detailed migration steps, Maven and Spring Boot configuration, and troubleshooting tips for a smooth transition.
This article presents a concise tutorial on building a flash‑sale (Seckill) system with SpringBoot, MySQL, Redis, RabbitMQ and a basic HTML/JQuery front‑end, covering architecture, key features, code snippets, over‑selling prevention, rate limiting, and deployment screenshots.
This article demonstrates how to build a real‑time equipment monitoring application by using WebSocket for server‑client communication, a Vue.js front‑end to display device status, and a SpringBoot back‑end that broadcasts alerts when abnormal devices are reported.
This article explains how to use Redis BitMap to build an efficient sign‑in feature and monthly statistics in a Spring Boot microservice, covering basic BitMap commands, key design, code implementation, testing procedures, and a cache‑penetration mitigation strategy.
The article walks through a DDD‑inspired four‑layer microservice architecture, explains how an application SDK enables RPC communication across services, details each architectural layer, and showcases the open‑source D3boot framework that bundles reusable base components, BOM management, and SaaS‑ready features for rapid backend development.
This article explains how to design microservice permission control using Apache Shiro, sharing session data via Redis, outlines failed approaches, presents a workable solution with custom cache and session managers, and provides complete code examples for realms, configuration, and login flow.
This article analyzes the overselling problem that occurs during high‑concurrency flash‑sale (seckill) operations and presents seven concrete solutions—including improved lock placement, AOP‑based locking, three types of database locks, optimistic locking, a blocking‑queue approach, and a Disruptor queue—complete with SpringBoot 2.5.7 code samples, performance test results, and practical recommendations.
This article demonstrates how to build a real‑time equipment‑monitoring solution by using WebSocket for server‑to‑client push, with a SpringBoot backend that handles WebSocket connections and a Vue.js front‑end that visualizes device status and updates instantly when an abnormal event is reported.
This article explains how to build a Spring Boot‑based service registry that replicates Nacos' core features—service discovery, health‑checking, and dynamic configuration management—by creating server‑side registration APIs, scheduled heartbeat checks, client registration logic, and database‑backed configuration storage.
This tutorial explains how to build a real‑time fire‑equipment monitoring application where a Vue.js front‑end receives abnormal event notifications via WebSocket from a SpringBoot back‑end that broadcasts device status changes instantly.
This article examines the benefits of moving from JDK 11 to the long‑term support JDK 17, detailing performance gains—especially sub‑millisecond ZGC pause times—new language features, compatibility considerations, benchmark results, and step‑by‑step migration instructions for Spring‑based applications.
This article details the design and implementation of a Java‑based flash‑sale (Seckill) system using SpringBoot, Redis, RabbitMQ, and related technologies, covering architecture, security, caching, asynchronous processing, oversell prevention, and rate‑limiting techniques.
This article introduces the open‑source mall project—a SpringBoot + Vue + uni‑app e‑commerce platform with over 60 K GitHub stars—detailing its payment flow, architecture, tech stack, video tutorial series, and how to join the learning community for hands‑on development experience.
This guide explains how Java applications can send SMS messages efficiently by comparing client‑side SDK integration with a dedicated server‑side SMS platform, covering provider choices, code examples, multi‑channel aggregation with SMS4J, and design considerations for high‑availability messaging.
This article walks through the design and implementation of a Java SpringBoot‑based electronic signature and seal system, covering the underlying concepts of digital signatures, the complete project structure, key controller and service code, utility classes, deployment steps, and a step‑by‑step functional demo with screenshots.
This article introduces TLog, a zero‑intrusion Java logging library that adds globally unique trace IDs, SpanId and upstream/downstream tags to microservice logs, outlines its key features, multiple integration modes, configuration examples for Log4j and async logging, and shows how to use it with Spring Boot, Spring Native and task frameworks like XXL‑JOB.
The article walks through diagnosing a 10‑second backend loading delay, explains connection‑pool concepts, introduces Alibaba's Druid pool with its monitoring UI, shows how to identify and optimize slow SQL queries using DISTINCT and indexes, and provides step‑by‑step SpringBoot integration instructions.
Learn how to implement both simple parameter checks and complex business rule validations in SpringBoot by leveraging Bean Validation, creating custom annotations like @UniqueUser and @NotConflictUser, and integrating them seamlessly into controllers to ensure data integrity and reduce boilerplate logic.
This article explores how many concurrent requests a SpringBoot application can process with default settings, demonstrating a hands‑on demo, analyzing Tomcat’s thread‑pool defaults, comparing Undertow behavior, and revealing how configuration parameters like core threads, max threads, queue size, and connection limits affect throughput.
This article examines the pitfalls of using SpringBoot's @ControllerAdvice and @ExceptionHandler for global exception handling, illustrates common issues across controller, service, and data layers, and proposes more precise logging and debugging strategies to improve error traceability and maintainability.
The article explains why multiple independent systems hurt user experience, reviews traditional session and cookie based authentication, discusses session sharing problems in clustered environments, and presents centralized Redis storage and CAS‑based single sign‑on solutions with code examples and a comparison to OAuth2.
This article explains SpringBoot’s auto‑configuration mechanism, walks through the DispatcherServlet example, and demonstrates how to build a custom logging starter—including annotation, properties class, AOP aspect, auto‑configuration class, Maven packaging, and usage—showcasing the efficiency and reusability benefits for backend developers.
This guide shows how to free up hundreds of gigabytes on a Windows PC by locating and deleting large JetBrains IDE directories, customizing IDE configuration and cache paths, and also introduces the popular open‑source SpringBoot‑based e‑commerce project “mall” for further learning.
This article demonstrates how to invoke external services from a Spring Boot application by using raw HttpClient, the RestTemplate utility, and Feign client, providing complete code examples, configuration steps, and tips for handling headers and tokens.
This guide introduces Spring WebClient, a reactive, non‑blocking HTTP client for Spring Boot, compares it with RestTemplate, explains configuration options, demonstrates usage patterns, error handling, memory limits, Reactor Netty customization, request bodies, form data, and filter registration, providing practical code examples throughout.
This article investigates why a SpringBoot service takes 6‑7 minutes to start, identifies the bean‑scanning and bean‑initialization phases as the main performance culprits, and presents concrete JavaConfig and starter‑based solutions to reduce startup time to around 40 seconds while handling cache auto‑configuration pitfalls.
This article introduces DynamicTp, a Java framework that extends ThreadPoolExecutor with dynamic configuration, real‑time monitoring, and alerting, enabling developers to adjust thread‑pool parameters on the fly, integrate with popular configuration centers, and achieve high‑availability and scalability in microservice environments.
This article details a practical approach to handling massive billing data by dynamically creating monthly tables in MySQL via stored procedures, integrating them with a SpringBoot‑MyBatis backend, and providing APIs for insertion, serial‑number lookup, and time‑range queries, complete with code examples and operational tips.
This article introduces a simplified Seckill (flash‑sale) system built with SpringBoot, detailing its overall architecture, key backend techniques such as distributed sessions, Redis caching, RabbitMQ asynchronous ordering, security measures, oversell prevention, rate limiting, and provides essential code snippets and deployment screenshots.
Learn how to install and configure PowerJob, a next‑generation distributed scheduling and computation framework, by setting up MySQL and MongoDB, deploying the server and worker via Docker, adding Maven dependencies, defining processors, and managing tasks through its web UI for reliable microservice job orchestration.
This article details the design and implementation of a Java-based Seckill (flash‑sale) platform built with SpringBoot, MySQL, Redis, RabbitMQ, and front‑end technologies, covering password hashing, distributed sessions, caching strategies, asynchronous order processing, oversell prevention, rate limiting, and provides code snippets and deployment screenshots.
This article provides a comprehensive guide to Caffeine, a high‑performance Java local cache library, covering its fundamentals, loading strategies, eviction policies, refresh mechanisms, statistics, and step‑by‑step integration with Spring Boot using annotations such as @Cacheable and configuration examples.
The article explains how concurrent database updates can cause Redis cache inconsistency, introduces the delayed double‑delete solution, details each step of the algorithm, provides full Spring Boot AOP implementation code, demonstrates verification with test cases, and shares the complete project repository.
This article explores how SpringBoot 2.6.12 injects HttpServletRequest into controllers using JDK dynamic proxies and ThreadLocal, detailing the underlying ObjectFactoryDelegatingInvocationHandler, RequestObjectFactory, RequestContextHolder, and DispatcherServlet processing flow with code examples and explains why injecting HttpServletRequest and HttpServletResponse in a controller is safe.
This article walks through the complete shopping‑cart‑to‑order workflow of the open‑source Mall project—built with SpringBoot, Vue and uni‑app—detailing database schema, cart promotion logic, confirm‑order generation, order creation, cancellation, and payment‑success callbacks, while highlighting key design considerations and code references.
This article explains how to merge multiple backend requests in a SpringBoot application using a blocking queue, ScheduledThreadPoolExecutor, and CompletableFuture to batch database queries, reduce connection overhead, handle high concurrency, and includes full Java code examples and performance testing.
This tutorial walks through RabbitMQ fundamentals, installation on macOS, core AMQP concepts, common exchange types, and step‑by‑step SpringBoot integration with code samples, while highlighting practical issues like connection leaks and the need for a connection pool.
This article introduces the 12306 railway ticket system project, detailing its purpose for student learning, two deployment versions, extensive backend architecture, technology stack, code repository structure, design challenges, and resources to help learners master high‑concurrency distributed systems.
This article presents a hands‑on walkthrough of implementing in‑database horizontal partitioning by month for a high‑volume billing table, covering the business background, design decisions, stored‑procedure table creation, dynamic table selection in MyBatis, and query strategies such as serial‑number lookup and date‑range retrieval.
This article compiles a set of practical SpringBoot techniques, including Flyway-based SQL version control, JetCache declarative caching, Netty WebSocket service customization, jasypt configuration encryption, ShardingSphere data masking, Jackson response desensitization, read‑write splitting, idempotent request handling, MockMvc testing, and Prometheus‑Grafana monitoring.
This article documents a comprehensive migration from JDK 8 to JDK 17, detailing new language and JVM features, step‑by‑step upgrade procedures, Maven and SpringBoot version changes, performance benchmarking, and ZGC‑based garbage‑collection tuning to dramatically reduce pause times.
This article investigates why a Spring Boot application using JedisPool experiences high connection‑acquisition latency, analyzes the Evictor logic and mis‑configured pool parameters, and presents a custom configuration solution that stabilizes the pool and eliminates repeated connection creation and destruction.
This article explains why public APIs need protection, outlines anti‑tampering and anti‑replay strategies using timestamps and nonces, and provides complete SpringBoot code—including request signing, filter implementation, and Redis utilities—to safeguard API calls from manipulation and replay attacks.
This article walks through a step‑by‑step refactoring of repetitive Java code, illustrating how to extract common methods, use reflection, apply generics with lambda expressions, leverage inheritance and the template method pattern, and finally combine factory, template, and strategy patterns into a clean, reusable solution.
This comprehensive guide explains the purpose and usage of Spring MVC, Bean, Dependency Injection, container‑configuration, and Spring Boot annotations, providing clear examples and code snippets that help Java developers master annotation‑driven configuration for backend applications.
This guide explains how to use Spring 6.1's new RestClient for synchronous HTTP calls, covering setup, request building, response handling, data conversion, error processing, and advanced exchange methods with full code examples.
This article documents a comprehensive upgrade from JDK 8 to JDK 17, detailing new language and JVM features, evaluation criteria for selecting services, step‑by‑step migration of Maven settings, dependencies, SpringBoot and middleware, performance testing results, and ZGC‑focused garbage‑collector tuning.
This article explains how to use Redis BitMap to build an efficient sign‑in feature and continuous‑sign‑in statistics in a Spring Boot microservice, covering basic BitMap commands, integration steps, core source code, and a cache‑penetration solution using BitMap hashing.
This article introduces a Spring‑Boot library that uses a single annotation to enable WebSocket (and other long‑connection) load balancing across multiple microservice instances, explains its abstract connection model, shows how to configure and use it with code examples, and describes the underlying connection management, selector, and message routing mechanisms.
This article introduces 35 high‑quality open‑source SpringBoot and SpringCloud projects, ranging from development scaffolds and admin systems to e‑commerce, HR, payment, seckill, blog, and ERP solutions, each with brief feature descriptions, technology stacks, and repository links for developers seeking ready‑made frameworks.
This article explains how to replace the default Tomcat container in Spring Boot with Undertow, provides step‑by‑step configuration instructions, and presents benchmark results that show Undertow's superior throughput and lower memory usage under high‑concurrency workloads.
This article introduces Spring Framework 6's new HTTP Interface feature, walks through creating a simple Spring Boot service, defining a Java interface for HTTP calls, testing it with WebClient and HttpServiceProxyFactory, and explains related annotations and dependencies.
This article explains why asynchronous methods improve response speed in SpringBoot, demonstrates how to enable @Async, implement service and controller code, configure custom thread pools, handle exceptions, and retrieve results, showing measurable performance gains through non‑blocking execution.
This article explores the interview question of how many concurrent requests a SpringBoot project can process by building a minimal demo, measuring Tomcat and Undertow thread pool limits, analyzing default configurations, and showing how container settings and annotations like @Async affect the actual request capacity.
This article explains how to invoke external services from a Spring Boot application using three approaches—raw HttpClient, Spring's RestTemplate, and Feign—providing detailed code examples, configuration steps, and tips for handling headers and tokens.
This article explains various approaches to implementing an audit feature in a SpringBoot application, compares their pros and cons, provides detailed SQL schema, Java backend controller code, and Vue frontend integration, and includes complete code snippets for database tables, file handling, and UI components.
This article explains how small web projects can avoid heavyweight message middleware by using CDC technology, specifically Debezium, to monitor MySQL binlog changes, outlines why Debezium outperforms alternatives like Canal, and provides step‑by‑step Spring Boot integration with configuration, code samples, and practical use‑case scenarios.
This article introduces LiteFlow, a lightweight yet powerful Java flow engine that enables developers to define complex business logic through concise rule files, demonstrates its key features, IDE plugin support, various orchestration expressions, and provides step‑by‑step integration examples with SpringBoot, code snippets, and a real‑world order‑price calculation use case.
This article explains how to enhance SpringBoot's native @Scheduled tasks with the spring-boot-starter-super-scheduled library, allowing dynamic creation, modification, and cancellation of scheduled jobs at runtime without altering existing annotations, and details the underlying implementation using BeanPostProcessor, CGLIB proxies, and a custom task manager.
This article explains how to design and implement a unified exception handling framework in Spring Boot applications, covering background, the use of @ControllerAdvice and @ExceptionHandler, custom assertion utilities, error response structures, handling of various exception types, and practical validation examples with code snippets.
A Java developer added fastjson to a SkyWalking agent for JSON conversion, causing class‑loading conflicts in a SpringBoot 2 application; the article analyzes the root cause, demonstrates debugging steps, explains the parent‑delegation mechanism, and presents solutions using Maven shade relocation or switching to Gson, with practical lessons for avoiding similar issues.
This article demonstrates three methods for invoking external services in Spring Boot applications—using raw HttpClient, the RestTemplate utility, and Feign clients—providing code examples, configuration steps, and usage details for each approach in production.
This article explains the COLA (Clean Object‑Oriented and Layered Architecture) framework, its layered structure, component breakdown, and practical implementation details with SpringBoot, including code examples, module organization, and design principles for building maintainable backend systems.
This article explains four design patterns for implementing an audit workflow, compares their advantages and disadvantages, and provides complete SpringBoot backend, MySQL table definitions, and Vue front‑end code to build a functional audit system with file upload support.
This article analyzes how adding Fastjson to a SpringBoot agent causes classloader conflicts that prevent GenericHttpMessageConverter from loading, explains the underlying parent‑delegation mechanism, and presents solutions such as using Maven Shade to rename packages or switching to a lightweight JSON library like Gson.
This guide explains how to use the open‑source Java diagnostic tool Arthas to attach to a running Spring Boot application, view real‑time metrics, and trace method execution in order to pinpoint and optimize performance‑critical code sections without modifying the source.
This guide explains how to customize the serialization and deserialization of Date objects in SpringBoot by adjusting application.yml/properties, using @JsonFormat, @DateTimeFormat, and @Temporal annotations, and by creating global converters for both form submissions and JSON payloads, ensuring consistent timezone handling.
This article walks through an interview question about the maximum concurrent requests a SpringBoot project can handle, builds a minimal demo, measures Tomcat and Undertow thread‑pool limits, explains the underlying thread‑pool mechanics, and offers practical tips for answering such questions in interviews.
Discover how magic‑api, a Java‑based rapid API framework, streamlines backend development by eliminating boilerplate code, enabling visual API design, dynamic configuration, and seamless database integration, all demonstrated through a step‑by‑step tutorial using a SpringBoot e‑commerce project.
This article provides a comprehensive introduction to OAuth 2.0, its core concepts, advantages and disadvantages, details four authorization flows, and presents step‑by‑step Java Spring Boot implementations for GitHub, QQ, and WeChat third‑party login, including database design considerations and code examples.
This article explains how Nginx can be used to achieve various load‑balancing strategies—including round‑robin, least‑connections, IP hash, generic hash, least‑time, and random—provides detailed configuration examples, shows how to integrate Nginx with SpringBoot services, and outlines testing and deployment steps.
This article explains why API idempotency is crucial in real‑world systems, outlines which operations need it, discusses the trade‑offs of adding idempotency, and presents four practical implementation patterns—including unique primary keys, optimistic locking, anti‑duplicate tokens, and downstream sequence numbers—complete with SpringBoot code examples.
This article demonstrates how to simulate a high‑concurrency flash‑sale scenario using SpringBoot, MySQL and JMeter, analyzes why naive lock‑and‑transaction code causes overselling, and presents six refined solutions—including controller‑level locking, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches—along with performance test results.
This article introduces the OpenAI Java SDK, provides code examples for edit operations and Claude AI completions, and shows how to configure the SDK in a Maven project while also recommending related SpringBoot tools.
This article analyzes the common overselling problem in high‑traffic flash‑sale systems and presents seven concrete solutions—including improved locking, AOP locking, pessimistic and optimistic locks, as well as blocking‑queue and Disruptor‑based designs—complete with SpringBoot code samples and performance testing results.
This article provides an in‑depth tutorial on the Caffeine local cache library for Java, covering its fundamentals, loading strategies, eviction policies, refresh mechanisms, statistics, and step‑by‑step integration with Spring Boot, including configuration, annotations, and practical code examples.
This article explains the benefits and common practices of plugin‑based development in Java, covering module decoupling, extensibility, third‑party integration, and detailed implementations using Java SPI, custom configuration loading, and Spring Boot's spring.factories mechanism with practical code examples.
This article shares a hands‑on journey of solving cross‑origin issues in a multi‑domain education product, covering CORS fundamentals, simple and preflight requests, Nginx and SpringBoot configurations, response‑code choices, and Chrome’s insecure private‑network restrictions, with practical solutions and lessons learned.
This article walks through four audit implementation strategies, provides the SQL schema and Java SpringBoot controller for an audit feature, shows how to integrate it with a Vue front‑end including file upload handling, and offers complete code snippets for both back‑end and front‑end components.
This guide walks through building a SpringBoot architecture that updates MySQL first, deletes Redis cache asynchronously via Canal and RabbitMQ, resolves common Canal meta‑data mismatches, and configures manual RabbitMQ acknowledgments to guarantee reliable cache invalidation.
This article explains how MyBatis first‑level (session) and second‑level (cross‑session) caches work, the conditions required for them to function, common pitfalls when integrating with SpringBoot, and step‑by‑step instructions to enable and safely use second‑level caching in real projects.
This article walks through the design and implementation of the order module in the Mall project, covering both backend administration and frontend shopping flow, database schema, API design, and available video tutorials for a comprehensive e‑commerce solution.
This guide walks you through setting up kkFileView—a SpringBoot‑based file preview tool—on Windows or Linux (Docker), configuring it to work with MinIO, and using it to preview a wide range of document, image, video, and archive formats via simple base64‑encoded URLs.
This article walks through the Mall project's product module—covering its architecture, feature design, database schema, and API implementation—while providing links to source code, video tutorials, and a mind‑map that together serve as a comprehensive guide for building robust e‑commerce systems.
This article explains the concept of plugin‑based development, outlines its benefits such as decoupling and extensibility, and provides step‑by‑step Java implementations using ServiceLoader, custom configuration files, and Spring Boot's spring.factories mechanism, complete with runnable code examples.
This article analyzes why Redis's increment operation returns null when used inside a Spring @Transactional method with transaction support enabled, details the debugging steps, experiments, and presents two practical solutions to prevent the issue.
This article demonstrates how to achieve zero‑downtime releases for SpringBoot applications on Kubernetes by configuring readiness/liveness probes, rolling update strategies, graceful shutdown hooks, horizontal pod autoscaling, Prometheus monitoring, and externalized configuration via ConfigMaps.
This article explains how to replace SpringBoot's default embedded Tomcat with Undertow, details the configuration steps, compares their performance and memory usage through benchmark results, and argues that Undertow offers superior throughput for high‑concurrency Java web applications.
This article explains how to replace SpringBoot's default embedded Tomcat with the high‑performance Undertow container, compares their architectures, presents benchmark results on QPS and memory usage, and shows why Undertow is the better choice for high‑concurrency Java web applications.
This guide walks newcomers through taking over a brand‑new Java mall project, covering the full development workflow, selecting a modern backend tech stack, building the framework step‑by‑step, and accessing a comprehensive video tutorial series for hands‑on learning.
The article explains how to extend Java's ThreadPoolExecutor by dynamically increasing or decreasing corePoolSize according to the task queue length, using setCorePoolSize, a daemon monitoring thread, and scheduled tasks to improve asynchronous processing performance in Spring Boot applications.
This article explains how to invoke external APIs in a SpringBoot application using three approaches—raw HttpClient, RestTemplate, and Feign—detailing configuration, code examples for GET and POST requests, token handling, and header interception.
This article explains how to reduce the size of SpringBoot executable JAR files by separating application classes from dependency libraries, configuring the Maven build to use a ZIP layout, and deploying the slimmed package with a custom loader path, thereby speeding up uploads and updates.
This tutorial walks you through a complete one‑click Jenkins, Docker, and SpringBoot automated deployment on CentOS, covering environment preparation, Docker and Jenkins installation, plugin configuration, job creation, build testing, and running the packaged application in a Docker container.
This article compiles a series of practical SpringBoot implementations—including AES encryption with Vue, a Netty‑based TCP client that parses hex data into MySQL, multiple Redis integration patterns, strategy‑factory designs, custom annotations for rate limiting, global exception handling, and scheduled tasks—each linked to detailed examples.
This article explores Java's exception hierarchy, demonstrates proper use of try‑catch‑finally and return statements, shows how to define custom system, business, and third‑party exceptions, implements global handling with @RestControllerAdvice, and discusses monitoring and alerting strategies for robust backend development.
