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 {@Resourceprivate Target target;@Autowiredprivate SonTarget sonTarget;@Testpublic 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()方法，运行测试类：