初学Java设计模式随记 -- 代理(Proxy)模式之动态代理(Dynamic Proxy)

 

什么是动态代理？

被代理的对象（真实主题（RealSubject））可以在运行时动态改变，需要控制的接口(抽象主题（Subject）)可以在运行时改变，控制的方式也可以动态改变，从而实现了非常灵活的动态代理关系。

 

Java提供了动态代理的实现方法。

在Java的java.lang.reflect库中，提供了下面的三个类来实现动态代理。

Proxy(类): 此类表示代理设置，通常为类型（http、socks）和套接字地址。Proxy 是不可变对象。

InvocationHadler(接口): 可以称为调用处理器，是代理实例的调用处理程序 实现的接口。 每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

Method（类）: 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。

 

那么，怎么实现动态代理呢？主要通过以下四步：

1） 定义一个抽象主题

2） 定义一个真实主题

前两个和静态代理相同。关键就是这个动态代理角色是怎么实现呢？

3) 需要实现InvocationHadler(接口)，这个接口的实现类，将会完成动态代理类的实际工作。

     在这个接口的invoke方法中，会通过Method（类），利用Java的反射机制，动态实现对真实主题的调用。

4) 在客户端（或InvocationHadler的实现类），调用Proxy(类)的静态方法newProxyInstance，会返回一个代理对象（这个就是动态代理类，它其实并不做实际的工作）。

 

通过代码来理解动态代理的实现机制吧。 

还以初学Java设计模式随记 -- 代理(Proxy)模式之静态代理中，买汽车为例。

现实生活中，去向卖家（抽象主题（Subject））买汽车，通常不直接向厂家（真实主题(Real Subject)）购买汽车，可以到4S店（代理（Proxy）角色）买汽车，那里可以得到更多的服务。

 

Java代码如下：

抽象主题（Subject）： 

/**
 * 抽象主题（Subject）
 * 
 * 汽车的销售商
 *
 */
public interface CarSeller {
	
	/*
	 * 销售汽车
	 */
	public Object sellCars(int type);

}

 

真实主题(Real Subject)： 

/**
 * 真实主题(Real Subject)角色
 * 奥迪厂家
 *
 */
public class AudiCarFactory implements CarSeller {

	/*
	 * 实现了抽象主题（Subject）角色的方法
	 */
	public Object sellCars(int type) {
		System.out.println("奥迪工厂出售汽车。");
		if(type == 1){
			return "AudiA6";
		}else{
			return "AudiA8";
		}
	}
}

 

调用处理器（InvocationHadler的实现类）： 

/*
 * 实际提供代理商服务的一个类
 * （很多地方把这个类称为代理类，个人觉得不准确。
 * 它是一个会完成动态代理类的实际工作的类。）
 */
public class CarProxyInvocationHandler implements InvocationHandler {
	
	Object carSeller = null;
	
	public CarProxyInvocationHandler(Object carSeller){
		this.carSeller = carSeller;
	}
	
	/*
	 * 代理角色提供服务的真正方法。
	 * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
	 */
	public Object invoke(Object proxy, Method method, Object[] args){
		Object result = null;
		
		try {
			
			serveBeforeSell();
			result = method.invoke(carSeller,args);
			serveAfterSell();

		} catch (Exception e) {
			System.exit(1);
		}
		
//		System.out.println("result:" + result +";" + args[0]);
		
		return result;
	}
	
	protected void serveBeforeSell(){
		System.out.println("汽车代理商为客户提供了一些售前服务");
	}
	
	protected void serveAfterSell(){
		System.out.println("汽车代理商为客户提供了一些售后服务");
	}

}

  

客户端： 

/**
 * 客户端调用
 */
public class Customer {

