AOP

通常情况都是切一个方法，如果调用另一个带有切面的方法的话，会不会出发 AOP 呢？

两种情况：

1. 调用自身的增强方法
2. 调用其他类的增强方法

1 调用自身的方法

测试接口

public interface Calculator {

    public int add(int i,int j);

    public int sub(int i,int j);

    public int mult(int i,int j);

    public int div(int i,int j);

}

计算方法实现类

@Service
public class CalculatorImpl implements Calculator {

    public int add(int i, int j) {
        System.out.println("add 方法打印：" + (i + j));
        sub(i, j);
        return i + j;
    }

    public int sub(int i, int j) {
        System.out.println("sub 方法打印：" + (i - j));
        return i - j;
    }

    public int mult(int i, int j) {
        return i * j;
    }

    public int div(int i, int j) {
        return i / j;
    }
}

此时编写增强类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component // 将当前类注入到Spring容器内
@Aspect // 表明是一个切面类
public class LogUtil {

    // CalculatorImpl加法增强
    @Pointcut("execution(int com.yeyangshu.aop.CalculatorImpl.add(int, int))")
    public void addPoint(){}

    @Before("addPoint()")
    public void start(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        System.out.println("AOP addPoint：方法开始执行，参数是：" + Arrays.asList(args));
    }

    // CalculatorImpl减法增强
    @Pointcut("execution(int com.yeyangshu.aop.CalculatorImpl.sub(int, int))")
    public void subPoint(){}

    @Before("subPoint()")
    public void start2(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        System.out.println("AOP subPoint：方法开始执行，参数是：" + Arrays.asList(args));
    }
}

测试类

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class AopApplicationTests {

	@Autowired
	CalculatorImpl calculator;

	@Test
	void aopTest() {
        // 执行add方法
		calculator.add(1, 1);
		System.out.println("-------------------------");
        // 执行sub方法
		calculator.sub(1, 1);
	}

}

日志

AOP addPoint：方法开始执行，参数是：[1, 1]
add 方法打印：2
sub 方法打印：0
-------------------------
AOP subPoint：方法开始执行，参数是：[1, 1]
sub 方法打印：0

通过日志查看，单独调用 add/sub 方法都正常增强，但是 add 方法里调用自身增强的 sub 方法却不会触发增强。

2 调用其他增强方法

复制计算方法实现类，命名为 CalculatorImpl2，添加 @Service 注解添加到 Spring 容器中。

import org.springframework.stereotype.Service;

@Service
public class CalculatorImpl2 implements Calculator {

    public int add(int i, int j) {
        System.out.println("add 方法打印：" + (i + j));
        return i + j;
    }

    public int sub(int i, int j) {
        System.out.println("sub 方法打印：" + (i - j));
        return i - j;
    }

    public int mult(int i, int j) {
        return i * j;
    }

    public int div(int i, int j) {
        return i / j;
    }
}

此时 CalculatorImpl 类，add 方法的时候，调用 CalculatorImpl2 的 sub 方法。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class CalculatorImpl implements Calculator {

    @Autowired
    CalculatorImpl2 calculator2;

    public int add(int i, int j) {
        System.out.println("add 方法打印：" + (i + j));
        calculator2.sub(i, j);
        return i + j;
    }

    public int sub(int i, int j) {
        System.out.println("sub 方法打印：" + (i - j));
        return i - j;
    }

    public int mult(int i, int j) {
        return i * j;
    }

    public int div(int i, int j) {
        return i / j;
    }
}

增强类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component // 将当前类注入到Spring容器内
@Aspect // 表明是一个切面类
public class LogUtil {

    // CalculatorImpl加法增强
    @Pointcut("execution(int com.yeyangshu.aop.CalculatorImpl.add(int, int))")
    public void addPoint(){}

    @Before("addPoint()")
    public void start(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        System.out.println("AOP addPoint：方法开始执行，参数是：" + Arrays.asList(args));
    }

    // CalculatorImpl2减法增强
    @Pointcut("execution(int com.yeyangshu.aop.CalculatorImpl2.sub(int, int))")
    public void subPoint(){}

    @Before("subPoint()")
    public void start2(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        System.out.println("AOP subPoint：方法开始执行，参数是：" + Arrays.asList(args));
    }
}

测试类

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class AopApplicationTests {

	@Autowired
	CalculatorImpl calculator1;

	@Autowired
	CalculatorImpl2 calculator2;

	@Test
	void aopTest() {
		calculator1.add(1, 1);
		System.out.println("-------------------------");
		calculator2.sub(1, 1);
	}

}

日志

AOP addPoint：方法开始执行，参数是：[1, 1]
add 方法打印：2
AOP subPoint：方法开始执行，参数是：[1, 1]
sub 方法打印：0
-------------------------
AOP subPoint：方法开始执行，参数是：[1, 1]
sub 方法打印：0

被添加到 Spring 容器里面的方法单独调用能触发增强，被增强的 add 方法调用另一个被 Spring 托管的 sub 方法也可以触发 sub 的增强。

AOP增强测试

原文：https://www.cnblogs.com/yeyangshu/p/14343787.html