设计模式-AOP动态代理-jdkcglib

Posted 2021-09-06 赵晓东-Nastu

前言

最近在学习Spring的AOP，学习AOP首先我们需要知道动态代理，所以我就整理了一下关于动态代理的实现方式。

过程

实现动态代理一共有两种方式，一种是jdk的，一种是cglib的，在了解动态代理之前我们首先来了解静态代理。

静态代理

ITeacherDao

public interface ITeacherDao {
    void teach();
}

TeacherDao

public class TeacherDao implements ITeacherDao {
    public void teach(){
        System.out.println("老师授课中。。。");
    }
}

TeacherDaoProxy

public class TeacherDaoProxy  implements ITeacherDao{
    //目标对象
    private final ITeacherDao target;

    public TeacherDaoProxy(ITeacherDao target) {
        this.target = target;
    }

    //代理对象执行目标对象的方法，通过共同的接口来规范代理
    @Override
    public void teach() {
        System.out.println("代理开始");
        target.teach();
        System.out.println("代理结束");
    }
}

Client1

public class Client1 {
    public static void main(String[] args) {
        //被代理对象
        TeacherDao teacherDao = new TeacherDao();

        //代理对象，同时将被代理对象传递给代理对象
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);

        teacherDaoProxy.teach();
    }
}

分析：
现在需要一个类去代理TeacherDao，让它也实现了teach方法，所以现在抽象于接口ITeacherDao，代理和被代理者都继承了ITeacherDao。这样ITeacherDao和TeacherDaoProxy作为组合关系，就可以调用teach方法了。然后在前后就可以增加代码。
如果现在再来一个MasterDao去继承了ITeacherDao，那么需要重新写一个代理类，如果再来几个需要重新写几个代理类。所以接下来就有了动态代理了。来保证代理类只有一个。

动态代理

jdk方式

ITeacherDao

public interface ITeacherDao {
    void teach();
    void sayHello(String name);
}

TeacherDao

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师正在授课中");
    }

    @Override
    public void sayHello(String name) {
        System.out.println("hello "+name);
    }
}

ProxyFactory

public class ProxyFactory {
    //维护一个目标对象，object
    private final Object target;

    //对target进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //***给目标对象生成一个代理对象(这样代理对象就根据不是固定类型的了，而是根据实际生成的类型)
    //代理对象执行的是目标对象的方法-拿到目标对象的接口与目标对象的类型(取代原来的代理对象实现接口)
    // *得到* 代理，并执行目标的方法
    public Object getProxyInstance() {
        // params:
        // 指定当前对象使用的类加载器，获取加载器的方法固定
        // ***目标对象实现的接口类型使用泛型方法确认
        // 事件处理，执行目标对象的方法时会触发事件处理器的方法，会把当前执行的目标对象方法作为参数传入
        //得到代理
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method,
                                         Object[] args) throws Throwable {
                        System.out.println("JDK代理开始");
                        //反射机制得到目标，调用目标对象的方法
                        Object invoke = method.invoke(target, args);
                        System.out.println("JDK代理提交");
                        return invoke;
                    }
                });
    }
}

Client

public class Client2 {
    public static void main(String[] args) {
        //创建目标对象
        TeacherDao target = new TeacherDao();

        //由目标对象类型→确定代理对象类型(体现出动态：不写死而是根据目标生成)→目标的接口(在此确定了实现接口的类：目标对象)
        //给目标对象创建代理对象
        ITeacherDao proxyInstance = ( ITeacherDao)new ProxyFactory(target).getProxyInstance();

        //proxyInstance = class com.sun.proxy.$Proxy0：内存中动态生成了代理对象
        System.out.println("proxyInstance = "+proxyInstance.getClass());

        //实现接口的方法：接口.方法,实际↑，接口实际为创建出的代理对象
        // 通过代理对象调用目标对象的方法
        proxyInstance.teach();
        proxyInstance.sayHello("tom");
    }
}

第二种方法：

