Spring BOOT AOP是什么

面试课题一: Spring boot AOP

  • Spring boot 中 AOP是其中 重要的特性,其实现的方式借助的拦截器 + Proxy 动态代理,在AOP主要用于日志打印,安全拦截,事务处理,异常处理和性能统计,要向深刻了解Spring boot AOP 原理,从 Spring 动态代理的原理讲起

Spring boot 动态代理

  • 原理:
    动态代理底层实现借助 java.lang.reflect.Proxy 的 newProxyInstance的方法
    在这里插入图片描述
    其有是三个参数: 1.Class的类加载器 2.接口方法 3.h 增强方式
    在代码中 定于 interface , interfaceImpl 具体的实现类 ,使用 java 代理代码方式进行处理:
 Proxy.newProxyInstance(Main.Class.getClassLoader(), new Class[] {UserDao.class}, new InvocationHandler() {
})
在 InvocationHandler()  调用方法之前增强添加预处理 和 方法调用后的处理东西
public interface UserDao {
    public int add(int a, int b);
}
public class UserDaoImpl implements UserDao {
    @Override
    public int add(int a, int b) {
        System.out.println("add 方法执行了");
        return a+b;
    }
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDaoImpl = new UserDaoImpl();

        //创建接口实现类代理对象
        //此处用UserDao作为返回值的类型,是因为我们传入的interfaces就是UserDao.class
        UserDao dao = (UserDao) Proxy.newProxyInstance(Main.class.getClassLoader(), interfaces, new InvocationHandler() {
            //把想要代理的对象传递进来
            private Object object = userDaoImpl;

            //增强的逻辑
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                //方法之前
                System.out.println("方法之前执行 : " + method.getName() + "; 传递的参数:" + Arrays.toString(args) + "; object:" + object);

                //被增强的方法执行,填写要增强的对象、参数
                Object res = method.invoke(object, args);

                //方法之后
                System.out.println("方法之后执行 : " + method.getName() + "; 传递的参数:" + Arrays.toString(args) + "; object:" + object);

                return res;
            }
        });


        int res = dao.add(1, 2);
        System.out.println("这个是res: " + res);
    }
}

  • 总结
    Spring boot中 能够实现AOP的底层原理,之上的代码属于静态编码方式 ,需要相同的逻辑抽象出来,因此诞生了AOP,在Spring boot中 动态代理有两种
  1. 基于接口的JDK-动态代理(返回类型属于接口类型)
  2. 基于父类的cglib 代理,通过继承关系代理(不管是接口还是实现类 OK)
    在实际使用过程中 Spring boot 默认 cglib动态代理 ,使用范围更加广泛

AOP 切面

基本知识

  1. pointcut: 切入点: execution… 表示需要在哪些方法上生效,对哪些方法进行增强 – 使用正则表达式
  2. Advice: 通知: 自定义处理 ,通知 分为BeforAdvice, AfterAdvice, ThrowAdvice
  3. Advisor: 将 PointCut 与 Advice 进行连接起来定义哪些通知在哪些方法增强生效 – 对切面XXAOP 使用@Ascpect 注解进行生效定义
@Component
@Aspect
public class BookAop {
    // 定义切入点
    public static final String POINT_CUT = "execution(* com.example.bootaop.dao..*.*(..))";

    @Before(POINT_CUT)
    public void before() {
        System.out.println("----------添加图书方法前[校验]-----------");
    }

    @After(POINT_CUT)
    public void after(JoinPoint jp) {
        System.out.println("----------添加图书成功后-----------");
        System.out.println(jp.getTarget().getClass());
        System.out.println(Arrays.asList(jp.getArgs()));
    }
}

自定义注解

如上显示是 AOP的切面,但是AOP切面有个使用不好定法在于 pointcut 写正则表达式 无法准确的表达,最好有个插拔式方式 ,引入到自定义注解,自定义注解弥补这一缺陷

  • 元注解
    元注解是 java 自带的类型,
  1. @Retention 注解 保留策略(SOURCE,CLASS,RUNTIME)
@Retention(RetentionPolicy.SOURCE) 仅存在于源码中

@Retention(RetentionPolicy.CLASS) 存在于class字节码中,但运行时无法获取

@Retention(RetentionPolicy.RUNTIME) 存在于class字节码中,运行时可以通过反射获取
  1. Target 注解 作用范围
@Target(ElementType.TYPE) 接口、类等

@Target(ElementType.FIELD) 字段

@Target(ElementType.METHOD) 方法

@Target(ElementType.PARAMETER) 方法参数

@Target(ElementType.CONSTRUCTOR) 构造函数

@Target(ElementType.LOCAL_VARIABLE) 局部变量

@Target(ElementType.ANNOTATION_TYPE) 注解

@Target(ElementType.PACKAGE)
  1. 自定义注解:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyLog {
    String value() default "";
}
  1. 如何在AOP引用
    在 pointcut = “@annotation(MyLog)”
@Slf4j
@Aspect
@Component
public class LogAspect {

    @Around("@annotation(myLog)")
    public Object around(ProceedingJoinPoint point, MyLog myLog) throws Throwable{
        String className = point.getTarget().getClass().getName();
        String methodName = point.getSignature().getName();
        String value = myLog.value();
        log.info("类名:{},方法名:{},注解值:{}",className,methodName,value);
        log.info("方法之前执行");
        long startTime = System.currentTimeMillis();
        Object proceed = point.proceed();
        long endTime = System.currentTimeMillis();
        long time = endTime - startTime;
        log.info("方法之后执行");
        log.info("方法耗时:{}", time);
        return proceed;
    }

}

你可能感兴趣的:(spring,boot,java,spring)