【Java设计模式】六、代理模式：静态代理、JDK + CGLIB动态代理

结构型设计是将类或者对象按某种布局（继承机制、组合聚合）来组成更大结构。包括七种：

* 代理模式
* 适配器模式
* 装饰者模式
* 桥接模式
* 外观模式
* 组合模式
* 享元模式
1
2
3
4
5
6
7

1、代理对象

以买电脑为例，联想公司就是目标对象，地方代理商就是代理对象。

Java按照代理对象生成时机，分为：

• 静态代理：代理类在编译器就生成
• 动态代理：代理类在程序运行时动态生成。又分为JDK代理和CGLib代理

2、代理模式结构

有三种角色：

• 抽象主题类：定义一套规范
• 真实主题类：下面例子中的火车站类
• 代理类：下面例子中的代售点类

3、静态代理

直接去火车站买票，需要经历：坐车到火车站、排队等操作，麻烦（即目标对象不适合或不能直接访问到）。我们一般会到镇上就近的火车票代售点。此时，火车站为目标对象，代售点是代理对象。类图如下：注意，代理对象ProxyPoint聚合了目标对象（火车站TrainStation）

定义卖火车票的规范：

//卖票接口
public interface SellTickets {
    void sell();
}
1
2
3
4

定义火车站，实现规范接口：

//火车站  火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {

    public void sell() {
        System.out.println("火车站卖票");
    }
}
1
2
3
4
5
6
7

定义代售点类，和目标对象实现同一个接口（即抽象主题），聚合目标对象，代售点卖票，调用的也是目标对象（火车站对象）的卖票功能：

//代售点
public class ProxyPoint implements SellTickets {

    private TrainStation station = new TrainStation();    //目标对象

    public void sell() {
        System.out.println("代理点收取一些服务费用");
        station.sell();
    }
}

1
2
3
4
5
6
7
8
9
10
11

客户端测试：

public class Client {
    public static void main(String[] args) {
        ProxyPoint proxy = new ProxyPoint();   //创建代理对象
        proxy.sell();
    }
}
1
2
3
4
5
6

注意上面代理类自己sell方法里的这句：

System.out.println("代理点收取一些服务费用");
1

客户端直接访问的是代理对象，代理对象是一个目标对象和访问者的中介，同时也是对原来对象的一个增强！！！（如上面代理对象的sell就新增了收取服务费用的功能）

4、JDK动态代理

先是抽象主题和目标对象：

//卖票接口
public interface SellTickets {
    void sell();
}

