设计模式--代理模式

1 静态代理模式
抽象角色–一般使用接口或者抽象类来实现。
被代理的角色–被代理的角色
代理角色–代理真实角色。代理真实角色后一般会做一些附属操作。
客户–使用代理角色来进行一些操作。
优点:真实角色变得更加的纯粹，各个类分工明确，不再关注公共的事情，公共的业务由代理来完成，实现了业务的分工。公共业务发生扩展时，变得更加集中和方便，实现解耦。
缺点：类增加了，工作量变多了。开发效率降低了。
抽象角色：

public interface UserService {
	public void add();
	public void delete();
	public void update();
	public void select();
}

被代理的角色：

public class UserServiceImpl implements UserService{
	@Override
	public void add() {
		// TODO Auto-generated method stub
		System.out.println("add()");
	}
	@Override
	public void delete() {
		// TODO Auto-generated method stub
		System.out.println("delete");
	}
}

代理角色：

public class UserServiceProxy implements UserService{
	private UserService userService;
	public UserServiceProxy(UserService userService) {
		this.userService = userService;
	}
	@Override
	public void add() {
		// TODO Auto-generated method stub
		log("add");
		userService.add();
	}

	@Override
	public void delete() {
		// TODO Auto-generated method stub
		log("delete");
		userService.delete();
	}

	private void log(String methodName){
		System.out.println(methodName);
	}
}

客户通过调用代理对象完成对业务的调用。
另外一个化抽象为通俗化的例子，房东，中介，看房者。
抽象行为：出租房子

public interface Rent {
	public void rent();
}

被代理角色：房东

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

代理对象：中介

public class Proxy implements Rent{
	private Host host;
	public Proxy(Host host) {
		super();
		this.host = host;
	}
	public void rent(){
		seeHello();
		host.rent();
		fare();
	}
	public void seeHello(){
		System.out.println("带客户去看房");
	}
	public void fare(){
		System.out.println("收中介费");
	}
}

客户：

public class Client {
	public static void main(String[] args){
		Host host=new Host();
		Proxy proxy=new Proxy(host);
		proxy.rent();
	}
}

说明：客户需要房子，可是大部分房子被中介机构掌握，大部分客户只能通过中介来租房子，中介本身是没房子的，但是有大量房东的房子，客户通中介这个代理来租房子，同时收取一部分的费用，收费的业务和出租的业务在不同的类中，通过代理模式，将出租和收中介费整合在一起，但是各个业务之间相互解耦。
例子出自某学堂的视频。

2 动态代理
2.1 基于接口的动态代理，jdk动态代理–Proxy类和InvocationHandler类
说明：jdk动态代理的应用前提，必须是目标类基于统一的接口。如果没有上述前提，jdk动态代理不能应用。从InvocationHandler这个名称我们就可以知道，实现了这个接口的中介类用做“调用处理器”。当我们调用代理类对象的方法时，这个“调用”会转送到invoke方法中，代理类对象作为proxy参数传入，参数method标识了我们具体调用的是代理类的哪个方法，args为这个方法的参数。这样一来，我们对代理类中的所有方法的调用都会变为对invoke的调用，这样我们可以在invoke方法中添加统一的处理逻辑(也可以根据method参数对不同的代理类方法做不同的处理)。
接口：

public interface Rent {
	public void rent();
}

实现类：

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

代理类：

public class ProxyInovationHandler implements InvocationHandler {
	//真实对象
	private Rent rent;
	public void setRent(Rent rent) {
		this.rent = rent;
	}
	/**
	 * 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
	 */
	public Object getProxy() {
		//第一个参数为定义代理类的类加载器，第二个参数为代理类的接口列表，
		//第三个为指派方法调用的调用处理程序
		return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent
				.getClass().getInterfaces(), this);
	}
	/**
	 * 在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。 
	 * proxy 在其上调用方法的代理实例对象
	 * method 对应于在代理实例上调用的接口方法的 Method实例
	 * args 包含传入代理实例上方法调用的参数值的对象数组
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		log(method.getName());
		//执行代理实例上的接口方法，第一个参数为方法的实例对象，第一个参数为该方法的参数数组
		Object result = method.invoke(rent, args);
		System.out.println("返回"+result);
		return result;
	}
	public void log(String methodName){
		System.out.println("执行："+methodName);
	}
}

测试：

public class Client {
	public static void main(String[] args) {
		Host host = new Host();
		ProxyInovationHandler proxyInovationHandler = new ProxyInovationHandler();
		proxyInovationHandler.setRent(host);
		//该处可以了解为创建了一个虚拟类，
		Rent proxy = (Rent) proxyInovationHandler.getProxy();
		proxy.rent();
	}
}

至于是谁调用的invoke，推荐看一篇文章博主讲得蛮好：
http://rejoy.iteye.com/blog/1627405，感谢博主分享。

2.2 基于类的动态代理，cglib。
CGLib原理是动态生成被代理类的子类。需要添加cglib-2.2.0.jar架包.
被代理类:

public static void main(String[] args) {  
  CglibProxy proxy = new CglibProxy();  
  //通过生成子类的方式创建代理类  
  SayHello proxyImp = (SayHello)proxy.getProxy(SayHello.class);  
  proxyImp.say();  
 }  

实现动态代理:

public class CglibProxy implements MethodInterceptor {

	private Enhancer enhancer = new Enhancer();
	/**
	 * 生成一个被代理的子类
	 * @param clazz
	 * @return
	 */
	public Object getProxy(Class clazz) {
		// 设置需要创建子类的类
		enhancer.setSuperclass(clazz);
		enhancer.setCallback(this);
		// 通过字节码技术动态创建子类实例
		return enhancer.create();
	}

	/**
	 * 拦截方法的执行
	 */
	public Object intercept(Object obj, Method method, Object[] args,
			MethodProxy proxy) throws Throwable {

		System.out.println("前置代理");
		// 通过代理类调用父类中的方法
		Object result = proxy.invokeSuper(obj, args);
		System.out.println("后置代理");
		return result;
	}
}

测试:

public class DoCGLib {
	
	public static void main(String[] args) {
		CglibProxy proxy = new CglibProxy();
		// 通过生成子类的方式创建代理子类
		SayHello proxyImp = (SayHello) proxy.getProxy(SayHello.class);
		//执行
		proxyImp.say();
	}
}

JDK与Cglib代理对比
1 JDK只能针对有接口的类的接口方法进行动态代理
2 Cglib基于继承来实现代理，无法对static、final类进行代理
3 Cglib基于继承来实现代理，无法对private、static方法进行代理。

Spring中的代理，主要在DefaultAopProxyFactory类的createAopProxy方法
如果目标对象实现了接口，则默认采用JDK动态代理
如果目标对象没有实现接口，则采用Cglib进行动态代理
可以强制使用Cglib实现代理：

//强制使用Cglib
@EnableAspectJAutoProxy(proxyTargetClass =true)

参考:http://blog.csdn.net/yakoo5/article/details/9099133/
未完待续。。。