学习Spring之动态代理

最近上班工作不是很忙，就补了一下基础知识，在传智播客上找了一些免费的视频，下载下来慢慢看，为了让自己很好的吸收，还是要多动手实践啊

在讲动态代理之前先做一个很好理解的静态代理的小例子：

说到代理，很容易想到的就是中介，例如房屋中介，不仅代替房东（房东本人也可以讲房屋出租给客户）将房屋出租给客户（基本业务接口），还收取了中介费，转化为代码

房租出租业务接口：

public interface RentInterface {
	public void rent();
}

房东实现房屋出租：

public class Host implements RentInterface{
	
	public void rent() {
		System.out.println("房屋出租");		
	}

}

中介实现房屋出租：

public class HouseProxy implements RentInterface {
	private Host host;
	public void setHost(Host host) {
		this.host = host;
	}
	//构造方法
	public HouseProxy(Host host) {
		super();
		this.host = host;
	}

	@Override
	public void rent() {
		//不仅实现了房屋出租还收取了中介费
		host.rent();
		System.out.println("收取中介费");
	}

}

客户从代理那里租房：

public class client {
	public static void main(String[] args) {
		System.out.println("客户来了");
		Host host=new Host();
		HouseProxy houseProxy=new HouseProxy(host);
		houseProxy.rent();
	}
}

运行结果：

可以看到使用静态代理的明显优点是不仅可以实现原来的业务接口，还能添加些属于自己的的业务，使得原来的业务接口更加纯粹

缺点：一个业务接口需要一个代理实现类，增加开发代码量

接着便是静态代理的升级版——动态代理

主要有两种实现方式：

1、基于接口的动态代理——jdk动态代理

2、基于类的动态代理——cglib

这里主要讲jdk动态代理

先看下API文档说明（其实我看了也真的不理解）

则之前的静态代理代码中只需要改动：

public class HouseProxy implements InvocationHandler {
	private Object target;

	public void setTarget(Object target) {
		this.target = target;
	}
	public Object getProxy() {
		/**
		 * 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
		 * newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)
		 *@param     loader定义代理类的类加载器 
		 *@param 	 interfaces - 代理类要实现的接口列表 
		 *@param   	 h - 指派方法调用的调用处理程序 
		 * */
		return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		log(method.getName());
		Object result = method.invoke(target, args);
		return result;
	}
	public void log(String methodName){
		System.out.println("调用了"+methodName+"方法");
	}

}

public class client {
	public static void main(String[] args) {
		System.out.println("客户来了");
		/*Host host=new Host();
		HouseProxy houseProxy=new HouseProxy(host);
		houseProxy.rent();*/
		Host host=new Host();
		HouseProxy proxy = new HouseProxy();
		proxy.setTarget(host);
		RentInterface host2=(RentInterface)proxy.getProxy();
		host2.rent();
		
	}
}

为了更好的理解，我们再引入一个业务接口卖东西：

public interface SellInterface {
	public void sell();
}

超市实现商品销售：

public class Market implements SellInterface{
	
	public void sell() {
		System.out.println("卖商品");
		
	}

}

客户即可以通过代理实现房屋出租，也可以买东西

public class client {
	public static void main(String[] args) {
		System.out.println("客户来了");
		/*Host host=new Host();
		HouseProxy houseProxy=new HouseProxy(host);
		houseProxy.rent();*/
		Host host=new Host();
		HouseProxy proxy = new HouseProxy();
		proxy.setTarget(host);
		RentInterface host2=(RentInterface)proxy.getProxy();
		host2.rent();
		Market market = new Market();
		proxy.setTarget(market);
		SellInterface sellInterface=(SellInterface)proxy.getProxy();
		sellInterface.sell();
	}
}

不难发现，相比于静态代理，动态代理大大实现了代码简化及高效利用，无论有多少个业务接口，只要一个动态代理实例都能进行实现

动态代理其实它的编码思想是一种代理模式，对于项目来说，公共的必不可少单独实现又繁琐的业务都可以利用动态代理来实现，如日志、事物、缓存、安全权限、异常处理……