代理设计模式（三）

前言

代理模式是Java常见的设计模式之一。所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。
为什么要采用这种间接的形式来调用对象呢？一般是因为客户端不想直接访问实际的对象，或者访问实际的对象存在困难，因此通过一个代理对象来完成间接的访问。
在现实生活中，这种情形非常的常见，比如请一个律师代理来打官司。
下面例子的代码可以访问源码。欢迎star,欢迎fork

代理模式的UML图

从UML图中，可以看出代理类与真正实现的类都是继承了抽象的主题类，这样的好处在于代理类可以与实际的类有相同的方法，可以保证客户端使用的透明性。

代理模式的实现

代理模式可以有两种实现的方式，一种是静态代理类，另一种是各大框架都喜欢的动态代理。例如Spring框架的底层就是用的动态代理。下面我们主要讲解一下这两种代理模式.

静态代理

我们先看针对上面UML实现的例子，再看静态代理的特点。
Subject接口的实现

public interface Subject {
    void visit();
}

实现了Subject接口的两个类：

public class RealSubject implements Subject {

    private String name = "byhieg";
    @Override
    public void visit() {
        System.out.println(name);
    }
}

public class ProxySubject implements Subject{

    private Subject subject;

    public ProxySubject(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void visit() {
        subject.visit();
    }
}

具体的调用如下：

public class Client {

    public static void main(String[] args) {
        ProxySubject subject = new ProxySubject(new RealSubject());
        subject.visit();
    }
}

通过上面的代理代码，我们可以看出代理模式的特点，代理类接受一个Subject接口的对象，任何实现该接口的对象，都可以通过代理类进行代理，增加了通用性。但是也有缺点，每一个代理类都必须实现一遍委托类（也就是realsubject）的接口，如果接口增加方法，则代理类也必须跟着修改。其次，代理类每一个接口对象对应一个委托对象，如果委托对象非常多，则静态代理类就非常臃肿，难以胜任。

组成：

1.1      抽象对象 ： 接口或者是父类

1.2      被代理对象： 被隐藏起来的对象

1.3      代理对象： 暴露在外，向外提供的对象

1.4      调用者： 调用代理对象

好处：

1.1将被代理对象隐藏，保护隐私，从代码层面说，隐藏那些不必或者不应该暴露在外的类和代码。

1.2 扩展了原有的功能的。

1.3 使得被代理对象更加专注地完成自己的工作。

坏处：

如果被代理对象过多（比如要求被代理的客户多，案子多），那么就需要构筑大量的代码进行逻辑判断，这无形中增加了代码的冗余度。

动态代理

为了解决静态代理的缺点，可以采用动态代理。

（1）动态代理相对于静态代理带来的改变： 解决静态代理如果被代理类过多造成的冗余代码问题。

（2）动态代理的原理：底层是通过反射的方式完成被代理对象方法的执行。

（3）在调用者类中，调用Proxy对象的静态方法newProxyInstance（xx,xx,xx）。

（4）代理类（ZhongJie）实现了InvocationHandler接口，目的是实现invoke方法。

 Invoke 方法的三个参数：

 Proxy  为抽象对象生成的临时代理对象

Method： reflect包下的Method的对象，要通过反射执行某个类的方法

Args： 该方法的参数

动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理是实现方式，是通过反射来实现的，借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成。
其步骤如下：

1. 编写一个委托类的接口，即静态代理的（Subject接口）
2. 实现一个真正的委托类，即静态代理的（RealSubject类）
3. 创建一个动态代理类，实现InvocationHandler接口，并重写该invoke方法
4. 在测试类中，生成动态代理的对象。

第一二步骤，和静态代理一样，不多说了。第三步，代码如下：

public class DynamicProxy implements InvocationHandler {
    private Object object;
    public DynamicProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(object, args);
        return result;
    }
}

第四步，创建动态代理的对象

Subject realSubject = new RealSubject();
DynamicProxy proxy = new DynamicProxy(realSubject);
ClassLoader classLoader = realSubject.getClass().getClassLoader();
Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new  Class[]{Subject.class}, proxy);
subject.visit();

创建动态代理的对象，需要借助Proxy.newProxyInstance。该方法的三个参数分别是：

• ClassLoader loader定义代理类的类加载器，表示当前使用到的appClassloader。
• Class<?>[] interfaces代理类要实现的接口列表 （就是你要完成的业务功能—打官司）。表示目标对象实现的一组接口。
• InvocationHandler h指派方法调用的调用处理程序 （谁是代理-律师）；表示当前的InvocationHandler实现实例对象。

关于动态代理的使用，我们就介绍到这里。关于动态代理的实现、借助非JDK库实现动态代理、以及他们的优缺点放到以后再介绍。

（5）动态代理带来的好处：

1.1      扩展性增加：

1.2      解决了被代理对象过多造成冗余代码的问题

1.3      解耦性提高： 作为代理类的结构代码无需进行返回修改，只要根据调用者提供的代理对象及被代理对象灵活分配（底层应用了反射技术实现）

参看链接：https://www.cnblogs.com/qifengshi/p/6566752.html