public class ProxyFactory implements InvocationHandler{
    //维护一个目标对象，object
    private final Object target;

    //对target进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //***给目标对象生成一个代理对象(这样代理对象就根据不是固定类型的了，而是根据实际生成的类型)
    //代理对象执行的是目标对象的方法-拿到目标对象的接口与目标对象的类型(取代原来的代理对象实现接口)
    // *得到* 代理，并执行目标的方法
    public Object getProxyInstance() {
        // params:
        // 指定当前对象使用的类加载器，获取加载器的方法固定
        // ***目标对象实现的接口类型使用泛型方法确认
        // 事件处理，执行目标对象的方法时会触发事件处理器的方法，会把当前执行的目标对象方法作为参数传入
        //得到代理
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("JDK代理开始");
        //反射机制得到目标，调用目标对象的方法
        Object invoke = method.invoke(target, args);
        System.out.println("JDK代理提交");
        return invoke;
    }
}

可以直接实现InvocationHandler
然后重写invoke方法。
我们理解以下InvocatioinHandler，官方是这么定义的：是由代理实例的调用处理程序实现的接口，每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用被编码并分派到处理程序的Invoke方法
这句话的意思呢我个人理解是，我们在调用方法的时候，其实Jdk底层是通过Invoke机制进行调用的，并不是我们在程序中写的类.方法直接调用。然而我们在实现动态代理的时候可以重写这个Invoke方法，这样就能满足我们自定义的横切了。
而且这个必须是要有接口的，因为在底层实现的话需要用到接口来实现实例。

cglib动态代理

TeacherDao

public class TeacherDao {
    public void teach() {
        System.out.println("老师授课中。。。cglib代理不用实现接口");
    }
}

ProxyFactory

public class ProxyFactory implements MethodInterceptor {
    //维护一个目标对象，object
    private final Object target;

    //对target进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象生成一个代理对象
    public Object getProxyInstance() {
        //创建一个工具类
        Enhancer enhancer = new Enhancer();
        // ***设置父类，根据传入的目标生成——动态
        enhancer.setSuperclass(target.getClass());
        // 设置回调函数
        enhancer.setCallback(this);
        // 创建子类对象
        return enhancer.create();
    }

    //重写拦截方法
    //会调用目标对象的方法
    @Override
    public Object intercept(Object o, Method method, Object[] args,
                            MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib代理模式~~开始");
        Object invoke = method.invoke(target, args);
        System.out.println("Cjlib代理模式~~提交");
        return invoke;
    }
}

Client

public class Client3 {
    //相当于通过被代理对象创建一个和被代理对象同样的对象，用这个对象去做方法的扩展
    public static void main(String[] args) {
        //创建目标对象
        TeacherDao teacherDao = new TeacherDao();
        //用目标对象获取代理对象，目标对象起一个类型约束的作用
        //并将目标对象传递给代理对象，绕过目标类生成一个目标对象，对此目标对象进行扩展
        TeacherDao proxyInstance =
                (TeacherDao) new ProxyFactory(teacherDao).getProxyInstance();
        //执行代理对象的方法，触发intecept方法，从而实现对目标对象的调用
        proxyInstance.teach();
    }
}

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢？这就需要CGlib了，CGlib采用了非常底层的字节码技术，其原理时通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用。
cglib其实是实现了拦截器（MethodIntercepter），然后重写了拦截的方法，当调用方法的时候会走拦截器。

jdk和cglib的区别

1、实现方式不一样：jdk采用的是InvocationHandler、Proxy的方式实现。cglib采用的是MethodInterceptor 的方式实现。
2、生成的字节码不一样：JDK动态代理只能对实现了接口的类生成代理，而不能针对类。CGLB是针对类实现代理。
3、性能不一样：在1.6和1.7JDK动态代理的速度要比CGLib动态代理的速度要慢。在JDK1.8的时候，JDK动态代理的速度已经比CGLib动态代理的速度快很多了，但是JDK动态代理和CGLib动态代理的使用场景不一样。