This article explains the Spring AOP advice lifecycle, distinguishes shared and per‑instance advice beans, and details each advice type—around, before, throws, after‑returning, and introduction—along with practical Java code snippets for implementation.
This article explains how to replace tightly‑coupled if‑else or switch‑case logic for selecting file parsers (JSON, CSV, XML) with a Service Locator Pattern using Spring's ServiceLocatorFactoryBean, demonstrating a clean, extensible solution that follows the Open/Closed principle.
This article explains how to enable @AspectJ support in Spring (both via annotations and XML), defines custom AspectJ pointcuts and advice, and dives into Spring AOP APIs such as Pointcut, ClassFilter, MethodMatcher, and utility classes for composing pointcuts.
This article comprehensively reviews the various techniques for injecting beans into the Spring container—including XML and properties configuration files, annotation-based declarations, manual BeanDefinition registration, direct singleton registration, and FactoryBean usage—providing code examples, underlying principles, and practical guidance for each method.
This article explains the Java SPI mechanism, demonstrates how to create service interfaces and implementations, shows how to configure META-INF/services and spring.factories files, and compares Java's built‑in SPI with Spring's optimized SPI approach, providing complete code samples and analysis.
Learn how to use Spring's Application Event mechanism to separate main and sub‑processes in Java applications, covering custom event and listener creation, publishing events, abstract base event design, singleton manager, and a real‑world order‑cancellation SMS notification case.
This article analyzes the limitations of traditional HTTP session mechanisms in single‑server and clustered environments, explains why session sharing is essential for multi‑system products, and presents practical solutions such as session replication and centralized Redis storage, followed by a detailed walkthrough of CAS‑based single sign‑on implementation with Java Spring code examples and a comparison to OAuth2.
This article introduces eight practical techniques for achieving asynchronous processing in Java—including raw threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, Hutool ThreadUtil, and Guava ListenableFuture—complete with code examples and discussion of their advantages and limitations.
This article explains why short-lived JWT tokens need automatic renewal, outlines a Redis‑based solution, and provides complete Spring interceptor and utility code to create, verify, and refresh tokens without forcing users to re‑login frequently.
This article examines why duplicate code harms maintainability, then demonstrates three practical techniques—using factory and template method patterns, leveraging custom annotations with reflection, and applying bean‑copy utilities—to refactor Java business logic and dramatically reduce redundancy.
This article provides an in‑depth overview of Java's ThreadPoolExecutor, covering why thread pools are needed, various creation methods via Executors, core parameters, internal workflow, source‑code analysis, monitoring, shutdown procedures, and real‑world applications such as Spring @Async and Dubbo integration.
This article explains how to let users upload a JAR that implements a predefined Java interface, then dynamically load, register, and switch the implementation at runtime using both reflection‑based and Spring‑annotation‑based hot‑deployment techniques, complete with code examples and utility methods.
This article explains how to design a flexible logging solution in Java by creating a custom @Log annotation, using meta‑annotations such as Retention and Target, and applying Spring AOP with various advice types to capture method parameters, return values, and notes without polluting service code.
This article explains why a custom business rate‑limiting (risk‑control) component is needed for AI‑driven services, compares open‑source solutions, and provides a complete implementation using Redis+Lua scripts, Kotlin code, and Spring AOP annotations, including testing and deployment tips.
This article explains why a business needs its own risk‑control (rate‑limit) component, compares open‑source options, and provides a complete Kotlin/Spring implementation using Redis Lua scripts, annotations, and AOP to enforce real‑time adjustable limits.
The article provides a hands‑on migration guide for moving an internal gateway service from Java 8 to JDK 11 with the G1 garbage collector, detailing a checklist of tool and dependency updates, showcasing up to 105 % performance gains, outlining new language features, virtual‑thread usage, and best‑practice recommendations for a smooth, cost‑effective upgrade.
Learn how to use Spring's RestTemplate and WebClient for calling REST endpoints, explore their core methods, initialization options, URI handling, header and body processing, multipart support, and underlying HttpMessageConverters, with practical code examples and migration guidance for modern Spring applications.
This article explains Spring's TaskExecutor and TaskScheduler abstractions, their various implementations, how they decouple threading and scheduling from the deployment environment, and provides practical code examples for configuring and using them in Java applications.
This article explains the Chain of Responsibility design pattern, demonstrates its use in multi‑step product creation validation and expense‑approval workflows with concrete Java/Spring code, and discusses configuration, dynamic composition, advantages, drawbacks, and testing scenarios.
This article explains the importance of data safety, defines the ACID properties of transactions, details how InnoDB implements them, and shows how Spring's @Transactional annotation works with AOP, including default rollback behavior, configuration options, and common pitfalls that can cause transaction failures.
This article explains how to replace numerous static Feign client interfaces with a single dynamic Feign client in Spring, showing the generic service definition, a client factory, and usage examples that streamline inter‑service HTTP calls while keeping code reusable and maintainable.
This article explains nine widely used design patterns—Singleton, Builder, Factory, Strategy, Template Method, Chain of Responsibility, Proxy, Adapter, and Observer—detailing their concepts, typical use‑cases, and concrete Java code examples drawn from popular open‑source projects such as Spring, Dubbo, MyBatis and Guava.
PowerJob is a third‑generation distributed job scheduler that adds workflow orchestration, map‑reduce style computation and rich execution modes to traditional CRON‑based scheduling, and this guide explains its advantages, core features, architecture, and provides step‑by‑step instructions with code samples to get started quickly.
This guide explains Spring 5.3’s built‑in servlet filters—including FormContentFilter for handling form data in PUT/PATCH/DELETE, ForwardedHeaderFilter for adjusting request URLs behind proxies, ShallowEtagHeaderFilter for lightweight caching, the CORS filter for cross‑origin requests, and CharacterEncodingFilter for enforcing request/response encoding—along with configuration tips and security considerations.
This article shares common pitfalls of Java candidates, emphasizes building a solid Java foundation, and provides a curated collection of over 100 interview questions covering Spring, Redis, MyBatis, and multithreading, with a QR code for accessing the full answer set.
This article explains how Spring's @EnableTransactionManagement activates transaction support by registering advisors and proxy beans, details the core execution flow of transactional methods, explores various propagation scenarios with code examples, and demonstrates forced rollback and transaction synchronization techniques.
This article introduces asynchronous programming concepts in Java, explaining the shift from synchronous to asynchronous execution, and demonstrates practical implementations using raw threads, ThreadPoolExecutor, Future, FutureTask, CompletableFuture, and Spring's @Async annotation, along with event handling and message queue integration for high‑throughput systems.
This article explains how Aspect‑Oriented Programming (AOP) was introduced into a data construction platform to address high development effort, strong business coupling, and maintenance difficulty by isolating cross‑cutting concerns such as logging, thereby improving modularity, development speed, and code maintainability.
This article explains how Spring enables transaction management with @EnableTransactionManagement, details the underlying beans and proxy mechanisms, describes the basic execution flow, explores transaction propagation scenarios, shows how to force rollbacks, and demonstrates using TransactionSynchronization for lifecycle callbacks.
Learn how to integrate Bean Validation with Spring 5.2.23, configure the validator, inject it, create custom constraints, and enable method‑level validation using MethodValidationPostProcessor, with complete code examples and execution results, including handling of constraint violations and bean registration steps.
This guide explains how to implement declarative retry mechanisms in Java using Spring‑Retry and Guava‑Retry, covering dependency setup, template and annotation usage, various retry and back‑off policies, test examples, and a comparative analysis of their flexibility and configuration options.
This article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling strategy that leverages @ControllerAdvice, custom Assert utilities, enum‑based error codes, and standardized response objects to improve code readability, maintainability, and internationalisation.
This article explains Spring's IoC container architecture, bean definition processing, lifecycle methods, and AOP proxy creation, providing detailed code examples and step‑by‑step descriptions of resource loading, bean instantiation, dependency injection, and interceptor chains.
This article analyzes why a Spring service encounters "connection closed" errors during long‑running transactions, explains how MyBatis and Druid manage connections, and provides a programmatic‑transaction solution that splits large operations into smaller units to prevent connection leaks and timeouts.
This article explains how Spring configures its parent and child application contexts using web.xml, ContextLoaderListener, and DispatcherServlet, detailing the loading of configuration files, context class determination, bean definition processing, and the refresh cycle that ultimately stores the WebApplicationContext in the ServletContext.
This article explains the Strategy design pattern, its structure, advantages and drawbacks, and demonstrates a practical Java implementation for payment processing using Spring beans, including interface definitions, concrete payment strategies, and a controller that selects the appropriate strategy at runtime.
This article provides a comprehensive tutorial on Activiti 7, covering workflow concepts, engine configuration files, process engine creation methods, service interfaces, BPMN diagram symbols, deployment techniques, task management, process variables, gateway types, and integration with Spring and Spring Boot.
This article investigates a production issue where Redis increment operations return null each morning, explores hypotheses about Redis pipelines, transactions, and Spring @Transactional interaction, reproduces the bug, analyzes the source code, and proposes two practical solutions to prevent null returns.
This article explains how to use Spring Validation for automatic request parameter checks in Java web applications, covering basic setup, DTO annotations, requestBody and requestParam validation, unified exception handling, and advanced features like group, nested, collection, custom, and fail‑fast validation.
A production microservice failed each morning because Redis's increment operation returned null when generating IDs, and restarting the service temporarily fixed it; the article investigates the root cause—Redis transaction support combined with Spring @Transactional—and presents two concrete remediation strategies.
The article presents comprehensive best‑practice guidelines for building a clean, maintainable Controller layer in Spring MVC, covering its essential responsibilities, common pitfalls, unified response structures, parameter validation with JSR‑303, custom validators, and centralized exception handling to improve code simplicity and robustness.
This post shares a free, extensive compilation of interview questions and detailed explanations covering Java fundamentals, multithreading, Spring framework, Redis, MyBatis and other backend technologies, encouraging systematic preparation and offering a QR‑code method to obtain the full document.
This article walks through the fundamentals of Spring's transaction management, presenting a practical example, detailed execution workflow, and step‑by‑step source‑code analysis—including bean creation, AOP proxy generation, transaction attribute retrieval, transaction start, commit, and rollback – to help developers master Spring transaction internals.
This article explains Spring's @Transactional annotation, detailing its propagation options, rollback mechanisms, common pitfalls such as self‑invocation and non‑public methods, and demonstrates how to correctly invoke transactional methods via proxy objects with practical code examples.
This article compiles over a thousand interview questions and detailed explanations covering core Java fundamentals, multithreading, Spring framework, Redis, MyBatis, and related backend technologies, offering a free downloadable resource to help candidates prepare effectively for major tech company interviews.
This article explains the background of RocketMQ clusters, demonstrates typical Java consumer and producer usage, and introduces the AOP‑based HunterConsumer and HunterProducer components that simplify lifecycle management, configuration, and code reuse for backend developers working with messaging systems.
This article provides a comprehensive overview of Spring Framework utility classes, covering assertion methods, object and collection utilities, string manipulation, file and resource handling, reflection, and AOP helpers, with code examples illustrating their usage for robust backend development.
This roundup covers the latest Java developments, including JEP 434’s move to candidate status, second‑preview updates for virtual threads and structured concurrency, the JDK 20 release schedule, and new releases across Spring, GraalVM, Open Liberty, Vert.x, TomEE, JReleaser, Hibernate, PrimeFaces, JDKMon, and EclipseCon.
This article explains why high‑concurrency big‑data systems need database sharding, describes table‑level partitioning methods (modulus and range), shows how to implement them with MySQL and Java code, compares vertical and horizontal database splitting, and evaluates middleware solutions such as Sharding‑JDBC and Mycat.
This article explains how to build a modular backend service in Java using domain‑driven design, configurable modules, dynamic proxies, cache adapters, lambda‑based query conditions, and Spring‑based conditional bean loading to enable flexible extensions without altering existing code.
This article explains how to improve the Controller layer in Spring applications by separating responsibilities, implementing unified response structures with Result wrappers, handling String response issues via ResponseBodyAdvice, applying parameter validation with JSR‑303, customizing validators, and centralizing exception handling for cleaner, more maintainable backend code.
This article provides a detailed tutorial on using Spring Validation in Spring Boot applications, covering simple and advanced usage such as requestBody and requestParam parameter checks, group validation, nested and collection validation, custom constraints, programmatic validation, fail‑fast mode, and the underlying implementation mechanisms.
This article explains the challenges of multiple product systems, reviews traditional session mechanisms and their limitations in clustered environments, compares session replication and centralized storage using Redis, and details the design and implementation of Single Sign-On using CAS and OAuth2 with Java Spring code examples.
This article investigates whether Spring’s class‑path bean scanning can be made concurrent, walks through source‑code verification, examines relevant GitHub issues and official responses, and finally offers practical tips for speeding up Spring Boot startup.
This article explains MyBatis's first-level (SqlSession-scoped) and second-level (Mapper-scoped) caching mechanisms, their default behaviors, key generation, configuration options, and the impact of Spring integration, and provides recommendations for disabling caches in distributed environments to avoid data inconsistency.
This article introduces Robustdb, a lightweight client‑side read‑write splitting framework built with only a dozen classes, explains its architecture, routing logic, method‑level transaction handling, dynamic data‑source management, and presents performance comparisons with the legacy Atlas proxy.
The article explains how Redis cache expiration can cause a request avalanche that overloads databases, and presents mitigation techniques such as semaphore rate limiting, per‑key locking, fault‑tolerant cache rebuilding, and example Java code using Spring and Redis.
The article demonstrates how to replace fragile if‑else shop‑ranking logic in a Java backend with the Strategy pattern, progressing from simple factories and enums to Spring‑auto‑wired and generic factories, highlighting improved extensibility, reduced coupling, Open‑Closed compliance, and the trade‑off of added abstraction complexity.
This article walks through the complete design and implementation of a high‑performance user login system, covering client‑side verification, server‑side token generation, token expiration strategies, gateway authentication, logout handling, anonymous request allowances, rate‑limited auth tokens, and blacklist management, illustrated with diagrams and Java Spring code examples.
The article explains that when using MapStruct with Lombok, Maven must list Lombok before MapStruct (or define annotationProcessorPaths) so Lombok’s annotation processor runs first, and then demonstrates basic and advanced mapping techniques, Spring integration, and singleton caching strategies.
This article analyzes why a Redis increment operation returns null when executed inside a Spring @Transactional method, explores several hypotheses with experiments, explains the underlying Redis transaction behavior, and proposes two practical solutions to prevent the issue in production environments.
This article provides a detailed walkthrough of Spring and Spring Boot's bean lifecycle, explaining each extension point—from ApplicationContextInitializer to CommandLineRunner—illustrating their usage with code examples and describing practical scenarios for customizing bean creation, initialization, and destruction.
This article explains how to replace repetitive try‑catch blocks in Spring applications with a unified exception handling mechanism based on @ControllerAdvice, custom assertion utilities, and enum‑driven business exceptions, while also showing how to standardize response structures and integrate internationalization.
This article explains how to centralize exception handling in Spring applications using @ControllerAdvice, replace repetitive null‑checks with Assert utilities, and combine enums with custom BusinessException classes to create a clean, maintainable backend error‑handling strategy.
This article explains why cross‑origin issues occur, presents common solutions such as @CrossOrigin, HttpClient and Spring Cloud Gateway, and provides detailed code examples for configuring CORS, building a gateway module, and making HTTP requests in a Java backend project.
This article explains traditional HTTP session handling, the problems of session sharing in clustered and multi‑service environments, and presents practical SSO solutions—including session replication, centralized Redis storage, and a complete CAS‑based single sign‑on implementation with Java code examples.
This article provides a comprehensive tutorial on using Spring annotations for pure annotation‑based development, defining beans, managing bean scopes, performing various injection techniques, reading configuration properties, and integrating Spring with MyBatis, complete with code examples and best‑practice tips.
This guide explains how to upgrade to Alipay’s new transfer interface, alipay.fund.trans.uni.transfer, by updating the SDK, configuring certificates, adding Maven dependencies, and implementing Java Spring beans and utility classes for secure fund transfers.
This article compares Spring's @Autowired and @Resource annotations, explains their injection semantics, outlines practical differences, and dives into the internal implementation classes and processing steps that Spring uses to resolve and inject beans.
This article reveals ten common Spring transaction pitfalls—including private methods, final modifiers, self‑invocation, missing @Service, wrong propagation, non‑transactional databases, swallowed or wrong exceptions, multi‑threaded calls, and nested transaction rollbacks—that can silently disable transaction management in Java backend projects.
This article walks through the eleven most commonly used Spring extension points—including custom interceptors, bean retrieval methods, global exception handling, type converters, import configurations, startup runners, bean definition tweaks, post‑processing, initialization and destruction callbacks, and custom scopes—providing clear explanations and code samples for each.
This article explains six common techniques for adding beans to the Spring IoC container, including @Configuration with @Bean, @Component with @ComponentScan, various @Import approaches, FactoryBean, and BeanDefinitionRegistryPostProcessor, providing code examples and usage details for each method.
Explore the 11 most commonly used Spring extension points—from custom interceptors and bean factories to global exception handling, type converters, import mechanisms, startup runners, bean lifecycle processors, and custom scopes—complete with clear code examples and practical guidance for enhancing Java backend applications.
This article compares JWT and session authentication, explains their differences, outlines the authentication flows, evaluates advantages, disadvantages, security, performance and one‑time use issues, and provides a complete Java implementation with JWT, Redis, interceptor and utility classes.
This article introduces RobustDB, a client‑side read‑write splitting framework that replaces the problematic Atlas proxy by routing SQL statements to master or slave databases based on DML/DQL detection, using Spring, AspectJ, thread‑local context, and dynamic data‑source management.
This article provides a step‑by‑step tutorial on using Spring annotations for bean definition, component scanning, scope management, autowiring, qualifier usage, simple value injection, property file loading, and finally demonstrates how to integrate Spring with MyBatis for streamlined data access in Java backend projects.
This article compiles a large set of interview questions frequently asked by top tech companies, covering Java fundamentals, multithreading, Spring framework, MyBatis, Redis, and related concepts, and provides a free QR‑code link for downloading the complete question set with answers.
This article explains how MyBatis‑Plus maps Mapper interface methods to executable SQL statements, detailing the auto‑configuration of SqlSessionFactory, XML parsing, mapper registration, SQL injection, and the dynamic proxy mechanism used at runtime.
This article explains the complete Spring Bean lifecycle—including IoC fundamentals, bean creation, property injection, initialization callbacks, custom init/destroy methods, and post‑processor hooks—by walking through detailed source‑code examples and step‑by‑step execution traces for a sample bean.
This article explains the IDEA warning for @Autowired field injection, compares @Autowired and @Resource, outlines the pros and cons of constructor, setter, and field injection in Spring, and clarifies why only @Autowired triggers the warning due to its tighter framework coupling.
The article investigates MySQL InnoDB lock‑wait timeouts caused by hanging transactions that lack proper commit or rollback, explains ACID and lock mechanisms, shows how stale ThreadLocal bindings let pooled threads reuse unfinished transactions, and recommends using @Transactional with robust try‑catch handling to prevent such deadlocks.
This article explains why Spring singleton beans can be unsafe in concurrent scenarios, demonstrates the issue with a controller example, and presents multiple solutions including changing bean scope, using ThreadLocal, avoiding member variables, employing concurrent collections, and leveraging distributed caches.
This article explains the Strategy design pattern in Java, demonstrates its integration with Spring using custom annotations, enums, and a context manager, provides complete code examples, discusses its advantages over traditional conditional logic, and shows how to easily add new strategies.
This article explains how Spring treats @Component and @Configuration annotations, distinguishes their LITE and FULL modes, demonstrates the proxy behavior with concrete code examples, and details the role of ConfigurationClassPostProcessor and CGLIB enhancement in implementing FULL configuration.
This article compares Spring’s @Autowired and Java’s @Resource annotations, detailing five key differences—including their origins, lookup order, supported parameters, injection styles, and IDE warnings—while providing code examples and diagrams to help developers choose the appropriate annotation.
This article explains how to create a web‑based chat application similar to WeChat using Netty as the core server, WebSocket for real‑time communication, and Spring MVC for HTTP handling, covering architecture, required tools, core code, and deployment steps.
Explore the complete lifecycle of graceful shutdown in Java backend systems, covering kernel signal handling, JVM shutdown hooks, Spring’s ContextClosedEvent, Dubbo’s integration and bug fix, and Netty’s Reactor shutdown process, with detailed code examples and state transition diagrams.
This article explains why IntelliJ IDEA warns about @Autowired field injection but not @Resource, compares the two annotations, outlines Spring's common DI methods, discusses the pros and cons of constructor, setter, and field injection, and provides guidance on choosing the appropriate approach.
This article explains why IntelliJ IDEA warns about field injection with @Autowired but not with @Resource, compares the two annotations, outlines common Spring DI methods, and discusses the advantages and drawbacks of each injection style.
This article explains how to improve Spring MVC controller logic by separating responsibilities, introducing a unified response structure, handling String return types with ResponseBodyAdvice, applying JSR‑303 validation, creating custom validators, and using custom exceptions with global exception handling to produce concise and maintainable backend code.
This article provides a comprehensive overview of the most frequently used Spring and Spring Boot annotations, explaining their purposes, usage scenarios, and includes practical Java code examples for core, MVC/REST, stereotype, data access, scheduling, asynchronous, and testing annotations.
This article explains how to refactor Spring MVC controller code by introducing a unified response structure, handling String response issues with ResponseBodyAdvice, applying JSR‑303 validation, creating custom validation annotations, and implementing custom exceptions with global exception handling to produce cleaner, more maintainable backend services.
This article explains Spring's core features such as IoC, DI, and AOP, demonstrates a simple Hello World application with Spring Boot, then shows how to implement the same functionality using raw Servlets and a handcrafted mini‑Spring framework, complete with code examples and deployment steps.
This article demonstrates how Spring's @Transactional annotation rolls back only for RuntimeException subclasses, explains why checked exceptions like Exception do not trigger rollback by default, and shows how to configure rollbackFor to handle custom exceptions, illustrated with SQL updates and Java code examples.
This article explains the Spring Bean lifecycle in depth, covering IoC fundamentals, each lifecycle stage, extension points such as Aware interfaces and BeanPostProcessor, and provides a step‑by‑step code walkthrough that maps the execution flow from bean creation to destruction.
This article explains why manual timestamp logging is cumbersome, introduces Spring's org.springframework.util.StopWatch and Apache Commons Lang's StopWatch, provides Maven dependencies, detailed usage examples, key methods, and important cautions for accurate performance measurement in Java applications.
This comprehensive guide explores ten practical Java scheduling techniques—from Linux crontab and JDK Thread/Timer to Spring Task, Quartz, and distributed solutions like XXL‑Job and Elastic‑Job—detailing their usage, code examples, advantages, and drawbacks for robust backend automation.
The article explains why IntelliJ IDEA shows a warning for Spring's @Autowired field injection but not for @Resource, compares the two annotations, outlines common DI methods, and discusses the advantages and drawbacks of constructor, setter, and field injection in Spring applications.
This article explains various methods to add beans to the Spring IoC container, including @Configuration with @Bean, component scanning, @Import with selectors or registrars, FactoryBean usage, and BeanDefinitionRegistryPostProcessor, providing code examples and detailed explanations for each approach.
This article explains the concept and usage of Service Provider Interface (SPI) in Java, demonstrating how JDK’s ServiceLoader, Dubbo’s enhanced SPI, and Spring’s SPI mechanisms enable flexible extension of logging frameworks and other components, while comparing their features, configuration files, and limitations.
