【设计模式-AOP】动态代理-jdk、cglib

x33g5p2x  于2021-08-19 转载在 Java  
字(5.2k)|赞(0)|评价(0)|浏览(178)

前言

最近在学习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动态代理的使用场景不一样。

相关文章

最新文章

更多