代理模式

定义

定义：为其他对象提供一种代理以控制对这个对象的访问。

优点及使用场景

优点：职责清晰，高扩展，智能。
使用场景：Spring AOP

静态代理

自己手写代理类。

/**
 * 接口
 * @author Administrator
 *
 */
public interface IGamePlayer
{
	void login();
	void killBoss();
    void update();
}

/*
 * 
 * 委托类
 */
public class GamePlayer implements IGamePlayer
{

	@Override
	public void login()
	{
		System.out.println("login...");
	}

	@Override
	public void killBoss()
	{
         System.out.println("killBoss...");
	}

	@Override
	public void update()
	{
		System.out.println("update...");
	}

}

/**
 * 代理类
 * @author Administrator
 *
 */
public class StaticProxy implements IGamePlayer
{
	private GamePlayer gamePlayer;
	public StaticProxy(GamePlayer gamePlayer){
		this.gamePlayer = gamePlayer;
	}
	@Override
	public void login()
	{
		this.gamePlayer.login();
	}
	@Override
	public void killBoss()
	{
		this.gamePlayer.killBoss();
	}
	@Override
	public void update()
	{
		this.gamePlayer.update();
	}
	
}

静态代理缺点明显，需要手写代理类，委托类种类一多，代理类型也随之增多。

动态代理

//接口和委托类跟静态代理的一样
//动态代理机制提供的接口
public class MyInvocationHandler implements InvocationHandler
{
	//要代理的真实对象
    private Object object = null;
	
	public MyInvocationHandler(Object obj)
	{
		this.object = obj;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
	{
        System.out.println("before..."); //自己扩展的功能
        Object result = method.invoke(object, args);
        System.out.println("after...");
		return result;
	}
}
//委托类
IGamePlayer player = new GamePlayer();
//动态代理类关联的handler
InvocationHandler handler = new MyInvocationHandler(player);
//动态生成代理类
IGamePlayer proxy = (IGamePlayer) Proxy.newProxyInstance(player.getClass().getClassLoader(),
player.getClass().getInterfaces(), handler);

Proxy.newProxyInstance这个方法要提供三个参数：
第一个传入类加载器，可以传入委托类的类加载器。
第二个是要实现的接口，传入委托类实现的接口，这样生成的接口才能强转为IGamePlayer，因为这个动态代理类实现了这个接口，后续可以调用这个接口的方法。
第三个是要关联的handler，这个handler代理了委托类。

每个动态生成的代理对象都关联一个handler，而handler又代理了委托类。个人感觉有点像两个代理的关系。