Java设计模式Proxy之动态代理

Java动态代理主要涉及到两个类：

• InvocationHandler：该接口中仅定义了一个Object : invoke(Object proxy, Method method, Object[] args);参数proxy指代理类，method表示被代理的方法，args为method中的参数数组，返回值Object为代理实例的方法调用返回的值。这个抽象方法在代理类中动态实现。

• Proxy：所有动态代理类的父类，提供用于创建动态代理类和实例的静态方法。

所谓动态代理类是在运行时生成的class，在生成它时，你必须提供一组interface给它，则动态代理类就宣称它实现了这些interface。当然，动态代理类就充当一个代理，你不要企图它会帮你干实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

下面通过实例来说明：

Subject.java

[java] view plain copy print ?

1. /** 
2.  * 抽象角色：声明真实对象和代理对象的共同接口 
3.  * @author WalkingDog 
4.  * 
5.  */  
6. public interface Subject {  
7.     public void doSomething();  
8. }  

/**
 * 抽象角色：声明真实对象和代理对象的共同接口
 * @author WalkingDog
 *
 */
public interface Subject {
	public void doSomething();
}

RealSubject.java

[java] view plain copy print ?

1.  * 真实对象：定义目标操作  
2.  * @author WalkingDog  
3.  *  
4.  */  
5. public class RealSubject implements Subject {  
6.     @Override  
7.     public void doSomething() {  
8.         System.out.println("RealSubject.doSomething");  
9.     }  
10. }  

 * 真实对象：定义目标操作
 * @author WalkingDog
 *
 */
public class RealSubject implements Subject {
	@Override
	public void doSomething() {
		System.out.println("RealSubject.doSomething");
	}
}

DynamicProxy.java

[java] view plain copy print ?

1. import java.lang.reflect.InvocationHandler;  
2. import java.lang.reflect.Method;  
3.   
4. public class DynamicProxy implements InvocationHandler {  
5.     private Object object;  
6.     public DynamicProxy(Object object) {  
7.         this.object = object;  
8.     }  
9.   
10.     @Override  
11.     public Object invoke(Object proxy, Method method, Object[] args)  
12.             throws Throwable {  
13.         System.out.println("Before Invoke ! method : " + method);  
14.           
15.         //我们可以再代理方法调用前后添加功能  
16.         Object result = method.invoke(object, args);  
17.           
18.         System.out.println("object : " + object + "\tresult : " + result + "\targs : " + args);  
19.         System.out.println("After Invoke !");  
20.         return result;  
21.     }  
22. }  

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler {
	private Object object;
	public DynamicProxy(Object object) {
		this.object = object;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("Before Invoke ! method : " + method);
		
		//我们可以再代理方法调用前后添加功能
		Object result = method.invoke(object, args);
		
		System.out.println("object : " + object + "\tresult : " + result + "\targs : " + args);
		System.out.println("After Invoke !");
		return result;
	}
}

Client.java

[java] view plain copy print ?

1. import java.lang.reflect.InvocationHandler;  
2. import java.lang.reflect.Proxy;  
3.   
4. /** 
5.  * 客户端 
6.  * @author WalkingDog 
7.  * 
8.  */  
9. public class Client {  
10.     public static void main(String[] args) throws Exception {  
11.           
12.         //创建目标对象，也就是被代理对象  
13.         RealSubject realSubject = new RealSubject();  
14.           
15.         //将目标对象交给代理  
16.         InvocationHandler handler = new DynamicProxy(realSubject);  
17.           
18. //      Class<?> proxyClass = Proxy.getProxyClass(Subject.class.getClassLoader()  
19. //              , new Class[]{Subject.class});  
20. //      Subject subject = (Subject)proxyClass.getConstructor(new Class[]{InvocationHandler.class})  
21. //              .newInstance(new Object[]{handler});  
22.           
23.         //返回代理对象，相当于上面两句  
24.         Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(),  
25.                 realSubject.getClass().getInterfaces(),  
26.                 handler);  
27.           
28.         //叫代理对象去doSomething()，其实在代理对象中的doSomething()中还是会  
29.         //用handler来调用invoke(proxy, method, args) 参数proxy为调用者subject(this)，  
30.         //method为doSomething()，参数为方法要传入的参数，这里没有  
31.         subject.doSomething();  
32.     }  
33. }  

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * 客户端
 * @author WalkingDog
 *
 */
public class Client {
	public static void main(String[] args) throws Exception {
		
		//创建目标对象，也就是被代理对象
		RealSubject realSubject = new RealSubject();
		
		//将目标对象交给代理
		InvocationHandler handler = new DynamicProxy(realSubject);
		
//		Class<?> proxyClass = Proxy.getProxyClass(Subject.class.getClassLoader()
//				, new Class[]{Subject.class});
//		Subject subject = (Subject)proxyClass.getConstructor(new Class[]{InvocationHandler.class})
//				.newInstance(new Object[]{handler});
		
		//返回代理对象，相当于上面两句
		Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
				realSubject.getClass().getInterfaces(),
				handler);
		
		//叫代理对象去doSomething()，其实在代理对象中的doSomething()中还是会
		//用handler来调用invoke(proxy, method, args) 参数proxy为调用者subject(this)，
		//method为doSomething()，参数为方法要传入的参数，这里没有
		subject.doSomething();
	}
}

打印结果：
Before Invoke ! method : public abstract void Subject.doSomething()
RealSubject.doSomething
object : RealSubject@ec6b00    result : null    args : null
After Invoke !