设计模式——代理模式

代理模式：为其他对象提提供一种代理以控制这个对象的访问。在某种情况下，一个对象不适合或者和不能直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。  代理模式符合开闭原则（Open-ClosedPrinciple， OCP）， 即对扩展开放，对修改关闭。 其实就是一个中介的功能。

扩展方法举例：据库连接池中连接的那个close方法, 普通的Connection的close方法是关闭连接, 而连接池中的连接的close方法只是把连接放回连接池, 而没有关闭连接, 这里就是使用了代理, 改变了Connection的close方法的行为。

代理模式的好处:代理有很多好处，比如一个已经在跑的系统，出现了一点问题，我们会采用代理模式或直接修改源代码。
直接修改源代码的最大隐患在于对别的系统功能造成不可预知的错误。
但通过代理模式，相当于在错误部位截断，然后修正错误，在继续运行程序，从而不对老系统造成任何的伤害。
代理在其中充当了‘桥梁作用’。

代理模式分为两种，静态代理和动态代理：

静态代理

代理对象，要实现与目标对象一样的接口；

// 接口
public interface IUserDao {

	void save();
}
/**
 * 目标对象
 *
 */
public class UserDao implements IUserDao{

	@Override
	public void save() {
		System.out.println("-----已经保存数据！！！------");
	}

}

/**
 * 代理对象(静态代理)
 * 	   代理对象，要实现与目标对象一样的接口
 *
 */
public class UserDaoProxy implements IUserDao{

	// 接收保存目标对象
	private IUserDao target;
	public UserDaoProxy(IUserDao target) {
		this.target = target;
	}
	
	@Override
	public void save() {
		System.out.println("开始事务...");
		
		target.save(); 			// 执行目标对象的方法
		
		System.out.println("提交事务...");
	}	
}
public class App {

	public static void main(String[] args) {
		// 目标对象
		IUserDao target = new UserDao();
		
		// 代理
		IUserDao proxy = new UserDaoProxy(target);
		proxy.save();  // 执行的是，代理的方法
	}
}

1）可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。

         2）缺点：

                   --》  因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。

                   --》  一旦接口增加方法，目标对象与代理对象都要维护。

动态代理（JDK代理）

1）代理对象，不需要实现接口；

         2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);

// 接口
public interface IUserDao {

	void save();
	
}
/**
 * 目标对象
 *
 */
public class UserDao implements IUserDao{

	@Override
	public void save() {
		System.out.println("-----已经保存数据！！！------");
	}

}
/**
 * 给所有的dao创建代理对象【动态代理】
 * 
 * 代理对象，不需要实现接口
 *
 */
public class ProxyFactory {

	// 维护一个目标对象
	private Object target;
	public ProxyFactory(Object target){
		this.target = target;
	}
	
	// 给目标对象，生成代理对象  
	public Object getProxyInstance() {
		return Proxy.newProxyInstance(
				target.getClass().getClassLoader(), 
				target.getClass().getInterfaces(),
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						System.out.println("开启事务");
						
						// 执行目标对象方法
						Object returnValue = method.invoke(target, args);
						
						System.out.println("提交事务");
						return returnValue;
					}
				});
	}
}
public class App {

	public static void main(String[] args) {
		// 目标对象
		IUserDao target = new UserDao();
		// 【原始的类型 class cn.itcast.b_dynamic.UserDao】
		System.out.println(target.getClass());
		
		// 给目标对象，创建代理对象
		IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
		// class $Proxy0   内存中动态生成的代理对象
		System.out.println(proxy.getClass());
		
		// 执行方法   【代理对象】
		proxy.save();
	}
}

代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！

Cglib代理（不需要实现接口）

1) 需要引入cglib – jar文件， 但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。

         2）引入功能包后，就可以在内存中动态构建子类

         3）代理的类不能为final， 否则报错。

         4） 目标对象的方法如果为final/static,那么就不会被拦截，即不会执行目标对象额外的业务方法。

/**
 * 目标对象
 *
 */
public class UserDao {

	public void save() {
		System.out.println("-----已经保存数据！！！------");
	}

}
/**
 * Cglib子类代理工厂
 * (对UserDao 在内存中动态构建一个子类对象)
 *
 */
public class ProxyFactory implements MethodInterceptor{
	
	// 维护目标对象
	private Object target;
	public ProxyFactory(Object target){
		this.target = target;
	}
	
	// 给目标对象创建代理对象
	public Object getProxyInstance(){
		//1. 工具类
		Enhancer en = new Enhancer();
		//2. 设置父类
		en.setSuperclass(target.getClass());
		//3. 设置回调函数
		en.setCallback(this);
		//4. 创建子类(代理对象)
		return en.create();
	}
	

	@Override
	public Object intercept(Object obj, Method method, Object[] args,
			MethodProxy proxy) throws Throwable {
		
		System.out.println("开始事务.....");
		
		// 执行目标对象的方法
		Object returnValue = method.invoke(target, args);
		
		System.out.println("提交事务.....");
		
		return returnValue;
	}

}

public class App {

	public static void main(String[] args) {
		// 目标对象
		UserDao target = new UserDao();
		// class cn.itcast.c_cglib.UserDao
		System.out.println(target.getClass());
		
		// 代理对象
		UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
		// UserDao子类：class cn.itcast.c_cglib.UserDao$$EnhancerByCGLIB$$25d4aeab
		System.out.println(proxy.getClass());
		
		// 执行代理对象的方法
		proxy.save();
	}
}