结构型模式-代理模式

1.代理模式

代理就是帮[目标对象]去完成它应该做，但是不想或者不擅长做的事情。
代理模式分为静态代理和动态代理
* 静态代理：就是编写一个代理类，去代理[目标对象]，在程序运行之前静态代理的.class文件已经存在了，只能服务于指定接口而不能服务于其他接口
* 动态代理：在运行期间，通过反射，对[目标对象]产生一个[代理对象]

2.动态代理

动态代理的实现方式分为两种，下面两种方式生成的代理类都是继承了Proxy：
* JDK实现的 ：基于接口的，也就是说[目标对象]必须实现一个接口，[目标对象]和[代理对象]都实现该接口
* cglib实现的 ：可以被继承的普通类，它是通过继承的方式，产生一个子类，这个子类就是代理类
示例：
定义目标对象接口

public interface UserService {

	void saveUser() ;
}

public class UserServiceImpl implements UserService {

	@Override
	public void saveUser() {
		System.out.println("添加用户");
	}
}

public class JDKProxyFactory implements InvocationHandler {

	//目标对象的引用
	private Object target;

	//通过构造方法将目标对象注入到代理对象中
	public JDKProxyFactory(Object target) {
		super();
		this.target = target;
	}

	/**
	 * @return
	 */
	public Object getProxy() {

		//如何生成一个代理类呢？
		//1、编写源文件
		//2、编译源文件为class文件
		//3、将class文件加载到JVM中(ClassLoader)
		//4、将class文件对应的对象进行实例化（反射）
		
		// Proxy是JDK中的API类
		// 第一个参数：目标对象的类加载器
		// 第二个参数：目标对象的接口
		// 第二个参数：代理对象的执行处理器
		Object object = Proxy.newProxyInstance(target.getClass().getClassLoader(),
				target.getClass().getInterfaces(), this);

		return object;
	}

	/**
	 * 代理对象会执行的方法
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("这是jdk的代理方法");
		// 下面的代码，是反射中的API用法
		// 该行代码，实际调用的是[目标对象]的方法
		// 利用反射，调用[目标对象]的方法
		Object returnValue = method.invoke(target, args);

		return returnValue;
	}
}

/**
 * 主要作用就是生成代理类
 * 使用CGLib动态代理技术实现 它是基于继承的方式实现的
 * @author think
 *
 */
public class CgLibProxyFactory implements MethodInterceptor{


	/**
	 * @param clazz
	 * @return
	 */
	public Object getProxyByCgLib(Class clazz) {

		// 创建增强器
		Enhancer enhancer = new Enhancer();
		// 设置需要增强的类的类对象
		enhancer.setSuperclass(clazz);

		// 设置回调函数
		enhancer.setCallback(this);

		// 获取增强之后的代理对象
		return enhancer.create();
	}

	/***
	 * Object proxy:这是代理对象，也就是[目标对象]的子类
	 * Method method:[目标对象]的方法
	 * Object[] arg:参数
	 * MethodProxy methodProxy：代理对象的方法
	 */
	@Override
	public Object intercept(Object proxy, Method method, Object[] arg, MethodProxy methodProxy)
			throws Throwable {
		// 因为代理对象是目标对象的子类
		// 该行代码，实际调用的是目标对象的方法
		// object :代理对象
		// 父类目标对象，调用父类目标对象中的方法
		System.out.println("这是cglib的代理方法");
		
		// 调用[目标对象]的方法
		Object returnValue = methodProxy.invokeSuper(proxy, arg);
		return returnValue;
	}
}

public class TestProxy {

	public static void main(String[] args)
	{
		TestProxy testProxy = new TestProxy();
		testProxy.testJDKProxy();
		testProxy.testCgLibProxy();
	}

	public void testJDKProxy() {
		
		//1、创建目标对象
		UserService service = new UserServiceImpl();
		
		//2、生成代理对象
		JDKProxyFactory proxyFactory = new JDKProxyFactory(service); 
		UserService proxy = (UserService) proxyFactory.getProxy();
		
		//生成class文件
		generatorClass(proxy);
		
		//3、调用目标对象的方法
		service.saveUser();
		System.out.println("===============");
		//4、调用代理对象的方法
		proxy.saveUser();
	}
	
	public void testCgLibProxy() {
		//创建目标对象
		UserService service = new UserServiceImpl();
		
		//生成代理对象
		CgLibProxyFactory proxyFactory = new CgLibProxyFactory();
		UserService proxy = (UserService) proxyFactory.getProxyByCgLib(service.getClass());
		
		//生成class文件
		generatorClass(proxy);
		//调用目标对象的方法
		service.saveUser();
		System.out.println("===============");
		//调用代理对象的方法
		proxy.saveUser();
	}
	
	private void generatorClass(Object proxy) {
		FileOutputStream out = null;
		try {
//			byte[] generateProxyClass = ProxyGenerator.generateProxyClass(proxy.getClass().getName(), new Class[] {proxy.getClass()});
			byte[] generateProxyClass = ProxyGenerator.generateProxyClass(proxy.getClass().getSimpleName(), new Class[] {proxy.getClass()});
			out = new FileOutputStream(proxy.getClass().getSimpleName()+".class");
			out.write(generateProxyClass);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (out != null) {
				try {
					out.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
				}
			}
		}
		
	}
}