【Java】代理模式

发表于2021-04-25更新于2022-02-25字数统计2.7k阅读时长17分阅读次数

代理模式简介

https://segmentfault.com/a/1190000011291179

代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。

代理模式UML类图

代理模式UML类图

其实很多动态代理场景，我认为也可以看作是装饰器（Decorator）模式的应用。通过代理可以让调用者与实现者之间解耦。比如进行 RPC 调用，框架内部的寻址、序列化、反序列化等，对于调用者往往是没有太大意义的，通过代理，可以提供更加友善的界面。

静态代理

这种代理方式需要手动创建代理对象，并且该代理对象和目标对象必须实现一样的接口。

优点：可以在不修改目标对象的前提下扩展目标对象的功能。

缺点：

  1. 冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
  2. 不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。

示例：

  • 接口类： IUserDao
1
2
3
4
5
package com.proxy;

public interface IUserDao {
    public void save();
}
  • 目标对象：UserDao
1
2
3
4
5
6
7
8
9
package com.proxy;

public class UserDao implements IUserDao{

    @Override
    public void save() {
        System.out.println("保存数据");
    }
}
  • 静态代理对象：UserDapProxy 需要实现IUserDao接口！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.proxy;

public class UserDaoProxy implements IUserDao{

    private IUserDao target;
    public UserDaoProxy(IUserDao target) {
        this.target = target;
    }
    
    @Override
    public void save() {
        System.out.println("开启事务");//扩展了额外功能
        target.save();
        System.out.println("提交事务");
    }
}
  • 测试类：TestProxy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.proxy;

import org.junit.Test;

public class StaticUserProxy {
    @Test
    public void testStaticProxy(){
        //目标对象
        IUserDao target = new UserDao();
        //代理对象
        UserDaoProxy proxy = new UserDaoProxy(target);
        proxy.save();
    }
}

JDK 动态代理

JDK 动态代理本质上是使用反射机制，通过获取被代理对象的方法信息来动态执行目标方法：method.invoke(obj, args)

动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。

静态代理与动态代理的区别主要在：

  • 静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
  • 动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中

特点：动态代理对象不需要实现接口，但是要求目标对象必须实现接口（需要从该接口中获取到目标方法的元信息 Method，从而调用目标方法），否则不能使用动态代理。

JDK中生成代理对象主要涉及的类有：

1
2
3
4
5
static Object newProxyInstance(ClassLoader loader,  //指定当前目标对象使用类加载器
                               Class<?>[] interfaces,    //目标对象实现的接口的类型
                               InvocationHandler h      //事件处理器
                              ) 
    //返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
1
2
// 在代理实例上处理方法调用并返回结果。
Object invoke(Object proxy, Method method, Object[] args)

示例：

1）使用 JDK 动态代理，使用 Proxy类里面的方法创建代理对象：

调用 newProxyInstance 方法，方法有三个参数：

1
2
3
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
  • 参数一：类加载器
  • 参数二：增强方法所在的类，这个类实现的接口，支持多个接口
  • 参数三：实现这个接口 InvocationHandler，创建代理对象，写增强的部分

2）编写 JDK 动态代理代码

1
2
3
4
5
//（1）创建接口，定义方法
public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}
1
2
3
4
5
6
7
8
9
10
11
//（2）创建接口实现类，实现方法
public class UserDaoImpl implements UserDao {
    @Override
    public int add(int a, int b) {
        return a+b;
    }
    @Override
    public String update(String id) {
        return id;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//（3）使用 Proxy 类创建接口代理对象
public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl(); 
        
        /** 为目标对象生成代理对象
        第一参数，类加载器 
        第二参数，增强方法所在的类，这个类实现的接口，(支持多个接口)
        第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分  */
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,
                                                     new UserDaoProxy(userDao));
        int result = dao.add(1, 2);
        System.out.println("result:"+result);
    }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler {
    //1 维护一个目标对象，把创建的是谁的代理对象，把谁传递过来
    //有参数构造传递
    private Object obj;
    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }

    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前
        System.out.println("方法之前执行...."+method.getName()+" :传递的参数..."+ Arrays.toString(args));
        //被增强的方法执行
        Object res = method.invoke(obj, args);
        //方法之后
        System.out.println("方法之后执行...."+obj);
        return res;
    }
}

