Java设计模式之代理初探

java设计模式之静态代理，动态代理
代理模式是对象的结构模式。代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。意思就是一个体或者机构代表另一个体或者机构执行一些行为。在一些情况下，一个客户端不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

静态代理

• 场景：
  比如你要买一张飞机票，你的行为是要买机票，买机票可以通过第三方代理平台，比如阿里，去哪儿，携程这些平台帮你买，这种平台就充当了代理角色，这样的话你就不用直接在航空公司买票了。只需要将你行为需求告诉代理角色即可。

• 代码
  1.创建行为接口

public interface BuyTicketInterface {
    //买票的行为
    void butTicket();

}

2.创建客户端，客户端要实现接口中定义的行为，我要买票。然后执行自己的行为。

public class TravelPeople implements BuyTicketInterface {
    //客户端的行为和需求，是这样的。
    public void butTicket() {
        System.out.println("买一张5月1号重庆江北机场飞往北京首都机场的航班，时间14:00到24:00之间");
    }
}

3.创建代理端功能，代理端也要实现买票的行为，不然怎么完成客户端的要求，代理执行买票的过程是替将客户端的执行的。代码如下。

public class BuyTicketProxy implements BuyTicketInterface{

    private TravelPeople travelPeople;
    //
    public BuyTicketProxy(){
    this.travelPeople = new TravelPeople(); 
    }
    /**
     * 执行的时候调用的是代理的行为，代理是替客户端办事的。
     */
    public void buyTicket() {
        if(travelPeople != null){
            travelPeople.buyTicket();
        }
    }
}

4.使用代理来购票。终端行为和代理方处理，实现购片的功能；
代码如下：

public class TicketService {


    public static void main(String[] args) {
        TicketService.startBuyTicket();
    }
    //开始买票，看似交易的是代理和票务中心交易，其实执行的是客户端的交易。
    public static void startBuyTicket(){
        BuyTicketInterface buyTick = new BuyTicketProxy();
        buyTick.buyTicket();
    }
}

运行结果

---

买一张5月1号重庆江北机场飞往北京首都机场的航班，时间14:00到24:00之间

静态代理模式优缺点：
优点：业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点，同时降低了业务逻辑的耦合性。
缺点：
1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

那么问题来了，如果要按照上述的方式（静态代理）使用代理模式，那么真实角色必须是实现已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个代理角色，但如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。

动态代理

动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。 通过Java的反射机制来实现。

---

1. 先看看与动态代理紧密关联的Java API。

---

1）java.lang.reflect.Proxy

这是 Java 动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。
proxy的代码清单如下

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器
static InvocationHandler getInvocationHandler(Object proxy) 

// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static Class getProxyClass(ClassLoader loader, Class[] interfaces) 

// 方法 3：该方法用于判断指定类对象是否是一个动态代理类
static boolean isProxyClass(Class cl) 

// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 

2）java.lang.reflect.InvocationHandler

---

这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。每次生成动态代理类对象时都要指定一个对应的调用处理器对象。

InvocationHandlerd代码清单如下：

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象  
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行  
Object invoke(Object proxy, Method method, Object[] args)   

3）java.lang.ClassLoader

---

这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。
每次生成动态代理类对象时都需要指定一个类装载器对象 。

---

2 .动态代理实现步骤
具体步骤是：
a. 实现InvocationHandler接口创建自己的调用处理器
b. 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类
c. 以调用处理器类型为参数，利用反射机制得到动态代理类的构造函数
d. 以调用处理器对象为参数，利用动态代理类的构造函数创建动态代理类对象

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..); 

// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 

// 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); 

// 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler }); 

---

3.动态代理实现示例

创建接口；

public interface BuyTicketInterface {

    void buyTicket();
}

创建动态代理类对应的调用处理程序类

 public class BuyTicketHandler implements InvocationHandler {
     /**
     * 动态代理类对应的调用处理程序类
     */
    private Object orginObject;
    //代理类持有一个委托类的对象引用
    public BuyTicketHandler(Object orginObject){
        this.orginObject = orginObject;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result ; 
        //调用方法之前；
        doBefore();
          //利用反射机制将请求分派给委托类处理。Method的invoke返回Object对象作为方法执行结果。
          //因为示例程序没有返回值，所以这里忽略了返回值处理
        result = method.invoke(this.orginObject, args);
        doAfter();
        return result ; 
    }

    private void doBefore(){
        System.out.println("开始买票");
    }


    private void doAfter(){
        System.out.println("调用买票");
    }



}

生成动态代理对象的工厂，工厂方法列出了如何生成动态代理类对象的步骤。

/**
 * 生成动态代理对象的工厂.
 */
public class DynProxyFactory {
 //客户类调用此工厂方法获得代理对象。
 //对客户类来说，其并不知道返回的是代理类对象还是委托类对象。
 public static Subject getInstance(){ 
  Subject delegate = new RealSubject();
  InvocationHandler handler = new SubjectInvocationHandler(delegate);
  Subject proxy = null;
  proxy = (Subject)Proxy.newProxyInstance(
    delegate.getClass().getClassLoader(), 
    delegate.getClass().getInterfaces(), 
    handler);
  return proxy;
 }
}

动态代理客户类

public class BuyTicketProxy {
    //客户类调用此工厂方法获得代理对象。  
     //对客户类来说，其并不知道返回的是代理类对象还是委托类对象。  
    public static BuyTicketInterface  startBuy(){
        //创建待代理的对象
        BuyTicketInterface buyTicket = new TravelPeople();
        //创建动态代理
        InvocationHandler handler = new BuyTicketHandler(buyTicket);
        //通过反射来获取对象。
        BuyTicketInterface buy = (BuyTicketInterface)Proxy.newProxyInstance(buyTicket.getClass().getClassLoader(), buyTicket.getClass().getInterfaces(), handler);
        return buy;
    }

}

创建测试；

BuyTicketInterface buy = BuyTicketProxy.startBuy();
        buy.buyTicket();

运行结果：

开始买票
买一张5月1号重庆江北机场飞往北京首都机场的航班，时间14:00到24:00之间
调用买票

总结：首先是动态生成的代理类本身的一些特点。1）包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或 private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理类所在的包就是 com.ibm.developerworks），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；2）类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；3）类名：格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象，而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。

优点：
动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。在本示例中看不出来，因为invoke方法体内嵌入了具体的外围业务（记录任务处理前后时间并计算时间差）。

缺点：
Proxy 已经设计得很完美了，但是还是有局限，就是不能摆脱 interface 代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫 Proxy。Java 的继承机制注定了这些动态代理类们无法实现对 class 的动态代理，原因是多继承在 Java 中本质上就行不通。

有很多条理由，人们可以否定对 class 代理的必要性，但是同样有一些理由，相信支持 class 动态代理会更美好。接口和类的划分，本就不是很明显，只是到了 Java 中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾。
最后，代理设计模式结合项目自身的情况而定，做到将设计模式的设计功能发挥到最大化。使项目，易扩展，耦合性低。才是前进的方向。