代理模式（静态模式、动态模式）

说明：代理模式是一种常见的设计模式，常应用于高级框架中，原理用到了反射。

 

1.静态代理

 代理就是在客户端和对象之间起到中介的作用。（客户不能或不想直接引用一个对象，而在中间直接找到一个代理中介）

 

比如：某人找中介给自己介绍服装厂给自己量身定做衣服

package ProxyPattern;

//设置一个接口和一个功能

public interface ClothingFactory {

    void productClothing();

}

 
package ProxyPattern;

//一家能生产衣服的服装厂

public class LiNingCompany implements ClothingFactory{

    public void productClothing(){

        System.out.println("make of a lot of cloth!");

    }

}

 
package ProxyPattern;

//专为别人找服装中介公司

public class ProxyCompany implements  ClothingFactory{

    private ClothingFactory cf;

    public ProxyCompany(ClothingFactory cf){

        this.cf=cf;

    }

    public void productClothing(){

        System.out.println("赚10000元中介费");

        cf.productClothing();

    }

}
 

package ProxyPattern;

//通过中介生产一批服装

public class Customer {

    public static void main(String[] args) {

        ClothingFactory cf=new ProxyCompany(new LiNingCompany());

        cf.productClothing();

    }

}

说明：静态代理模式，在编译期间就已经把代理类和目标类确定下来了，

所以这不利于扩展，若后期要生产一批鞋，就很不方便，扩展起来很不方便。

 

2.动态代理

即在运行期间根据需要动态创建目标类的代理对象。javaSE API中在java.lang.reflect包中提供了对动态代理的支持的类和接口。

(1)InvocationHandler(Object proxy, Method method, Object[] args)

throws Throwable;

(2)Proxy类：提供用于创建动态代理类和实例的静态方法。

*首先，拥有一个目标对象，该对象必须实现一个接口：

public interface Subject{

 public void doSomething();

}

public class RealSubject implementSubject{

 public void doSomething(){

 System.out.println("call doSomething()");

 }

}

*其次，为目标对象增加额外的逻辑：

 自定义一个类，并实现InvocationHandler接口；

 实现invoke函数，并将需要增加的逻辑写在该函数中；

interface Subject  
{  
    public void doSomething();  
}
class RealSubject implements Subject  
{  
    public void doSomething()  
  {  
     System.out.println( "call doSomething()" );  
  }  
}
class ProxyHandler implements InvocationHandler
{
    private Object tar;
    //绑定委托对象，并返回代理类
    public Object bind(Object tar)
    {
        this.tar = tar;
        //绑定该类实现的所有接口，取得代理类
        return Proxy.newProxyInstance(tar.getClass().getClassLoader(),
                                      tar.getClass().getInterfaces(),
                                      this);
    }   
    public Object invoke(Object proxy , Method method , Object[] args)throws Throwable//不依赖具体接口实现
    {
        Object result = null;//被代理的类型为Object基类
        //这里就可以进行所谓的AOP编程了
        //在调用具体函数方法前，执行功能处理
        result = method.invoke(tar,args);
        //在调用具体函数方法后，执行功能处理
        return result;
    }
}
public class Test
{
    public static void main(String args[])
    {
           ProxyHandler proxy = new ProxyHandler();
           //绑定该类实现的所有接口
           Subject sub = (Subject) proxy.bind(new RealSubject());
           sub.doSomething();
    }
}