Java设计模式——代理模式

介绍代理模式

代理模式的本质是一个中间件，主要目的是解耦合服务提供者和使用者。使用者通过代理间接的访问服务提供者，便于后者的封装和控制。是一种结构性模式。

代理模式和装饰模式非常类似，甚至代码都类似。二者最主要的区别是：代理模式中，代理类对被代理的对象有控制权，决定其执行或者不执行。而装饰模式中，装饰类对代理对象没有控制权，只能为其增加一层装饰，以加强被装饰对象的功能，仅此而已。

介绍
意图：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

何时使用：想在访问一个类时做一些控制。

如何解决：增加中间层。

关键代码：实现与被代理类组合。

应用实例： 1、Windows 里面的快捷方式。 2、猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠兰的外貌抽象出来，高翠兰本人和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，所以说孙悟空是高翠兰代理类。 3、买火车票不一定在火车站买，也可以去代售点。 4、一张支票或银行存单是账户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制。 5、spring aop。

优点： 1、职责清晰。 2、高扩展性。 3、智能化。

缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

使用场景：按职责来划分，通常有以下使用场景： 1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。 4、保护（Protect or Access）代理。 5、Cache代理。 6、防火墙（Firewall）代理。 7、同步化（Synchronization）代理。 8、智能引用（Smart Reference）代理。

注意事项： 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

代理模式

代理模式类图：

• Subject:定义RealSubject对外的接口，且这些接口必须被Proxy实现，这样外部调用proxy的接口最终都被转化为对realsubject的调用。

• RealSubject:真正的目标对象。

• Proxy:目标对象的代理，负责控制和管理目标对象，并间接地传递外部对目标对象的访问。

下面我们使用两个例子来实际体验一下代理模式的应用。
网络代理

• 公共接口类Subject:

public interface Server{
    void visit(String url);
}

• 目标服务器RealSubject:

public class RealServer implements Server {
    private String serverName;
    public RealServer(String serverName) {
        this.serverName = serverName;
        System.out.println("This is " + serverName);
    }
    
    @Override
    public void visit(String url) {
        response(url);
    }
    
    private void response(String res) {
        System.out.println("This is response of " + res + " from server:" + serverName);
    }
}

• 代理服务器ProxyServer:

public class ProxyServer implements Server{
 
   private RealServer realServer;
 
   public ProxyServer(String serverName){
      this.realServer = new RealServer(serverName);
   }
 
   @Override
   public void visit(String url) {
      realServer.visit(url);
   }
}

• Client

public class Demo {
    public static void main(String[] args) {
        Server server = new ProxyServer("www.google.com");
        server.visit("map.google.com");
    }
}

动态代理

动态代理类图和上面的代理模式没有什么区别，只不过是多了Java反射等等。

动态代理具体步骤：

1. 通过实现 InvocationHandler 接口创建自己的调用处理器；
2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
   Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});
3. 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
   Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4. 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。
   Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。

• java.lang.reflect.Proxy，这是Java动态代理机制生成的所有动态代理类的父类，它提供静态方法来为一组接口动态地生成代理类及其对象。
• java.lang.reflect.InvocationHandler，这是调用处理器接口，它自定义了一个invoke方法，用于实现代理逻辑、转发请求给对原始类对象。

public interface SubjectInteface {
    void doJob(String s);
}

public class Subject implements SubjectInteface {
    @Override
    public void doJob(String s) {
        print(s);
    }

    public void print(String s){
        System.out.println("执行"+s+"号业务");
    }
}

public class SubjectProxy implements InvocationHandler {
    Object o;

    public SubjectProxy(Object o) {
        this.o = o;
    }

    public static Object factory(Object o) {
        Object instance = Proxy.newProxyInstance(
                o.getClass().getClassLoader(),
                o.getClass().getInterfaces(),
                new SubjectProxy(o));
        return instance;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理逻辑...");
        method.invoke(o, args);
        return null;
    }
}

public class Client {
    public static void main(String[] args) {
        SubjectInteface subject = new Subject();
        SubjectInteface instance = (SubjectInteface) SubjectProxy.factory(subject);
        instance.doJob("1");
    }
}