//火车站  火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {

    public void sell() {
        System.out.println("火车站卖票");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

JDK中有一个类Proxy，它不是上面提到的代理对象类，而是提供创建代理对象的静态方法newProxyInstance来获取代理对象

//代理工厂，用来创建代理对象
public class ProxyFactory {

	//声明目标对象
    private TrainStation station = new TrainStation();   
	
	//返回代理对象
    public SellTickets getProxyObject() {
        //使用Proxy获取代理对象
        /*
            newProxyInstance()方法参数说明：
                ClassLoader loader ： 类加载器，用于加载代理类，使用真实对象的类加载器即可
                Class[] interfaces ： 真实对象所实现的接口，但代理模式下，真实对象和代理对象实现相同的接口，这里依旧用目标对象（真实对象）+ getInterfaces拿到接口类对象
                InvocationHandler h ： 代理对象的调用处理程序
         */
        SellTickets proxyObject = (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
                    /*
                        InvocationHandler中invoke方法参数说明：
                            proxy ： 代理对象，即上面的proxyObject
                            method ： 对应于在代理对象上调用的接口方法的 Method 实例
                            args ： 通过代理对象调用接口方法时传递的实际参数
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("代理点收取一些服务费用(JDK动态代理方式)");
                        //执行真实对象，调用method的invoke，传入调用方法的对象和方法的实参
                        Object result = method.invoke(station, args);
                        return result;
                    }
                });
        return proxyObject;
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

客户端：

//测试类
public class Client {
    public static void main(String[] args) {
        //创建代理对象工厂
        ProxyFactory factory = new ProxyFactory();   
        //获取代理对象（proxyObject.getClass发现其全类名是com.sun.proxy.$Proxy0）
        SellTickets proxyObject = factory.getProxyObject();  
        //通过代理对象调用买票的方法
        proxyObject.sell();
    }
}
1
2
3
4
5
6
7
8
9
10
11

运行：

代理点收取一些服务费用(JDK动态代理方式)
火车站卖票
1
2

5、JDK动态代理的原理

注意上面定义的ProxyFactory不是代理类，代理类是程序运行过程中动态在内存中生成的类。使用阿尔萨斯下的jad指令，查看生成的代理类$Proxy0：

//简略版，删掉了hashcode、equals等方法
com.sun.proxy.$Proxy0
//程序运行过程中动态生成的代理类
  public final class $Proxy0 extends Proxy implements SellTickets {
  
      private static Method m3;
  
      public $Proxy0(InvocationHandler invocationHandler) {
          super(invocationHandler);
      }
  
      static {
          m3 = Class.forName("com.myplat.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]);
      }
  
      public final void sell() {
          this.h.invoke(this, m3, null);
      }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

而其父类Proxy：

//Java提供的动态代理相关类
  public class Proxy implements java.io.Serializable {
  	protected InvocationHandler h;
  	 
  	protected Proxy(InvocationHandler h) {
          this.h = h;
      }
  }
  .....略
1
2
3
4
5
6
7
8
9

发现：

• 代理类$Proxy0实现了抽象主题SellTickets接口（符合：真实的目标对象和代理对象实现了同样的接口）
• 代理类$Proxy0又将我在newProxyInstance传入的InvocationHandler传给了父类的h属性

因此，以上的完整过程是：

• 测试类中通过代理对象调用sell方法
• 到了$Proxy0的sell方法中
• h.invoke即newProxyInstance方法中传入的第三个匿名内部类对象h中重写的invoke方法
  
• 传入invoke的三个实参为：proxy代理对象自己（即this），m3（静态代码块中初始化的抽象主题SellTickets的sell方法），sell方法的实参（null）
• invoke方法中则通过反射，执行真实对象所属类TrainStation中的sell方法并返回，相关代码：Object result = method.invoke(station, args);

6、CGLIB动态代理

前面JDK动态代理Proxy.newProxyInstance方法的第二个形参是真实对象所实现的接口，当上面的案例没有抽象主题接口SellTickets时，则JDK代理无法使用了（看阿尔萨斯拿到的代理类$Proxy0，静态代码块要Class.forName加载newProxyInstance传入的抽象主题接口，现在没这个接口了，自然不能用了）

此时可用CGLIB：高性能的代码生成包

<dependency>
    <groupId>cglibgroupId>
    <artifactId>cglibartifactId>
    <version>2.2.2version>
dependency>
1
2
3
4
5

还是买票的案例，这次只有火车站这个具体主题类，没有SellTickets接口：

//火车站
public class TrainStation {

    public void sell() {
        System.out.println("火车站卖票");
    }
}

1
2
3
4
5
6
7
8

写代理工厂类，实现MethodInterceptor 接口，重写intercept方法。Enhancer的Callback设置回调，需要一个MethodInterceptor的子实现对象，此时传入代理工厂类对象后，就会回调intercept方法，intercept方法中又调用了真实对象的sell方法。关键点：

• Enhancer对象
• 设置父类字节码对象为真实目标对象
• 设置回调，回调中调真实目标对象的对应方法

//代理工厂
public class ProxyFactory implements MethodInterceptor {
	
	//声明真实目标对象
	private TrainStation  station = new TrainStation();
	//通过CGLIB获取代理对象
    public TrainStation getProxyObject() {
        //创建Enhancer对象，类似于JDK动态代理的Proxy类，下一步就是设置几个参数
        Enhancer enhancer =new Enhancer();
        //设置父类的字节码对象
        enhancer.setSuperclass(TrainStation.class);
        //设置回调函数
        enhancer.setCallback(this);
        //创建代理对象
        TrainStation proxyObj = (TrainStation) enhancer.create();
        return proxyObj;
    }

    /*
        intercept方法参数说明：
            o ： 代理对象
            method ： 真实对象中的方法的Method实例
            args ： 实际参数
            methodProxy ：代理对象中的方法的method实例
     */
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    	//对原真实目标对象的方法按实际需求做点增强
        System.out.println("代理点收取一些服务费用(CGLIB动态代理方式)");
        //调用真实目标对象的方法
        Object result = method.invoke(station, args);
        //也可用invokeSuper调用目标对象的方法（因为前面设置了代理对象的父类字节码对象为真实目标对象，他们之间是父子关系）
        //TrainStation result = (TrainStation) methodProxy.invokeSuper(o, args);
        return result;
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

PS：上面的真实目标对象，即目标对象

//测试类
public class Client {
    public static void main(String[] args) {
        //创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //获取代理对象
        TrainStation proxyObject = factory.getProxyObject();

        proxyObject.sell();
    }
}
1
2
3
4
5
6
7
8
9
10
11

7、三种代理的对比

关于JDK代理和CGLIB代理：

• CGLIB底层用ASM字节码生成框架来生成代理类
• CGLIB不能对final关键字的类进行代理，因为enhancer.setSuperclass，动态生成的代理类是目标类的子类，而final类无法被继承
• JDK和CGLIB动态代理的效率，和JDK版本有关（JDK1.8后，JDK > CGLIB）
• 总之，有接口用JDK动态代理，没接口，走CGLIB

关于动态和静态代理：

当抽象主题接口新增了一个方法，则静态代理下的写的代理类也需要去实现此方法，维护复杂。动态代理无此问题。

8、代理模式的总结

优点：

• 代理模式在客户端与目标对象之间起到了一个中介作用 + 保护目标对象
• 代理对象中可以扩展目标对象的功能（上面代售点加服务费、AOP增强）
• 代理模式将客户端和目标对象解耦

缺点：

• 增加了复杂度

使用场景：