静态代理、JDK动态代理、CGLIB动态代理以及JDK和CGLIB动态代理的区别

发布时间:2024年01月03日

什么是代理?

代理模式在 Java 开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功能,插入的功能对于调用者是透明的,起到伪装控制的作用。如租房的例子: 房客、中介、房东。对应于代理模式中即:客户类、代理类 、委托类 (被代理类)
为某一个对象(委托类)提供一个代理 (代理类),用来控制对这个对象的访问。委托类和代理类有个共同的父类或父接口。代理类会对请求做预处理、过滤,将请求分配给指定对象。

两个设计原则

  • 代理类与委托类有共同的行为
  • 代理类能够增强委托类的行为

三要素

  1. 共同的行为-定义接口
  2. 目标对象/真实角色-实现接口
  3. 代理对象-实现接口 增强用户行为

静态代理

某个对象提供一个代理,代理角色固定,以控制对这个对象的访问。代理类和委托类有共同的父类或父接口,这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

静态代理的实现

定义接口-定义行为

public interface Marry {
    public void toMarry();
}

静态代理 -> 目标角色

实现行为

public class You implements Marry {
    @Override
    public void toMarry() {
        System.out.println("你要结婚了...");
    }
}

静态代理-> 代理角色

1.实现行为
2.增强用户行为

public class MarryCompanyProxy implements Marry{
    //目标对象
    private Marry target;//多态

    //通过带参构造器传递目标对象
    public MarryCompanyProxy(Marry target) {
        this.target = target;
    }

    //实现行为
    @Override
    public void toMarry() {
        //用户行为增强
        before();

        //调用目标对象中的方法
        target.toMarry();

        //用户行为增强
        after();
    }

    /**
     * 用户行为增强
     */
    private void after() {
        System.out.println("新婚快乐...");
    }

    private void before() {
        System.out.println("婚礼现场正在布置...");
    }
}

静态代理测试

public class StaticProxy {

    public static void main(String[] args) {
        //目标对象
        You you = new You();
        //代理对象
        MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(you);
        //通过代理对象调用目标对象中的方法
        marryCompanyProxy.toMarry();
    }
}

在这里插入图片描述
静态代理对于代理的角色是固定的,如dao层有20个dao类,如果要对方法的访问权限进行代理,此时需要创建20个静态代理角色,引起类爆炸,无法满足生产上的需要,于是就催生了动态代理的思想。

特点

  1. 目标对象固定
  2. 在程序运行前已经得到目标对象
  3. 代理对象对目标对象进行增强
  4. 有可能存在多个代理,产生"类爆炸"(缺点)

JDK动态代理

JDK动态代理的目标对象必须有接口实现
可以根据需要,通过反射机制在程序运行期,动态的为目标对象创建代理对象

newProxyInstance

Proxy类是专门完成代理的操作类,可以通过此类为一个或多个接口动态地生成实现类,此类提供了如下操作方法:

/*
 Loader:类加载器
 interfaces:接口数组
     target.getClass().getInterfaces():目标对象的接口数组
 h:InvocationHandler接口(传入InvocationHandler接口的实现类)*/
 
 public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces
                                      InvocationHandler h)

获取代理对象

/**
 * JDK动态代理类
 *      每一个代理类都需要实现InvocationHandler接口
 */
public class JdkHandler implements InvocationHandler {



    //目标对象
    private Object target;//类型不固定,创建时动态生成
    //通过带参构造器传递目标对象


    public JdkHandler(Object target) {
        this.target = target;
    }

    /**
     * 1.调用目标对象的方法(返回object)
     * 2.增强目标对象的行为
     *
     * @param proxy 调用该方法的代理实例
     * @param method 目标对象的方法
     * @param args 目标对象的方法所需要的参数
     * @return
     * @throws Throwable
     */

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //前后都可能会有增强行为,不一定都要有,只是可能会有
        //用户的增强行为
        System.out.println("============方法执行前");


        // 调用目标对象中的方法(返回object)
        Object object=method.invoke(target,args);


        //用户的增强行为
        System.out.println("方法执行后============");

        return object;//调用方法中返回的值
    }
    /**
     * 获取代理对象
     * public static Object newProxyInstance(ClassLoader loader,
     *                                       Class<?>[] interfaces,
     *                                       InvocationHandler h)
     *  Loader:类加载器
     *  interfaces:接口数组
     *      target.getClass().getInterfaces():目标对象的接口数组
     *  h:InvocationHandler接口(传入InvocationHandler接口的实现类)
     * @return
     */
    public Object getProxy(){
        Object object= Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                                target.getClass().getInterfaces(),
                                                this);
        return object;
    }
}

