代码段学习设计模式 -- 代理模式

最新推荐文章于 2024-07-17 14:19:40 发布

玛斯特・布兰迪

最新推荐文章于 2024-07-17 14:19:40 发布

阅读量169

点赞数

分类专栏：设计模式使用与思考文章标签：设计模式 Java 代理模式动态代理静态代理

本文链接：https://blog.csdn.net/Strange_Monkey/article/details/80607097

版权

设计模式使用与思考专栏收录该内容

6 篇文章 0 订阅

订阅专栏

也被称为委托模式，代理模式为其他对象提供一种代理以控制对这个对象的访问。

1、组成及优点

1.1 组成

**抽象角色：**通过接口或抽象类声明真实角色实现的业务方法。
**代理角色：**实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
**真实角色：**实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

1.2 优点

职责清晰：真实角色就是实现实际的业务逻辑，不用关心其他非本职工作的事务，通过后期代理完成非本职工作。
高扩展性：具体主题角色可以随时发生变化，只要它实现了接口，而不用关心它如何变化，只要接口没变，代理类可以在完全不做修改的情况下使用。
智能化：通过动态代理的方式实现在编码阶段不需要知道代理的对象。
扩展原功能，不侵入原代码。
普通代理模式，在该模式下调用者只知道代理而不用知道真实角色，屏蔽了真实角色的变更对高层模块的影响，在实际项目中，一般都是通过约定来禁止new一个真实的角色。

1.3 缺点

代理类必须实现接口，导致代理类太多；
一旦接口发生变更，代理类也必须同步更新，导致维护成本会比较高；

2、静态代理

1.1 情景模拟

秉承着通过代码段学习设计模式的的宗旨，我们通过生活中一个常见的情景作为一个栗子：小明同学通过代码的方式从国外购买一台 Mac
以下为根据此情况设计的 UML 图：
UML图

1.2 具体代码

1.2.1 定义的接口

/**
 * Time: 2018/6/6  17:45
 * 定义目标对象的接口方法
 * 抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
 */
public interface Subject {
    public  void buybuybuy();
}

1.2.2 目标类(被代理类）

/**
 * Time: 2018/6/6  17:45
 * 小明，真正的想买Mac的对象 = 目标对象 = 被代理的对象 = 委托类
 * 实现抽象目标对象的接口
 * 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调* 用。
 */

public class XiaoMing implements Subject {
    private static final String TAG = "_XiaoMing";

    @Override
    public void buybuybuy() {
        Log.e(TAG, "buybuybuy: 小明要买Mac");
    }
}

1.2.3 代理类

/**                                                           
 * Time: 2018/6/7 0007 10:58                                  
 * 真正进行操作的对象 代理对象   
 * 代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法* 来实现抽象方法，并可以附加自己的操作。                            */                                                           
public class ForginerBuyer implements Subject {               
    private static final String TAG = "_ForginerBuyer";       
    private Subject mSubject;                                 
                                                              
    public ForginerBuyer(Subject mSubject) {                  
        this.mSubject = mSubject;                             
    }                                                         
                                                              
    @Override                                                 
    public void buybuybuy() {                                 
        Log.e(TAG, "buybuybuy: 代购开始购买");                      
        mSubject.buybuybuy();                                 
        Log.e(TAG, "buybuybuy: 代购结束购买");                      
    }                                                         
}

1.2.4 客户端

public class BuyActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_buy);
        //创建 XiaoMing 实例对象
        Subject mXiaoMing = new XiaoMing();
        //创建 ForginerBuyer 代购对象，并把 XiaoMing 实例对象传入
        Subject mBuyer = new ForginerBuyer(mXiaoMing);
        mBuyer.buybuybuy();
       
    }
}

1.2.5 执行结果

E/_ForginerBuyer: buybuybuy: 代购开始购买
E/_XiaoMing: buybuybuy: 小明要买Mac
E/_ForginerBuyer: buybuybuy: 代购结束购买

