Sring第五课-------spring（AOP）—动态代理源码分析

SpringAOP—动态代理

一、课程目标

【理解】SpringAOP面向切面编程概念
【了解】动态代理
【掌握】AOP注解开发

二、AOP

2.1 概念

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

可以理解为在对同一个系统应用不同用户的使用过程中，对调用的相同方法进行切面拦截，添加额外的功能在不修改原有代码的前提下进行功能的增强（使用代理模式将方法进行代理增强）

2.2 作用

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强

优势：减少重复代码，提高开发效率，并且便于维护

springAOP主要用于项目日志的管理以及事务的管理

2.3 AOP 的底层实现

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

首先书写相应的增强方法（执行指定方法时额外执行的方法），通过配置或注解形式将增强方法与切入点进行连接，这样当指定的方法被执行时，默认会调用jdk动态代理创建代理对象并将增强方法在指定位置执行，如果被代理的类没有实现任意接口那么会使用cglib动态代理

2.4 AOP 的动态代理技术

常用的动态代理技术

JDK 代理

基于接口的动态代理技术

（1）创建目标类实现接口

//目标类接口
//代理的目标类所实现的接口
public interface TargetInterface {
    void method();//目标类实现执行的方法
    void method1(int i);//目标类实现执行的方法
}

（2）创建目标类实现对应接口

//目标类
//被代理
public class Target implements TargetInterface{
    @Override
    public void method() {
        System.out.println("原始方法执行");
    }
    @Override
    public void method1(int i) {
        System.out.println("原始方法执行"+i);
    }
}

（3）创建代理类代理指定目标类对象

        //创建目标对象
        TargetInterface target = new Target();
        //创建代理对象
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass()
                        .getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
                    //proxy当前代理对象   method当前执行的方法  args方法执行的参数
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                        System.out.println("前置增强代码...");
                        Object invoke = method.invoke(target, args);
                        System.out.println("后置增强代码..."+method.getName()+"方法执行使用参数数据"+ Arrays.toString(args));
                        return invoke;
                    }
                }
        );
        //等价于
        TargetInterface proxy1=new TargetInterface() {
            @Override
            public void method() {
                System.out.println("前置增强代码...");
                target.method();
                System.out.println("后置增强代码...");
            }

            @Override
            public void method1(int i) {
                System.out.println("前置增强代码...");
                target.method1(i);
                System.out.println("后置增强代码...");
            }
        };
        //jdk动态代理的原理
        //可以理解为在创建目标对象后通过相同的接口创建相同的代理对象（通过匿名内部类的形式基于原目标对象的方法创建了一个新的代理对象）

（4）使用代理类对象执行对应方法实现方法的增强

        //调用对应方法
        proxy.method1(2);

CGLIB 代理

		<!--添加maven依赖-->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

基于父类的动态代理技术

（1）创建目标类

//目标类
//被代理
public class Target  {
    public void method() {
        System.out.println("原始方法执行");
    }
    public void method1(int i) {
        System.out.println("原始方法执行"+i);
    }
}

（2）创建增强器（用于创建增强子类的工具）

        Target target = new Target(); //创建目标对象
        Enhancer enhancer = new Enhancer();   //创建增强器
        enhancer.setSuperclass(Target.class); //设置父类
        enhancer.setCallback(new MethodInterceptor() { //设置回调
            @Override
            public Object intercept(Object o, Method method, Object[] objects,
                                    MethodProxy methodProxy) throws Throwable {
                System.out.println("前置代码增强2....");
                Object invoke = method.invoke(target, objects);
                System.out.println("后置代码增强2....");
                return invoke;
            }
        });
        //cglib动态代理原理
        //创建对应目标类的子类通过类似于重写的方式将增强代码书写

（3）调用增强器创对应代理对象执行方法

        Target proxy = (Target) enhancer.create(); //创建代理对象
        proxy.method();