Spring AOP 接口动态引入的实现

AOP引入：可以将其他接口或实现动态的引入到目标类中

（1）首先需要定义被增强的类，接口：Calculate.java，实现类：SimpleCalculate.Java

// 目标接口
public interface Calculate {
    // 加法
    int add(int numA, int numB);
}

// 目标接口实现类
@Component
public class SimpleCalculate implements Calculate {
    public int add(int numA, int numB) {
        System.out.println("执行目标方法:add");
        return numA+numB;
    }
}

（2）接下来，定义额外的接口和实现类，接口：ProgramCalculate.java，实现类：SimpleProgramCalculate.java

// 接口
public interface ProgramCalculate {
    // 转为二进制
    String toBinary(Integer value);
}

// 实现类
public class SimpleProgramCalculate implements ProgramCalculate {
    @Override
    public String toBinary(Integer value) {
        return Integer.toBinaryString(value);
    }
}

（3）最后创建切面，对目标对象进行接口引入

import com.swadian.aopdemo.Introductions.ProgramCalculate;
import com.swadian.aopdemo.Introductions.SimpleProgramCalculate;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.DeclareParents;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import java.util.Arrays;

@Aspect
@Component
public class LogAspect {
    // 引入
    @DeclareParents(value = "com.swadian.aopdemo.SimpleCalculate",   // 需要进行动态代理的类(增强)
            defaultImpl = SimpleProgramCalculate.class)  // 引入的接口的实现
    public static ProgramCalculate programCalculate;     // 引入的接口

    @Pointcut("execution(* com.swadian.aopdemo.SimpleCalculate.*(..))")
    public void pointCut() {
    }

    @Before(value = "pointCut()") // 前置通知
    public void methodBefore(JoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        Object target = joinPoint.getTarget();
        String className = target.getClass().getName(); // 获取类名
        System.out.println("执行" + className + ".【" + methodName + "】的<前置通知>,入参" + Arrays.asList(joinPoint.getArgs()));
    }
}

public class MainClass {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
        // 被代理类
        Calculate calculate = (Calculate) ctx.getBean("simpleCalculate");
        int retVal = calculate.div(2, 4);
        // 被代理类的引入-> simpleCalculate可以强转为ProgramCalculate 
        ProgramCalculate pCalculate = (ProgramCalculate) ctx.getBean("simpleCalculate");
        System.out.println(pCalculate.toBinary(100));
    }
}

被代理类SimpleCalculate进行AOP引入后，具备了ProgramCalculate接口的功能，实现了将其他接口或实现，动态的引入到目标类中。另外，执行引入接口的方法时，不会再额外调用其他前置或后置等AOP通知方法，因为接口引入本身就是一种增强。