JAVA动态代理学习

代理模式分为静态代理和动态代理，静态代理中的代理是由程序员自己编写的，也就是说在我们的代码运行前，代理类的class编译文件就已存在；而动态代理与其相反，代理类是在运行阶段由JVM帮忙生成。java也给我们提供了一个便捷的动态代理接口



InvocationHandler，实现该接口需要重写其invoke方法，如下：

public class DynamicProxy implements InvocationHandler {
	// 　这个就是我们要代理的真实对象
	private Object subject;

	// 构造方法，给我们要代理的真实对象赋初值
	public DynamicProxy(Object subject) {
		this.subject = subject;
	}

	@Override
	public Object invoke(Object arg0, Method method, Object[] args)
			throws Throwable {
		// 　　在代理真实对象前我们可以添加一些自己的操作
		System.out.println("before rent house");

		System.out.println("Method:" + method);

		// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
		method.invoke(subject, args);

		// 　　在代理真实对象后我们也可以添加一些自己的操作
		System.out.println("after rent house");
		return null;
	}

}

可以看到，我们声明一个Object的引用，该引用将指向被代理类，而我们调用被代理类的接口方法时，则会在invoke方法中执行。也就是说我们原来由代理类所做的工作现在由InvocationHandler来处理，不再需要关心到底代理谁，客户代码：

public class Client {
	public static void main(String[] args) {
		// 我们要代理的真实对象
		Subject realSubject = new RealSubject();

		// 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
		InvocationHandler handler = new DynamicProxy(realSubject);

		/*
		 * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数 第一个参数
		 * handler.getClass().getClassLoader()
		 * ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
		 * 第二个参数realSubject.getClass().
		 * getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，
		 * 表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了 第三个参数handler， 我们这里将这个代理对象关联到了上方的
		 * InvocationHandler 这个对象上
		 */
		Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass()
				.getClassLoader(), realSubject.getClass().getInterfaces(),
				handler);

		System.out.println(subject.getClass().getName());
		subject.hello("world");
	}
}

其他代码：

public interface Subject {
	public void rent();
	public void hello(String str);
}

public class RealSubject implements Subject {

	@Override
	public void rent() {
		System.out.println("I want to rent my house");
	}

	@Override
	public void hello(String str) {
		System.out.println("hello: " + str);
	}

}

运行结果：

com.sun.proxy.$Proxy0
before rent house
Method:public abstract void com.zte.dynamicproxy.Subject.hello(java.lang.String)
hello: world
after rent house

可以看到调用subject.getClass().getName()打印为Proxy0类型，接着调用hello方法就会进入DynamicProxy中的invoke方法中。

如果我们要换个接口，可以继续用这个动态代理，如下：

public interface Subject1 {
	public void rent();
}

public class RealSubject1 implements Subject1 {
	@Override
	public void rent() {
		System.out.println("1 I want to rent my house");
	}
}

public class Client {
	public static void main(String[] args) {
		Subject1 realSubject1 = new RealSubject1();
		InvocationHandler handler = new DynamicProxy(realSubject1);
		Subject1 subject = (Subject1) Proxy.newProxyInstance(handler.getClass()
				.getClassLoader(), realSubject1.getClass().getInterfaces(),
				handler);
		System.out.println(subject.getClass().getName());
		subject.rent();
	}
}

打印结果：

com.sun.proxy.$Proxy0
before rent house
Method:public abstract void com.zte.dynamicproxy.Subject1.rent()
1 I want to rent my house
after rent house

由此可见动态代理通过一个代理类来代替N多个被代理类，其实质是对代理者与被代理者进行解耦，使得两者没有直接的耦合关系，相对静态代理则只能为给定接口下的实现类做代理，如果接口不同那么就需要重新定义不同的代理类，但是静态代理更符合面向对象。