前言

代理模式是一种结构型设计模式，主要用来解决直接访问对象带来的问题。目地是为其他对象提供一个代理以控制某个对象的访问。代理分为静态代理和动态代理，先说静态代理，概念总是太抽象，直接用代码说明吧。

静态代理类图如下：

结构型设计模式代理模式：静态代理类图.jpg

抽象主题 声明一个接口

// 抽象主题  是一个接口，以一个工厂接口为例
public interface IToolFactory(){
    public void makeProduct();
}

定义一个真实的主题，用来实实在在做事的，以工厂为例，用来加工产品

public class ARealFactory implement IToolFactory(){
    @Override
    public void makeProduct(){
        System.out.println("我加工生产出来了你们所需要的产品。");
    }
}

下面是一个最重要的角色，代理类Proxy 相当于代购者

public class Proxy implements IToolFactory(){
    ARealFactory factory;
    public Proxy(ARealFactory factory){
        this.factory = factory;
    }

    public void doBefore(){
        System.out.println("售前咨询，可以提出客户的需求");
    }
    public void doAfter(){
        System.out.println("售后服务，解决客户的后顾之忧");
    }

    @Override
    public void makeProduct(){
        if(factory == null){
          factory = new ARealFactory();
        }

        doBefore();
        factory.makeProduct();
        doAfter();
    }

}

我们的顾客需要购买产品，就需要找代购

public class Customer(){

      public static void main(String args[]){
              //实例化一个真实的工厂
           // IToolFactory factory = new ARealFactory();
            //代购者需要持有真实对象
            Proxy proxy = new Proxy();
            proxy.makeProduct();
      }
}

小结：

以上就是静态代理的设计模式的原理演示。静态代理的缺点就是违反了开闭原则，扩展能力差，可维护性差。因此就有了动态代理设计模式。

动态代理

在静态代理的基础上，我们进行改进：主要修改代理类Proxy， 通过反射获取动态代理对象。

public class MarkCompany implements InvokeHandler{
     private Object factory;
    public void setFactory(Object factory){
        this.factory = factory;
    }
    public Object getFactory(){
        return this.factory;
    }

    //  关键方法：获取动态代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(factory.getclass().getClassLoader(),facory.getClass().getInterfaces(),this);
    }

  /**
     * 通过动态代理对象进行增强
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy,Method method,Object[] args){
        
        doBefore();
        method.invoke(factory,args);
        doAfter();
        return null;
    }
    public void doBefore(){
        System.out.println("售前咨询，可以提出客户的需求");
    }
    public void doAfter(){
        System.out.println("售后服务，解决客户的后顾之忧");
    }


}

调用有点小小的区别：

IToolFactory  realFactory = new ARealFactory();
MarkCompany company = new MarkCompany();
company.setFactory(realFactory);

IToolFactory employ1 = (IToolCompany)company.getProxyInstance();
employ1.makeProduct();

结语

在实际开发过程中，由于静态代理的局限性，用到的地方较少，可以会用于代理对象较少，比较固定不需要扩展的场景。
虽然，动态代理运用到了反射，性能会不及静态代理，但是由于动态代理的各种好处优点，非常强大，牺牲点性能还是值得的。