Java 8 Lambda中为Runnable.run实现@Before与@After切面的方法

嗨，我来帮你搞定这个需求！因为Spring AOP的动态代理机制无法覆盖Lambda生成的Runnable实例，所以我们需要用AspectJ来实现字节码层面的切面织入，这样不管是普通类还是Lambda实现的Runnable，都能被拦截到。

步骤1：定义AspectJ切面类 #

首先创建一个切面类，里面包含切入点定义和对应的@Before、@After增强方法：

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class RunnableAspect {

    // 定义切入点：匹配所有Runnable接口的run()方法执行
    @Pointcut("execution(void java.lang.Runnable.run())")
    public void runnableRun() {}

    // Before切面：在run()执行前输出指定内容
    @Before("runnableRun()")
    public void beforeRunnableExecution() {
        System.out.println("Before runnable");
    }

    // After切面：在run()执行后输出指定内容
    @After("runnableRun()")
    public void afterRunnableExecution() {
        System.out.println("After runnable");
    }
}

步骤2：编写测试代码 #

接下来写测试代码，验证Lambda形式的Runnable是否能被切面拦截：

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class RunnableLambdaTest {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        // 执行Lambda形式的Runnable
        executor.runAsync(() -> {
            System.out.println("Runnable invoked");
        });
        
        executor.shutdown();
        executor.awaitTermination(1, java.util.concurrent.TimeUnit.SECONDS);
    }
}

步骤3：配置AspectJ（Maven示例） #

如果是Maven项目，需要添加AspectJ的依赖和编译插件，确保切面能被正确织入字节码：

<dependencies>
    <!-- AspectJ运行时依赖 -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.9.21</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- AspectJ编译插件：负责编译期织入切面 -->
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.14.0</version>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>test-compile</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <complianceLevel>1.8</complianceLevel>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

为什么这个方案能生效？ #

Lambda表达式在Java编译后会生成一个匿名类，但这个类不是Spring动态代理创建的，所以Spring AOP无法拦截它。而AspectJ是直接在字节码层面织入切面逻辑，不管Runnable是普通类、匿名内部类还是Lambda生成的，只要它实现了Runnable接口并调用了run()方法，就会被我们定义的切入点匹配到。

预期输出 #

执行测试代码后，你会看到以下输出顺序：

Before runnable
Runnable invoked
After runnable

内容的提问来源于stack exchange，提问作者Manoj