1.2.6 小结

通过以上代码，稍微思考一下其实在平时静态代理十分的常见，就是把真正的对象包装一下成为一个新的类，通过访问这个新的类我们就可以真正的对目标类对象进行操作。但是我们需要让代理类和目标类发生关系 – 把目标类对象传入代理类中。
但是难道我们在使用代理模式时必须要首先构建一个抽像对象吗？我个人觉得不是必须的。即使代理类和目标类没有共同的方法，只要把目标类的实例对象传入代理类中，在代理类中调用目标类的相应方法，那么也能够完成代理的最终目的。

3、动态代理

动态代理和静态代理的不同：在程序运行前，代理类不存在，而是在程序运行时通过反射机制生成。
由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。动态代理类：在程序运行时，运用反射机制动态创建而成。

还是通过上面小明海外代购一台 Mac 的栗子来说明动态代理的具体实现。

3.1 具体代码

3.1.1 定义接口

/**
 * Time: 2018/6/6  17:45
 * 定义目标对象的接口方法
 * 抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
 */
public interface Subject {
    public  void buybuybuy();
}

3.1.2 目标类

/**
 * Time: 2018/6/6  17:45
 * 小明，真正的想买Mac的对象 = 目标对象 = 被代理的对象 = 委托类
 * 实现抽象目标对象的接口
 * 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调* 用。
 */

public class XiaoMing implements Subject {
    private static final String TAG = "_XiaoMing";

    @Override
    public void buybuybuy() {
        Log.e(TAG, "buybuybuy: 小明要买Mac");
    }
}

3.1.3 声明调用处理器类

/** 作用
 * 1.  生成 动态代理对象
 * 2.  指定 代理对象运行目标对象方法时需要完成的 具体任务
 */
public class DynamicProxy implements InvocationHandler {
    private static final String TAG = "DynamicProxy";
    private Object ProxyObject;

    public Object newProxyInstance(Object ProxyObject){
        this.ProxyObject =ProxyObject;
        return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
                ProxyObject.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Log.e(TAG, "invoke: 代购出门了" );
        Object result = null;
        // 通过Java反射机制调用目标对象方法
        result = method.invoke(ProxyObject, args);
        return result;
    }
}

3.1.4 通过动态代理对象，调用目标对象的方法


public class Main2Activity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        // 1. 创建调用处理器类对象
        DynamicProxy DynamicProxy = new DynamicProxy();
        // 2. 创建目标对象对象
        XiaoMing mXiaoMing = new XiaoMing();
        // 3. 创建动态代理类 & 对象：通过调用处理器类对 newProxyInstance（）
        // 传入上述目标对象对象
        Subject mSubject = (Subject) DynamicProxy.newProxyInstance(mXiaoMing);
        // 4. 通过调用动态代理对象方法从而调用目标对象方法
        // 实际上是调用了invoke（），再通过invoke（）里的反射机制调用目标对象的方法
        mSubject.buybuybuy();
    }
}

注：以上代码参考 Carson_Ho的简书

3.1.5 执行结果

E/_DynamicProxy: invoke: 代购出门了
E/_XiaoMing: buybuybuy: 小明要买Mac

InvocationHandler 是一个接口，官方文档解释说，每个代理的实例都有一个与之关联的 InvocationHandler 实现类，如果代理的方法被调用，那么代理便会通知和转发给内部的 InvocationHandler 实现类，由它决定处理。

InvocationHandler 内部只是一个 invoke() 方法，正是这个方法决定了怎么样处理代理传递过来的方法调用，在这个方法中，我们可以实现自己的业务逻辑。

proxy 代理对象
method 代理对象调用的方法
args 调用的方法中的参数

因为，Proxy 动态产生的代理会调用 InvocationHandler 实现类，所以 InvocationHandler 是实际执行者。

3.2 代码解析

