Spring AOP原理

2019-02-12 本文已影响47人黄靠谱

参考示例源代码:

https://github.com/huangzhenshi/SpringFreamworkDemo/tree/master

概述

Spring代理模式的运用场景: 操作日志、事务控制、异常处理（AOP ThrowsAdvice）、权限认证、缓存
Spring AOP实现的默认两种方式：DK动态代理、CGLIB

JDK动态代理反射原理的类依赖其接口，代理接口的实现方法，普通方法无法代理。
CGLIB，字节码增强技术，根据代理类实现一个增强的子类,采用方法拦截的技术拦截所有父类方法的调用，并顺势织入横切逻辑

设置proxy-target-class=true，全部都用CGLIB，false则接口类用反射，非接口类用CGLIB
Spring实现代理有4种方式：子类继承、@Aspect注解、JDK动态代理、CGLIB，各有各适用的场景

代理模式分析

继承的方法，最灵活，可以精准实现一个被代理类的一个方法。
@Aspect 先定义一个自定义注解，再定义一个@Aspect类，并且把切点指定为自定义注解，编写不同业务场景下的代理逻辑，最后直接在需要代理的方法上使用。优点是非常容易复用，而且封装了复杂性。编译期生成代码。
JDK动态代理，半灵活，把需要代理的方法写在继承接口里面，不希望被代理的方法，写在普通方法里面。
CGLIG最方便，不依赖接口，全部方法都用相同的代理逻辑

可以通过继承的方式，然后重写父类的方法，这样实现代理模式。
优势：特别灵活，可以根据业务需求，为某个代理类的每个方法实现不同的代理逻辑
缺点：代码量太大。如果一个类的多个方法代理逻辑一样，或者多各类的代理逻辑一样，无法复用。
@Aspect是针对某一类方法而创造的，比如对service层的所有新增的方法，添加日志的功能。
优势：编码简洁（写一个工具注解既可以，然后在需要代理的类上做注解即可），可以实现精准代理，是针对方法的代理模式

JDK动态代理，实体类所有的接口方法，都会执行相同的代理逻辑
优点：可以批量代理一个代理类里面所有接口中的方法；不同的代理类继承相同的接口，可以复用代理工具类，只要代理逻辑一样
缺点：完全依赖接口，所有要代理的方法必须要在接口中存在，否则无法代理
CGLIG代理模式：
优点：没有束缚，通过特殊的处理，通过继承和织入，对该类的所有的方法，都织入相同的代理逻辑
缺点：缺乏灵活性，无法为代理类的某一个方法定制特殊的代理逻辑

JDK动态代理实现

实现步骤：

写一个接口Subject，把所有要代理的方法都要写在接口里面
被代理类RealSubject实现接口，实现自己本身的业务逻辑，当然也可以包含一些不想被代理的方法，只要接口里没有，都不会被代理
写一个代理工具类Dynamicproxy，实现InvocationHandler接口，实现invoke方法，编写代理逻辑
创建代理类，调用代理方法

注意事项：被代理类里面可以包含接口里面没有的方法，实现保护某些方法被代理，这些未暴露的方法，在代理类中是不可见的，也不能被调用。

代码

public interface Subject {
    public void rent();
    public void hello(String str);
}

public class RealSubject implements Subject{
    @Override
    public void rent() {
        System.out.println("I want rent my house");
    }
    @Override
    public void hello(String str) {
        System.out.println("hello:"+str);
    }
    public void test(){
        System.out.println("Test");
    }
}

代理工具类

public class Dynamicproxy implements InvocationHandler{
    
    //这就是我们代理的真实对象
    private Object subject;
    
    //构造方法，给我们要代理的真实对象赋值
    public Dynamicproxy(Object subject){
        this.subject = subject;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //在代理真实对象前我们可以添加一些自己的操作
        System.out.println("代理开始");
        System.out.println("代理Method:"+method);
        
        //当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
        method.invoke(subject, args);
        
        //在代理真实对象后我们可以添加一些自己的操作
        System.out.println("代理结束");
        return null;
    }
}

代理

public class JDK动态代理 {
    public static void main(String[] args) {
        //我们要代理的真实对象
        RealSubject realSubject = new RealSubject();
        //我们要代理哪个真实对象，就将该对象传进去，最后通过该真实的对象调用该方法
        InvocationHandler handler = new Dynamicproxy(realSubject);
        
        Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler);
        System.out.println(subject.getClass().getName());
        subject.rent();
        subject.hello("world");
    }
}

CGLib实现

通过实现MethodInterceptor的intercept方法，来对所有的代理类进行代理操作。
具体涉及到继承的增强类子类Enhancer类。并设置子类的方法调用触发器

public class CglibProxy implements MethodInterceptor {
    // 被代理对象
    Object targetObject;

