1 views collected around this technical thread.
This article explains how to use SQL coloring in MyBatis by implementing a lightweight interceptor or an AspectJ weave to annotate each SELECT statement with its mapper ID and execution stack, enabling rapid identification of performance bottlenecks during high‑traffic events.
This comprehensive guide walks you through Spring Boot 3 AOP fundamentals, showing how to declare aspects with @Aspect, define pointcuts using @Pointcut, apply various advice types, manage ordering, bind method parameters, and leverage inter‑type declarations with clear code examples and diagrams.
Upgrading to Spring Boot 2.7.1 (Spring Framework 5.3.21) alters the execution order of @Around, @Before, @After, @AfterReturning, and @AfterThrowing advice within the same @Aspect, causing ThreadLocal data loss and prompting a recommendation to consolidate logic into a single @Around advice.
The article details practical monitoring strategies for both remote Redis and local Caffeine caches in high‑traffic game services, including prefix‑based Redis key tracking, Aspect‑oriented instrumentation, Caffeine statistics collection, and real‑world case studies that illustrate how these metrics identify hot‑keys, cache‑miss spikes, and reduce system load.
This article explains how Spring AOP’s @DeclareParents introduces new interfaces to proxied beans at runtime, walks through defining interfaces, implementations, aspect configuration, testing with Spring Boot 3, and also covers perthis and pertarget aspect instantiation models for fine‑grained lifecycle control.
This article explains how to create simple AOP aspects in Spring Boot 3, then dives into complex scenarios such as combining pointcut expressions, sharing pointcuts across aspects, programmatic pointcut composition, and controlling advice execution order, providing clear code examples for each case.
This article explains how the @Order annotation and Ordered interfaces control bean, listener, runner, and aspect execution order in Spring Boot 3, providing step‑by‑step code examples, output demonstrations, and guidance on applying ordering to various Spring components.
This article explains Spring AOP pointcut expression syntax, demonstrates how to match methods, packages, and beans with execution, within, and bean designators, shows how to combine expressions, and details controlling aspect execution order using @Order and the Ordered interface.
This guide explains how to use Spring's @Configurable annotation and the AnnotationBeanConfigurerAspect to inject dependencies into objects created with new, covering environment setup, Maven configuration, AspectJ weaving, and advanced options like autowiring, constructor injection, and dependency checks.
This article explains Spring AOP’s core concepts, shows how proxies are normally created with @EnableAspectJAutoProxy, and details several edge cases—such as implementing Advice, Pointcut, Advisor, or using special bean names—where Spring will not generate a proxy, providing code examples and the resulting output for each scenario.
Explore three Spring AOP implementation methods—dynamic proxy, Java Agent, and AspectJ Maven plugin—by setting up a sample Service, defining aspects, configuring aop.xml and JVM arguments, and comparing their flexibility, performance impact, and compile‑time weaving within a Spring Boot 2.7 environment.
This article explains why a Spring AOP aspect that overrides a parent method logs twice, walks through the debugging process that reveals duplicate advisor creation, and presents two solutions—including a pointcut tweak and upgrading to Spring 6.1.8—to eliminate the redundant logs.
This guide explains how to implement a robust, re‑entrant distributed lock using Redisson in a Spring Boot 2.7 application, covering basic and asynchronous APIs, Maven dependency setup, YAML configuration, custom annotation, AspectJ implementation, and comprehensive test cases.
This guide explains how to implement API rate limiting in SpringBoot 2.7.16 using custom annotations, AspectJ, and the high‑performance Caffeine cache, covering cache configuration, eviction policies, statistics, and practical code examples for annotation definition, aspect logic, and controller usage.
This tutorial walks through Spring AOP's control flow pointcuts and introduction advice, showing how to define dynamic pointcuts, create advisors, and use @DeclareParents to add interfaces to beans, complete with practical code examples and output analysis.
This article explains Spring's control flow pointcuts, compares them with AspectJ cflow pointcuts, walks through a complete Java example with nested service classes, shows how to configure a ControlFlowPointcut and proxy, and discusses performance implications and usage scenarios.
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.
After upgrading to Spring Boot 2.7.1 (Spring Framework 5.3.21), the execution order of @Around, @Before, and @After advice changes, leading to ThreadLocal data loss inside @Around, and the article explains the cause, reproduces the issue, and recommends using only @Around for reliable logic.
This article provides a comprehensive analysis of Spring AOP, covering its core concepts, configuration parsing, BeanFactoryPostProcessor and BeanPostProcessor mechanisms, namespace handling, the creation of advisors and advice from @Aspect annotations, and the proxy generation process that enables method interception.
This article demonstrates how to create a request‑logging aspect in Spring Boot using AOP annotations, shows code for pointcuts, advices, high‑concurrency optimizations, exception handling, and trace‑ID propagation, and explains the underlying concepts and practical tips.