代理

动态代理技术可以动态的生成一段内部有一个被扩展类引用的代码，生成的类类似于用组合这种方式，并把它动态的编译成class文件，然后装载进jvm中执行。著名的框架Spring的核心技术之一aop就是使用的就是动态代理技术。

 Java中为动态代理提供了支持，用到了类Proxy用于产生代理，还有一个接口InvocationHandler，用于在被代理的类的方法前后加入处理逻辑，这个接口内部有一个invoke方法，invoke接受三个参数，

代理Proxy 基本概念

安全、事物、日志要贯穿到好多模块中，就是交叉业务

AOP面向方面编程

目标：要使交叉业务模块化，将切面代码移动到原始方法的周围
代理是实现AOP功能的核心和关键技术

JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类

1）JVM生成的动态类必须实现一个或多个接口，JVM生成的动态类只能用作具有相同接口的目标类的代

理
    2）CGLIB库可以动态生成一个类的子类一个类的子类也可以用作该类的代理。，如果要为一个没有实现

接口的类生成动态代理类，那么可以使用CGLIB库
    代理方法在系统代码位置
    1）在调用模板方法之前
    2）在调用模板方法之后
    3）在调用模板方法之前后
    4）在处理目标方法异常的catch块中

二、创建代理
InvocationHandler接口
    创建实现Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数

    创建动态类的实例对象
       1）用反射获得构造方法
       2）编写一个简单的InvocationHandler类
       3）调用构造方法创建动态类的实例对象，并编写的InvocationHandler类的实例对象穿进去
   InvocationHandler的运行原理
创建某一接口 MyInterface的代理：
     InvocationHandler handler = newMyInvocationHandler(...);
            代理实例调用处理程序实现的接口，对代理实例调用方法时，将对方法调用进行编码并将其指

派到它的调用处理程序的 invoke方法
Class proxyClass = Proxy.getProxyClass(MyInterface.class.getClassLoader(), new Class[] { MyInterface .class });
得到接口代理类的类加载器，要接口数组(因为可能要加载的不是一个接口)
MyInterface myint = (MyInterface ) proxyClass.getConstructor(newClass[]{               

 InvocationHandler.class}).newInstance(new Object[] { handler });

创建代理的示例代码：

package lianxi;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class proxytest {

	/**
	 * @param args
	 * @throws Exception
	 * @throws SecurityException
	 */
	public static void main(String[] args) throws SecurityException, Exception {
		// TODO Auto-generated method stub

		Class clazz = Proxy.getProxyClass(Collection.class.getClassLoader(),
				Collection.class);
		Constructor[] Constructors = clazz.getConstructors();
		for (Constructor constructor : Constructors) {
			StringBuilder sb = new StringBuilder();
			sb.append("(");
			Class[] paramclazzs = constructor.getParameterTypes();
			for (Class paramclazz : paramclazzs) {
				sb.append(paramclazz.getName());
				sb.append(",");
			}
			if (paramclazzs.length != 0)
				sb.deleteCharAt(sb.length() - 1);
			sb.append(")");
			System.out.println(constructor.getName() + sb.toString());
		}
		class myInvocationHandler implements InvocationHandler {

			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				// TODO Auto-generated method stub
				return null;
			}

		}

		final ArrayList Target = new ArrayList();
		Collection coll1 = (Collection) getProxy(Target);
		coll1.add("123");
		coll1.add("456");
		coll1.add("ert");
		// System.out.println(coll1);
		System.out.println(Target);

		/*
		 * System.out.println("*************************************"); Method[]
		 * methods=clazz.getMethods(); for(Method method:methods){ StringBuilder
		 * sb=new StringBuilder(); sb.append("("); Class[]
		 * paramclazzs=method.getParameterTypes(); for(Class
		 * paramclazz:paramclazzs){ sb.append(paramclazz.getName());
		 * sb.append(","); } if(paramclazzs.length!=0)
		 * sb.deleteCharAt(sb.length()-1); sb.append(")");
		 * System.out.println(method.getName()+sb.toString()); }
		 */
	}

	private static Object getProxy(final Object Target) {
		Object coll1 = Proxy.newProxyInstance(Target.getClass()
				.getClassLoader(), Target.getClass().getInterfaces(),
				new InvocationHandler() {

					@Override
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {

						// TODO Auto-generated method stub
						long starttime = System.currentTimeMillis();
						if ("123".equals(args[0]))
							args[0] = "hello";
						Object obj = method.invoke(Target, args);
						System.out.println("args:::" + args);
						// System.out.println("proxy:::"+proxy);
						long endtime = System.currentTimeMillis();
						System.out.println(method + "....runtime..."
								+ (endtime - starttime));
						return obj;
					}
				});
		return coll1;
	}
}