    //参数为被代理类，返回结果为代理类
    public Object getProxyObject(Object object) {
        this.targetObject = object;
        //增强器，动态代码生成器
        Enhancer enhancer=new Enhancer();
        //回调方法
        enhancer.setCallback(this);
        //设置生成类的父类类型
        enhancer.setSuperclass(targetObject.getClass());
        //动态生成字节码并返回代理对象
        return enhancer.create();
    }
    // 拦截方法
    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法调用前");
        // 调用方法
        Object result = methodProxy.invoke(targetObject, args);
        System.out.println("方法调用后");
        return result;
    }
}

Spring中的配置

Pointcut（切点）：指定在哪些类的哪些方法上织入横切逻辑
Advice（增强）：描述横切逻辑和方法的具体织入点（方法前、方法后、方法的两端等）
Advisor（切面）：将Pointcut和Advice两者组装起来。有了Advisor的信息，Spring就可以利用JDK或CGLib的动态代理技术采用统一的方式为目标Bean创建织入切面的代理对象了

 <aop:config expose-proxy="true" proxy-target-class="true">
        <aop:pointcut id="txPointcut" expression="execution(* com.test.service..*.*(..))"/>
        <aop:advisor pointcut-ref="txPointcut" advice-ref="txAdvice"/>
    </aop:config>

自定义注解的使用

https://www.jianshu.com/p/7dcd59bdbb0a

通过元注解给注解做修饰
在对应的地方使用注解（可以是类上加注解、方法上加注解、属性上加注解)
通过反射获取到目标（类、方法、属性），并调用 ***.getAnnotation()，从而获取注解类

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyMessage {
        String name() default "sam";
        int num() default 0;
        String desc();
}

public class AnnotationTest {
    @MyMessage(num = 10, desc = "参数a")
    private static int a;


    @MyMessage(name = "Sam test", desc = "测试方法test")
    public void test() {
        System.out.println("test");
    }
}

public static void main(String[] args) throws Throwable{
            //加载annotationTest.class类
            Class clazz = Class.forName("com.test.aop.自定义注解.AnnotationTest");
            //获取属性
            Field[] fields = clazz.getDeclaredFields();
            //遍历属性
            for (Field field : fields) {
                MyMessage myMessage = field.getAnnotation(MyMessage.class);
                System.out.println("name:" + myMessage.name() + "  num:" + myMessage.num() + "  desc:" + myMessage.desc());
            }
            //获取类中的方法
            Method[] methods = clazz.getMethods();
            //遍历方法
            for (Method method : methods) {
                //判断方法是否带有MyMessage注解
                if (method.isAnnotationPresent(MyMessage.class)) {
                    // 获取所有注解 method.getDeclaredAnnotations();
                    // 获取MyMessage注解
                    MyMessage myMessage = method.getAnnotation(MyMessage.class);
                    System.out.println("name:" + myMessage.name() + "  num:" + myMessage.num() + "  desc:" + myMessage.desc());
                }
            }
    }

Aspect

https://www.cnblogs.com/magicalSam/p/7161942.html
原理：通过自定义注解+Aspect技术实现AOP代理

通过@Aspect注解使该类成为切面类
通过@Pointcut 指定切入点，这里指定的切入点为MyLog注解类型，也就是被@MyLog注解修饰的方法，进入该切入点。
@Before 前置通知：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
@Around 环绕通知：可以实现方法执行前后操作，需要在方法内执行point.proceed(); 并返回结果。
@AfterReturning 后置通知：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
@AfterThrowing 异常通知：在方法抛出异常退出时执行的通知。
@After 后置通知：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回

@Aspect 
@Component
public class MyLogAspect {
     //切入点
    @Pointcut(value = "@annotation(com.test.aop.aspectj.MyLog)")
    private void pointcut() {

    }
     //pointcut() 设置切点，也就是aspect绑定Mylog注解的一个纽带
     //@annotation(myLog) 注入当前的mylog，这样才可以正常的mylog.requestUrl了
     @Around(value = "pointcut()&& @annotation(myLog)")
     public Object around(ProceedingJoinPoint point, MyLog myLog) {

         System.out.println("++++执行了around方法++++");
         //拦截的类名
         Class clazz = point.getTarget().getClass();
         //拦截的方法
         Method method = ((MethodSignature) point.getSignature()).getMethod();

         System.out.println("执行了 类:" + clazz + " 方法:" + method + " 自定义请求地址:"+myLog.requestUrl());

         try {
             Object result=point.proceed();
             System.out.println("++++执行了around方法结束++++");
             return  result;//执行程序
         } catch (Throwable throwable) {
             throwable.printStackTrace();
             return throwable.getMessage();
         }
     }
}

参考

https://zhuanlan.zhihu.com/p/29483023

Spring AOP原理

参考示例源代码:

概述

代理模式分析

JDK动态代理实现

CGLib实现

自定义注解的使用

Aspect

参考

猜你喜欢

热点阅读