	public static void main(String[] args) {

//		创建真实主题对象
		CarSeller carSeller = new AudiCarFactory();

//		通过动态的方式，得到了真正的代理角色对象。
//		在运行时，真实主题对象，代理角色以及实际完成代理操作的类被关联起来了。
		CarSeller carProxy = (CarSeller) Proxy.newProxyInstance(carSeller.getClass()
				.getClassLoader(), carSeller.getClass().getInterfaces(),
				new CarProxyInvocationHandler(carSeller));
		
//		由代理商销售汽车
		Object car = carProxy.sellCars(2);
		System.out.println("顾客从代理商那里买了一辆" + car);
		
	}

}

 

运行结果： 

汽车代理商为客户提供了一些售前服务
奥迪工厂出售汽车。
汽车代理商为客户提供了一些售后服务
顾客从代理商那里买了一辆AudiA8

 

 在初看到Java动态代理的实现时，有几个地方总是不太容易理解： 

1） Proxy类的newProxyInstance方法中的三个参数用来干什么用的。

第一个参数，真实主题对象所使用的类加载器-----为了装载创建出来的动态代理类；

第二个参数，真实主题对象所实现的所有接口-----为了动态代理类将会实现真实主题的所有接口；

第三个参数，一个调用处理器（InvocationHadler的实现类）的实例-----因为动态代理类继承了Proxy类，所以使用其InvocationHadler的实现类从子类（通常为动态代理类）的构造函数构建新的 Proxy 实例。（可参见jdk的帮助文档）

 

这样，我们得到的动态代理类$Proxy0就被指定为某个真实主题的代理，并且该代理继承了Proxy(类)，也实现了抽象主题接口，并与InvocationHadler接口绑定在一起。

由于动态代理类$Proxy0是在运行时创建的，我们无法直接看到这个类的代码，可以参看下面的链接来了解。

java 动态代理深度学习(Proxy,InvocationHandler),含$Proxy0源码（转）

 

2) InvocationHadler接口的invoke方法中的三个参数用来干什么的。

第一个参数，是动态代理对象$Proxy0，通常不使用。不过，因为有了这个参数，我们可以得到对这个对象的方法的访问了。

第二个参数，被代理对象（真实主题）定义的方法。

第三个参数，被代理对象（真实主题）定义的方法的参数

第二和第三个参数可以利用Method类的反射机制，实现了动态地对主题对象的调用。 

 

3) 调用动态代理类的方法时，是怎么调用到InvocationHadler接口的invoke方法的呢？

 根据动态代理类$Proxy0的代码，我们可以看到，它所实现的抽象主题接口的方法中，调用了InvocationHadler的invoke方法。并且以动态代理类$Proxy0自身的this指针做为invoke方法的第一个参数。

 

明白了这三点，结合上面的代码，就可以理解动态代理的运行机制：

1）创建一个真实主题(AudiCarFactory )对象，该对象继承了抽象主题类(CarSeller)；

2）使用Proxy类的newProxyInstance方法得到了一个动态代理类$Proxy0，并绑定了CarProxyInvocationHandler 实例；

3）该动态代理类$Proxy0继承了Proxy类，并实现了真实主题对象的所有接口(本例中，只有CarSeller)；

4）该动态代理类$Proxy0实现的抽象主题(CarSeller)类的方法(sellCars)中，调用了CarProxyInvocationHandler的invoke方法；

5）CarProxyInvocationHandler的invoke方法中，调用了真实主题(AudiCarFactory )的sellCars方法，并在sellCars之前或之后添加了额外的操作。

 

下面给出时序图，应该能更清晰一些：

 

 

动态代理类是这样的一个类：可以在运行时、在创建这个类的时候才指定它所实现的接口。每个代理类的实例都有一个对应的InvocationHandler对象。

 

引用一位网友的总结： 

所谓动态代理（Dynamic Proxy）是这样一种class: 它是在运行时生成的class,在生成它时你必须提供一组interface给它，然后该class 就宣传它实现了这个interface。你当然可以把该class的实例当做这个interface中的任意一个来用。当然，这个动态代理（Dynamic Proxy）其实就是一个代理（Proxy），它不会替你做实质性的工作。在生成它的实例时，你必须提供一个handler，由它接管实际的工作。