Java代理模式的理解（一）

一 静态代理模式

在静态代理模式中有三类角色，理解了这三类角色也就理解了代理模式：

a.抽象对象：定义了真实角色和抽象角色的公共接口（可以是类，也可以是接口）Subject;

b.代理角色：代理角色内部包含有对真实角色的引用，通过这个引用去执行真实角色想要完成的任务；除此之外，代理角色可以完成其他的一些功能；

c.真实角色：实际要完成任务的角色，是我们始终要引用的对象。

代理角色和真实角色均实现了（或继承了）抽象角色。

写一段代码来举例：

 

//抽象角色，定义公共部分
interface Subject { 
    public void request();
}

//真实角色
class RealSubject implements Subject {
    public void request() {
        do something;
   } 
}

//抽象角色，内部保存真实角色的引用
class ProxySubject implements Subject {
    private RealSubject sub;
    
    public ProxySubject(RealSubject obj) {
        this.sub = obj;//获得真实角色的实例引用
    }

   public void request() {
       sub.request();//通过真实角色的引用去执行最终要完成的任务
  }
}

public static void main(String[] args) {
		Subject proxy = new ProxySubject();
		proxy.request();
}

 

 

二 动态代理模式

在学习动态代理模式时，学完了整个过程，我还是没有理解，下面的描述是我从自己理解的角度出发的，也许不适合别人阅读，也许会产生共鸣。

动态代理模式也是代理模式，所以它也会有三种角色。

   抽象角色，定义公共部分，interface Subject;

   真实角色，完成实际的工作，class RealSubject implements Subject。

 

  class DynamicSubject:里面保存真实角色的引用，实现了InvocationHandler接口，InvocationHandler接口中有一个invoke方法，接受三个参数：

             一个是代理实例；

              一个是要执行方法的Method对象，通过调用Method对象的invoke()方法，便可以执行该方法了；

              一个是执行该方法所需要的参数。

 

 在使用动态代理模式时，首先需要得到真实角色的一个实例：RealSubject real = new RealSubject();

DynamicSubject实现了InvocationHandler接口，DynamicSubject里保存了一个真实角色的引用sub,通过构造方法来得到它：InvocationHandler handler = new DyanmicSubject(real);

 

接下来就是通过Proxy动态的生成一个动态代理类（也就是代理模式中的代理角色），分析一下，如果要生一个代理类需要哪些条件？根据静态代理来分析：

 （1）要实现Subject接口，谁实现了Subject接口？RealSubject！所以需要RealSubject实现的接口的列表：RealSubject.class.getInterfaces()。

 （2）要实现Subject中的方法。但是动态代理把执行方法的任务交给了InvocationHandler,所以需要一个InvocationHandler的对象。

Proxy动态生成了该代理类后，返回一个该类的实例。想一想，代理模式的前提是什么？是有一个定义了公共部分的接口Subject，由Subject的一个实例去调用要执行的方法。生成的动态代理类实现了哪个接口？Subject！所以返回的该动态代理类的实例必定是Subject类型的：

   Subject sub = (Subject)动态代理类实例；

   sub.调用要执行的方法；

回想一下：动态代理模式把执行方法的任务交给了InvocationHandler，所以sub.调用要执行的方法这一步实际上是把执行动作转移到了handler上了，调用了handler的invoke方法。handler的invoke方法再去调用实际要执行方法的Method对象的invoke()方法。

 

以上的描述可能比较乱，总结一下：

 （1）动态代理模式，也需要三种角色：抽象角色Subject；真实角色RealSubject；代理角色，由Proxy动态生成。

（2）动态代理模式把执行方法的任务交给了InvocationHandler,所以需要一个类去实现InvocationHandler接口，并且实现invoke方法。

 （3）生成动态代理类需要三个条件：类加载器；真实角色实现的接口列表；handler。需要handler的原因是因为：方法最终是在handler的invoke()方法中执行；在生成动态代理类的实例时，完成代理类和handler的关联。

//抽象角色
public interface Subject {
   public void request();
}

//真实角色
public class RealSubject implements Subject {

	@Override
	public void request() {
		System.out.println("From real Subject");

	}

}

//InvocationHandler
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/*
 * 该代理类内部的属性是Object类型，实际使用的时候通过构造方法传递进来一个对象sub
 * 此外，该类还实现了invoke方法，该方法中的method.invoke其实就是调用被代理对象将要执行的方法，
 * 方法参数是sub,表示该方法从属于sub
 * 
 */
public class DynamicSubject implements InvocationHandler {
	
	private Object sub;
	
	public DynamicSubject(Object obj) {
		this.sub = obj;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("before : " + method);
		System.out.println("method name : " + method.getName() + "," + args);
		method.invoke(sub, args); 
		System.out.println("after : " + method);	
		
		return null;
	}

}


public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		RealSubject realSubject = new RealSubject();
		InvocationHandler handler = new DynamicSubject(realSubject);
		
		Class<?> clazz = handler.getClass();
		
		//下面的代码一次性生成代理
		//完成两件事：动态生成一个代理类，并且生成这个类的一个实例
		Subject subject = (Subject) Proxy.newProxyInstance(clazz.getClassLoader(),
				RealSubject.class.getInterfaces(), handler);
		
		subject.request();//实际上将是将方法的执行转移到了handler上了，调用handler.invoke()方法
		System.out.println(subject.getClass());
	}

}