通过代理对象实现目标对象的功能

public class JdkHandlerTest {
    public static void main(String[] args) {
        //目标对象
        You you = new You();
        //得到代理类
        JdkHandler jdkHandler = new JdkHandler(you);
        //得到代理对象
        Marry marry = (Marry) jdkHandler.getProxy();
        //通过代理对象调用目标对象的方法
        marry.toMarry();
    }
}

特点

1.目标对象不固定
2.在程序运行时,动态创建目标对象
3.代理对象会增强目标对象的行为

Java动态代理类中的invoke是怎么调用的?

在生成的动态代理类$Proxy9.class中,构造方法调用了父类Proxy.class的构造方法,给成员变量invocationHandler赋值,$Proxy9.classstatic模块中创建了被代理类的方法,调用相应方法时方法体中调用了父类中的成员变量InvocationHandlerinvoke()方法。

CGLIB动态代理

JDK的动态代理机制只能代理实现了接口的类,而不能实现接口的类就不能使用JDK的动态代理,cglib是针对类来实现代理的,它的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类进行代理。
代理类继承目标类,重写目标类中的方法
在这里插入图片描述

添加依赖

在pom.xml文件中引入cglib的相关依赖,可以上maven官网下载,也可以复制下面的依赖

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
public class CglibInterceptor implements MethodInte

定义类实现MethodInterceptor接口

public class CglibInterceptor implements MethodInterceptor {

    //目标对象
    private Object target;
    //通过构造器传入目标对象

    public CglibInterceptor(Object target) {
        this.target = target;
    }

    /**
     * 获取代理对象
     * @return
     */
    public Object getProxy(){
        //通过Enhancer对象中的create()方法生成一个类,用于生产代理对象
        Enhancer enhancer = new Enhancer();
        //设置父类(将目标类作为代理类的父类)
        enhancer.setSuperclass(target.getClass());
        //CglibInterceptor implements MethodInterceptor extends Callback
        //设置拦截器(回调对象为本身对象)
        enhancer.setCallback(this);
        //生成代理类对象,并返回给调用者
        return enhancer.create();
    }

    /**
     * 拦截器
     * 1.目标对象的方法调用
     * 2.行为增强
     * @param o cglib动态生成的代理类的实例
     * @param method 实体类所调用的都被代理的方法的引用
     * @param objects 参数列表
     * @param methodProxy 生成的代理类对方法的代理引用
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        //用户的增强行为
        System.out.println("============方法执行前");

        //调用目标类中的方法
        Object object=methodProxy.invoke(target,objects);

        //用户的增强行为
        System.out.println("方法执行后============");

        return null;
    }
}

调用方法进行测试

public class CglibInterceptorTest {
public static void main(String[] args) {
//得到目标对象
You you = new You();
//得到拦截器
CglibInterceptor cglibInterceptor = new CglibInterceptor(you);
//得到代理对象
Marry marry= (Marry) cglibInterceptor.getProxy();
//通过代理对象调用目标对象中的方法
marry.toMarry();
}
}
在这里插入图片描述
使用的还是一开始静态代理写的方法

JDK和CGLIB动态代理的区别是什么?

  • JDK动态代理实现接口,Cglib动态代理继承思想
  • JDK动态代理 (目标对象存在接口时) 执行效率高于Ciglib
  • 如果目标对象有接口实现,选择JDK代理,如果没有接口实现选择Cglib代理

基于CGLIB动态代理的实现代码实现一下没有接口实现的类分别是怎样的结果

先写一个没有接口实现的类User

public class User {
    public void test(){
        System.out.println("cglib动态代理...");
    }
}

通过Cglib动态代理实现:没有接口实现的类

        User user = new User();
        CglibInterceptor cglibInterceptor02 = new CglibInterceptor(user);
        User u = (User) cglibInterceptor02.getProxy();
        u.test();

实现结果
在这里插入图片描述

通过JDK动态代理实现:没有接口实现的类

User user = new User();
        JdkHandler jdkHandler = new JdkHandler(user);
        User u= (User) jdkHandler.getProxy();
        u.test();

实现结果
在这里插入图片描述

文章来源:https://blog.csdn.net/qq_52879387/article/details/135367254
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。