SpringBoot AOP相关注解 spring aop 注解

前言

  接触过Spring的都知道，aop是其中重要的特性之一。笔者在开发做项目中，aop更多地是要和注解搭配：在某些方法上加上自定义注解，然后要对这些方法进行增强(很少用execution指定，哪些包下的哪些方法要增强)。那这时就要引出@annotation、@target、@within了。我们一一讲解。

@annotation

  方法上是否有指定注解；子类调用不重写的方法会被aop拦截，调用重写的方法看是否加了指定注解。

  首先引入依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>2.7.4</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>2.7.4</version>
    <scope>test</scope>
</dependency>

  自定义一个注解：

import java.lang.annotation.Target;
import java.lang.annotation.*;

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Outer {

    int limit() default 0;

}

  目标类：

import org.springframework.stereotype.Component;

@Component
public class Target {

    @Outer(limit = 8)
    public void invoke() {
        System.out.println("执行Target的方法");
    }
    
}

@Component
public class SonTarget extends Target {
		
}

  切面类：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

@Component
@Aspect
public class MyAspect {

    @Around("@annotation(com.gs.spring_boot_demo.aop.Outer)")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Method method = ((MethodSignature)point.getSignature())
                        .getMethod();
        Outer outer = method.getAnnotation(Outer.class);

        System.out.println("aop前置：" + outer.limit());
        return point.proceed();
    }

}

  编写测试类：

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

@SpringBootTest
public class AopTest {

    @Resource
    private Target target;

    @Autowired
    private SonTarget sonTarget;

    @Test
    public void aop() {
        target.invoke();
        System.out.println("---");
        sonTarget.invoke();
    }
    
}

  运行aop方法，打印结果：

  把子类SonTarget修改一下，

import org.springframework.stereotype.Component;

@Component
public class SonTarget extends Target {
	
    public void invoke() {
        System.out.println("子类执行Target的方法");
    }

}

  再次运行测试类，这时子类的invoke()方法不会被拦截了：

  当然，如果SonTarget的invoke()方法上加上@Outer，那就能被aop拦截了。

@target

  调用方法的对象，所属的类上是否有指定注解；注解被@Inherited修饰，子类调用会生效；无@Inherited，看子类上有无该注解。

  自定义注解不动，目标类修改为：

import org.springframework.stereotype.Component;

@Component
@Outer(limit = 8)
public class Target {
	
    public void invoke() {
        System.out.println("执行Target的方法");
    }

}

import org.springframework.stereotype.Component;

@Component
public class SonTarget extends Target {
	
    public void invoke() {
        System.out.println("子类执行Target的方法");
    }

}

  切面类修改为：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

@Component
@Aspect
public class MyAspect {

    /**
     * 要注意一下，@target很硬霸：所有的bean都会被动态代理(不管类上有没有加自定
     * 义注解)，所以要约束为：本项目下的包下
     * 不然测试用例运行时会报错：依赖中有些类是final的，被动态代理会报错
     */
	@Around("@target(com.gs.spring_boot_demo.aop.Outer) && 
	        within(com.gs.spring_boot_demo..*)")
	public void around(ProceedingJoinPoint point) throws Throwable {
	    Method method = ((MethodSignature)point.getSignature())
	                    .getMethod();
	    Outer outer = method.getDeclaringClass().getAnnotation(
	                  Outer.class);
	
	    System.out.println("aop前置：" + outer.limit());
	    point.proceed();
	}

}

  测试类不动，运行：

  SonTarget的invoke()没有被拦截，想要被拦截，就在SonTarget类上添加@Outer；或者自定义注解上增加@Inherited(表明父类加上该注解后，子类能够继承)：

import java.lang.annotation.Target;
import java.lang.annotation.*;

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Outer {

    int limit() default 0;

}

@within

  方法所属的类上，是否有指定注解；注解没有被@Inherited修饰，子类调用不重写的方法会被拦截，调用重写的方法看子类上是否有注解；注解被@Inherited修饰，子类调用方法都会被拦截，不管是否重写

  自定义注解改一下，就把修饰它的@Inherited去掉；
  目标类：

import org.springframework.stereotype.Component;

@Component
@Outer(limit = 8)
public class Target {
	
    public void invoke() {
        System.out.println("执行Target的方法");
    }

}

import org.springframework.stereotype.Component;

@Component
public class SonTarget extends Target {
	
}

  切面类修改为：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

@Component
@Aspect
public class MyAspect {
	
    @Around("@within(com.gs.spring_boot_demo.aop.Outer)")
    public void around(ProceedingJoinPoint point) throws Throwable {
        Method method = ((MethodSignature)point.getSignature())
                        .getMethod();
        Outer outer = method.getDeclaringClass().getAnnotation(
                      Outer.class);

        System.out.println("aop前置：" + outer.limit());
        point.proceed();
    }

}

  测试类不动，运行：

  子类的方法能被拦截；我们把子类的方法重写一下：

import org.springframework.stereotype.Component;

@Component
public class SonTarget extends Target {
	
    public void invoke() {
        System.out.println("子类执行Target的方法");
    }

}

  再次运行测试类，打印出结果：

  子类的方法没有被拦截，想要被拦截，SonTarget类上加上@Outer。

  我们再试一下自定义注解被@Inherited修饰的情况。@Outer注解加上@Inherited，然后Target不动，SonTarget也不动(重写了invoke()方法，类上也没有@Outer)，运行测试类：

  SonTaget改一下，不重写invoke()方法，运行测试类：