Java 设计模式之代理模式（Proxy）

客官°小女子只卖身不卖艺 2022-04-23 22:16 149阅读 0赞

**目录**

代理模式（Proxy）

静态代理

JDK 动态代理

CgLib VS jdk 动态代理

--------------------

# 代理模式（Proxy） #

1、每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如租房子的时候会去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。

2、再如打官司，需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。

3、代理模式主要分为静态代理模式和动态代理模式。

4、代理模式的应用场景：如果已有的方法需要进行改进，可以采用一个代理类调用原有的方法，且对产生的结果进行控制。使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

# 静态代理 #

1、静态代理的优点是：

<table> 
 <tbody> 
  <tr> 
   <td> <p>1）可以将不同的业务关联统一处理。比如一个砍柴的原本不会钓鱼而没有鱼吃，但是通过代理，可以将砍柴的与另外一个会钓鱼的关联到一起，于是砍柴的也有鱼吃了。</p> <p>2）静态代理模式使用简单。</p> </td> 
  </tr> 
 </tbody> 
</table>

2、静态代理的缺点是：

<table> 
 <tbody> 
  <tr> 
   <td> <p>1）假如需要为 service 层每个实现类中的查询方法加上访问统计的功能，即每调用一次，则访问量加1，则系统中有多少 service 实现类，就得写多少个 service 的 proxy(代理)，代理类太多。</p> <p>2）一旦接口增加方法，则目标对象与代理对象都需要进行维护.。</p> <p>这些缺点都可以使用动态代理来进行处理掉。</p> </td> 
  </tr> 
 </tbody> 
</table>

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdteDE5OTMzMjg_size_16_color_FFFFFF_t_70][]

3、实现代码如下：

package com.lct.staticProxy;
    
    public interface UserService {
        //根据id查询用户姓名
        public String findUserNameById(int id);
    }

相当于图中的 Sourceable

