代理模式笔记

代理模式是我们SpringAOP的底层，使用代理模式可以使得我们的程序横向发展，实现业务上的分工。

代理模式UML图：

步骤：
抽象角色：一般使用接口或者抽象类实现（农场）
直系角色：实现接口的角色，被代理的对象（老板）
代理角色：实现接口，依赖于直系角色，直接接触客户（代理）
客户：接触代理角色（我）

静态代理

农场：

public interface Farm {
	public void product();
}

老板：

public class Boss implements Farm{

	@Override
	public void product() {
		System.out.println("卖产品了");		
	}
	
}

代理：

public class Proxy implements Farm{

	private Boss boss;
		
	public Proxy() {
		
	}

	public void setProxy(Boss boss) {
		this.boss = boss;
	}


	@Override
	public void product() {
		order();
		boss.product();
		charge();
	}
	
	public void order() {
		System.out.println("接单");
	}
	
	public void charge() {
		System.out.println("收钱");		
	}
	

}

我：

public class Me {
	public static void main(String[] args) {
		
		Proxy proxy = new Proxy();
		proxy.setProxy(new Boss());
		proxy.product();
	}
}

优点：

1. 直系角色只关注最终结果，不需要关心业务。
2. 实现了业务统一管理

缺点：
一个直系角色有一个代理，角色多将类爆炸。

动态代理

使用动态代理我们不在去写死我们的代理，而是使用反射机制动态生成一个代理。
代理处理程序：

public class ProxyInvocationHandler implements InvocationHandler{

	//被代理的接口
	private Object farm;
	
	public void setFarm(Farm farm) {
		this.farm=farm;
	}
	
	//生成代理
	public Object getProxy() {
		return Proxy.newProxyInstance(this.getClass().getClassLoader(), farm.getClass().getInterfaces(), this);
	}
	
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//代理方法从farm中得到
		order();
		Object result = method.invoke(farm, args);
		return result;
	}
	
	
	//代理做的事情
	public void order() {
		System.out.println("接单");
	}

}

我：

public class Me {
	public static void main(String[] args) {
		//创建代理对象处理程序
		ProxyInvocationHandler handler = new ProxyInvocationHandler();
		//代理的对象
		handler.setFarm(new Boss());
		
		//生成代理
		Farm proxy = (Farm)handler.getProxy();
		
		proxy.product();
		
	}
}

优点：

1. 具备静态代理的优点
2. 不再需要写代理类，调用代理处理程序生成动态代理，只需要提供代理的接口