【设计模式】代理模式

代理模式：

组成：抽象角色:通过接口或抽象类声明真实角色实现的业务方法。

代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

举例：现实生活里，大家租房可能需要通过中介公司（代理类），联系房屋出租者（真实类），我们是自己无法直接联系的，那么这其实就是一个典型的代理模式。中介公司在整个过程中，可能会有加钱，签署合同之类的附加动作。

代码举例：

中介公司就是一个代理，那么它其实有着约定好的协议。

可以是抽象类，也可以是接口。

public interface IAbstractObj {

	public void doSomeThings();

}

然后房屋出租者和我们自己都要遵守协定接口，那么不管是真实的类，还是代理类，都应该继承该接口，同时代理类应该持有被代理类的对象，完成代理的过程。

public class ProxyObject implements IAbstractObj {
	RealObject realObject = new RealObject();

	@Override
	public void doSomeThings() {
		realObject.doSomeThings();
	}
}

public class RealObject implements IAbstractObj {
	@Override
	public void doSomeThings() {
		System.out.println("真实对象");
	}
}

这样就是通过代理类把代理对象和调用者分开了。调用者不直接调用真实对象，而是通过代理对象间接调用。

public class Test {

	public static void main(String[] args) {

		IAbstractObj obj = new ProxyObject();
		obj.doSomeThings();
	}

}

以上为静态代理，缺陷很明显，当代理类增多，重复代码会很多，硬代码实现不太好，以下介绍动态代理示例。

------------------------------------------分割线--------------------------------------------------------

动态代理

修改代理类

动态代理类需要实现InvocationHandler接口，重写invoke方法

proxy：被代理对象

method：代理方法

args：方法的参数

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

public class ProxyObject implements InvocationHandler {

	private Object target;

	public Object bind(Object target) {
		this.target = target;
		return Proxy.newProxyInstance(target.getClass().getClassLoader(),
				target.getClass().getInterfaces(), this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;
		result = method.invoke(target, args);
		return result;
	}
}

客户端程序修改

import com.ufgov.impl.ProxyObject;
import com.ufgov.impl.RealObject;

public class Test {

	public static void main(String[] args) {

		ProxyObject proxy = new ProxyObject();
		IAbstractObj bind = (IAbstractObj) proxy.bind(new RealObject());
		bind.doSomeThings();
	}

}