import java.util.Random;
    import java.util.UUID;
    import java.util.logging.Logger;
    public class UserServiceImpl implements UserService {
        //根据id查询用户姓名
        public String findUserNameById(int id) {
            Logger logger = Logger.getAnonymousLogger();
            logger.info("查询用户 id = " + id);
            try {
                Thread.sleep(new Random().nextInt(1000));//故意延迟，模拟在请求数据库
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return UUID.randomUUID().toString();
        }
    }

相当于图中的 Suorce。

假设现在想要在上面的基础上不改变源码，而要为每个 service 层实现类的查询方法加上统计功能，为 增删改方法手段加上事务控制或者日志，则可以选择使用代理模式。也可以使用装饰器模式。

4、假设下面为需要新增的业务：

import java.util.Date;
    import java.util.logging.Logger;
    //统计帮助类——也就是被代理类需要控制的新业务（功能）
    public class CensusHelper {
        //统计方法被请求次数———只做简单的日志打印，不保存数据
        public static final void requestCount() {
            Logger logger = Logger.getAnonymousLogger();
            logger.info("请求次数 + 1");
        }
    
        //统计数据库请求耗时———只做简单的日志打印，不保存数据
        public static final void requestTime(Date statTime, Date endTime) {
            Logger logger = Logger.getAnonymousLogger();
            logger.info("本次请求耗时：" + (endTime.getTime() - statTime.getTime()) + " 毫秒.");
        }
    }

5、创建代理类进行代理原对象：

import java.util.Date;
    public class UserServiceProxy implements UserService {
        private UserService userService;
        public UserServiceProxy() {
            //装饰器模式时，成员变量的值是通过构造器参数传入的
            //静态代理时侧重的是隐藏原对象，所以写死在构造器中
            userService = new UserServiceImpl();
        }
    
        @Override
        public String findUserNameById(int id) {
            Date startTime = new Date();
            CensusHelper.requestCount();//在正式执行目标方法前进行控制
            String name = userService.findUserNameById(id);
            CensusHelper.requestTime(startTime, new Date());//在执行目标方法后进行控制
            return name;
        }
    }

由此可见，如果有几十个甚至上百个 service 层的实现都需要加统计功能，则也需要添加同等个数的代理类，这显然会有点让人抗拒，这时应该首选动态代理，一个动态代理即可代理它们所有。

6、测试如下：

import com.lct.staticProxy.UserService;
    import com.lct.staticProxy.UserServiceProxy;
    import java.util.Random;
    import java.util.logging.Logger;
    public class Test {
        public static void main(String[] args) {
            UserService userService = new UserServiceProxy();
            String name = userService.findUserNameById(new Random().nextInt(10000));
            Logger logger = Logger.getAnonymousLogger();
            logger.info("查询结果 name=" + name);
        }
    }

![20190409220851562.gif][]

《[装饰器模式 VS 静态代理模式][VS]》

# JDK 动态代理 #

1、动态代理也叫 JDK 代理，或接口代理

2、动态代理是一种常用的设计模式，其目的是为其他对象提供一个代理，以控制对某个真实对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

3、通过代理层这一中间层，有效的控制对于真实委托类对象的直接访问，同时可以实现自定义的控制策略（[spring][]的AOP机制），设计上获得更大的灵活性。

4、Spring 主要有两大思想，一个是 IOC(依赖注入)，另一个就是 AOP（面向切面编程），AOP 的原理就是 动态代理机制

5、Java 动态代理机制，有一个重要的接口 java.lang.reflect.InvocationHandler，以及另一个重要的类 java.lang.reflect.Proxy.

6、动态代理顾名思义也知道它相比静态代理会更加灵活，代码量大大减少。只需要修改代理类以及调用代理类的方式即可，接口与其实现类和静态代理是一致的。

7、下面使用代码来实现，其余代码不变，修改代理类 UserServiceProxy  为 ServiceDynamicProxy 如下：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.util.Date;
    import java.util.logging.Logger;
    /**
     * service 层动态代理
     * 动态代理第一步：实现 java.lang.reflect.InvocationHandler 接口，实现 invoke 方法
     * invoke：乞灵，祈求; 提出或授引…以支持或证明; 召鬼;借助
     */
    public class ServiceDynamicProxy implements InvocationHandler {
        //第二步：目标对象作为成员变量，即代理的真实对象，通过构造器传入值
        private Object targetObject;
    
        public ServiceDynamicProxy(Object targetObject) {
            this.targetObject = targetObject;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Date startTime = new Date();
            Logger logger = Logger.getAnonymousLogger();
            logger.info("用户准备调用方法(程序可以根据方法名执行不同的操作)：" + method);
            CensusHelper.requestCount();//执行真实对象目标方法前进行的操作，如日志记录、权限判断、事务等等
            /**
             * java.lang.reflect.Method#invoke(java.lang.Object, java.lang.Object...)：代理对象调用真实对象的方法，这里使用的反射
             * 返回的 Object 是真实对象方法的返回值
             * 代理类中的核心代码其实就是下面这一句：即代理对象通过反射调用真实对象的方法
             */
            Object result = method.invoke(targetObject, args);
            CensusHelper.requestTime(startTime, new Date());执行真实对象目标方法后进行的操作
            return result;
        }
    }

由此可见：对于同一功能，即使是成千上百个需要控制的 service 层实现，也只需要一个动态代理类。

8、测试代码如下：

import main.dynamicProxy.ServiceDynamicProxy;
    import main.dynamicProxy.UserService;
    import main.dynamicProxy.UserServiceImpl;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    import java.util.Random;
    import java.util.logging.Logger;
    
    /**
     * Created by Administrator on 2019/4/8 0008.
     */
    public class Test {
        public static void main(String[] args) {
            UserService userService = new UserServiceImpl();//被代理的真实对象
    
            //将真实对象通过代理对象构造器传入
            InvocationHandler handler = new ServiceDynamicProxy(userService);
            /**
             * userService 是真实对象，userServiceProxy 是其代理对象
             * newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
             * 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
             * loader - 定义代理类的类加载器
             * interfaces - 代理类要实现的接口列表
             * h - 指派方法调用的调用处理程序，即代理类、
             * 核心代码也就是下面一句：根据实际对象创建代理对象
             */
            UserService userServiceProxy = (UserService) Proxy.newProxyInstance(
                    handler.getClass().getClassLoader(),
                    userService.getClass().getInterfaces(),
                    handler
            );
            Logger logger = Logger.getAnonymousLogger();
            logger.info("代理对象名称：" + userServiceProxy.getClass().getName());//形如：com.sun.proxy.$Proxy0
    
            Object result = userServiceProxy.findUserNameById(new Random().nextInt(10000));
            logger.info("查询结果：" + result);
        }
    }

![20190410090743507.gif][]

# CgLib VS jdk 动态代理 #

1、java 中通过实现 InvocationHandler 接口来实现动态代理，然后使用 Proxy 将其初始化。

2、Cglib 使用了 ASM 字节码生成框架，可以代理普通类，但代理不了 final 类，而 jdk 动态代理只能代理接口。

3、Spring 默认使用 cglib 动态代理。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdteDE5OTMzMjg_size_16_color_FFFFFF_t_70]: /images/20220222/7fab6351823c41babd8defce08ea98f2.png
[20190409220851562.gif]: /images/20220222/ad094ce4a2a54c759bb2050eb1240c73.png
[VS]: https://blog.csdn.net/wangmx1993328/article/details/89153991#%E8%A3%85%E9%A5%B0%E5%99%A8%E6%A8%A1%E5%BC%8F%20VS%20%E9%9D%99%E6%80%81%E4%BB%A3%E7%90%86%E6%A8%A1%E5%BC%8F
[spring]: http://lib.csdn.net/base/javaee
[20190410090743507.gif]: /images/20220222/caafa551b17f49418bb7f0ce0761fecb.png