CGLIB 动态代理

CGLIB is a powerful, high performance and quality Code Generation Library. It can extend JAVA classes and implement interfaces at runtime.

CGLIB（Code Generation Library）是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

cglib 动态代理采取的是创建目标类的子类（继承）的方式，因为是子类化，我们可以达到近似使用被调用者本身的效果。在 Spring 编程中，框架通常会处理这种情况。

cglib特点

  • JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。
  • CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
  • CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。

CGLIB与JDK动态代理最大的区别就是：

  • 使用JDK动态代理的对象必须实现一个或多个接口
  • 使用CGLIB代理的对象则无需实现接口，达到代理类无侵入（本质上是继承了被代理类）

使用CGLIB需要引入cglib的jar包，如果你已经有spring-core的jar包，则无需引入，因为Spring中包含了CGLIB。

  • CGLIB的Maven坐标
1
2
3
4
5
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.5</version>
</dependency>

举例：保存用户功能的动态代理实现

  • 目标对象：UserDao
1
2
3
4
5
6
7
8
package com.cglib;

public class UserDao{

    public void save() {
        System.out.println("保存数据");
    }
}
  • 代理对象：ProxyFactory
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyFactory implements MethodInterceptor{

    private Object target;//维护一个目标对象
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //为目标对象生成代理对象
    public Object getProxyInstance() {
        //工具类
        Enhancer en = new Enhancer();
        //设置父类
        en.setSuperclass(target.getClass());
        //设置回调函数
        en.setCallback(this);
        //创建子类对象代理
        return en.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开启事务");
        // 执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("关闭事务");
        return null;
    }
}
  • 测试类：TestProxy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.cglib;

import org.junit.Test;

public class TestProxy {

    @Test
    public void testCglibProxy(){
        //目标对象
        UserDao target = new UserDao();
        System.out.println(target.getClass());
        //代理对象
        UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
        System.out.println(proxy.getClass());
        //执行代理对象方法
        proxy.save();
    }
}
  • 输出结果
1
2
3
4
5
class com.cglib.UserDao
class com.cglib.UserDao$$EnhancerByCGLIB$$552188b6
开启事务
保存数据
关闭事务

总结

  1. 静态代理实现较简单，只要代理对象对目标对象进行包装，即可实现增强功能，但每一个代理类只能代理一个被代理类，无法做到复用，如果目标对象过多，则会产生很多代理类
  2. JDK动态代理需要目标对象实现业务接口，代理类只需实现InvocationHandler接口
  3. 动态代理生成的类为 class com.sun.proxy.\$Proxy4，cglib代理生成的类为class com.cglib.UserDao\$\$EnhancerByCGLIB\$\$552188b6。
  4. 静态代理在编译时产生class字节码文件，可以直接使用，效率高
  5. JDK动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。一个代理类可以复用，代理多个不同的被代理类，不需要为每一个被代理类创建单独的代理类
  6. CGLIB代理无需实现接口（本质上是继承自被代理类），通过生成类字节码实现代理（根据目标类的字节码生成其代理子类），比反射稍快，不存在性能问题，但CGLIB会继承目标对象，需要重写方法，所以目标对象不能为final类

应用

其实很多动态代理场景，也可以看作是装饰器（Decorator）模式的应用

  • 静态代理：Thread 和 Runnable（Runnable 是接口，Thread 是代理类）
  • 动态代理：
    • AOP 机制：Spring AOP 使用动态代理为需要增强的组件创建动态对象组件，切入相应的通知方法
    • RPC 调用：Spring Cloud OpenFeign 使用动态代理为 @FeignClient 标注的接口生成实现类代理对象，在其中进行负载均衡并调用其他服务
    • MyBatis 中 sqlSession 返回的每个 mapper 对象都是一个代理对象

反射技术常用在各类通用框架开发中。因为为了保证框架的通用性，需要根据配置文件加载不同的对象或类，并调用不同的方法，这个时候就会用到反射——运行时动态加载需要加载的对象。