在静态代理模式中，代理类是通过我们我们自己编辑的，根据动态代理模式的特点：在程序运行期生成代理类，那么**动态代理类是怎么生成的呢？怎么通过调用动态代理类的实例来调用目标类的方法?**下面我们通过具体代码来说明这两个问题

3.2.1 生成代理类

很明显，在具体的调用中我们是通过以下代码生成代理类的：

Subject mSubject = (Subject) DynamicProxy.newProxyInstance(mXiaoMing);

跳转到具体代码**(终点关注标注（重要代码）的代码段)**

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        // Android-changed: sm is always null
        // final SecurityManager sm = System.getSecurityManager();
        // if (sm != null) {
        //     checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        // }

        /*
         * (重要代码)
         * Look up or generate the designated proxy class.
         * 查找或者生成代理类，正是在此处我们通过代码生成了代理类，
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            // }
            //(重要代码)
			//通过反射获得动态代理的构造器对象
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                // Android-changed: Removed AccessController.doPrivileged
                cons.setAccessible(true);
            }
            //(重要代码)
            //通过反射获得代理类的具体对象实例
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

但是具体是怎么生成动态代理类的呢，我们具体参考Class<?> cl = getProxyClass0(loader, intfs);

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        return proxyClassCache.get(loader, interfaces);
    }

proxyClassCache为 proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());我们需要关注的是 ProxyClassFactory

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

          ....
                Method[] methodsArray = methods.toArray(new Method[methods.size()]);
                Class<?>[][] exceptionsArray = exceptions.toArray(new Class<?>[exceptions.size()][]);

                /*
                 * Choose a name for the proxy class to generate.
                 */
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;

                return generateProxy(proxyName, interfaces, loader, methodsArray,
                                     exceptionsArray);
            }
        }

巴拉巴拉一大堆，我不想看这是什么鬼，反正最后来到了了
generateProxy(proxyName, interfaces, loader, methodsArray, exceptionsArray);,那我们来看一个generateProxy(...)

@FastNative
    private static native Class<?> generateProxy(String name, Class<?>[] interfaces,
                                                 ClassLoader loader, Method[] methods,
                                                 Class<?>[][] exceptions);

这是一个 Native方法，具体为生成代理类，我在网上查看一下资料时看到有些博客上可以调用相应的 api 生成具体的可以看到的代理类，但是我在具体的 demo 中不能进行此操作，故此代码跟踪完毕。

3.3 与静态代理相比的优点

当委托类特别多时，即在每个委托类都对应着一套规则（即每一个委托类都对应着一个抽象对象），那么相应的如果使用静态代理模式，那么就需要实现多个相应的代理类，这样代理类个数会比较多。但是如果使用动态代理模式，此时在生成 InvocationHandler相应的实例时传入不同的委托类实例对象，那么则可以实现同事代理多个委托类的功能。

DynamicProxy DynamicProxy = new DynamicProxy();
XiaoMing mXiaoMing = new XiaoMing();
Subject mSubject = (Subject) DynamicProxy.newProxyInstance(mXiaoMing);
mSubject.buybuybuy();
XiaoHong mXiaoHong= new XiaoHong();
Subject2 mSubject2 = (Subject2) DynamicProxy.newProxyInstance(mXiaoHong);
mSubject2 .buybuybuy2();

即在委托类比较多时，建议使用动态代理模式

优秀博客：
代理模式
 Java 动态代理
 动态代理相对于静态代理的优势
 代理模式（Proxy Pattern）：动态代理 - 最易懂的设计模式解析

玛斯特・布兰迪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码段学习设计模式 -- 代理模式

前言代码定义的接口/** * Time: 2018/6/6 17:45 * 定义目标对象的接口方法 * 抽象角色：通过接口或抽象类声明真实角色实现的业务方法。 */public interface Subject { public void buybuybuy();}委托类（目标类、被代理类）/** * Time: 2018/6/...
复制链接

扫一扫