代理的概念与作用
要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等
编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易
Eg： class X
{
void sayHello(){}
}
Xproxy{//既能实施原来的类，又能得到一些其他的信息
starttime
X.sayHello();
endtime;
}
面向方面的编程Aspect oriented program简称AOP
系统中存在交叉业务，一个交叉业务就是要切入到系统的一个方面，如下所示：
StudentService CourseService MiscService 三个对象都要有三个功能，包括安全，事物，日志，每个功能都贯穿每个类，AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果一样。使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术
动态代理技术
要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态的代理方式，将是一件非常麻烦的事情！写成百上千个代理类，很累
JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用做代理类，即动态代理类
JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标代理类
CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库
代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
1 在调用目标方法之前
2 在调用目标方法之后
3 在调用目标方法前后
4在处理目标方法异常的catch块中
分析JVM动态生成的类
创建实现了Collection接口的方法类和查看其名称，分析Proxy.getProxyClass方法的各个参数
编码列出动态类中的所有构造方法和参数签名
编码列出动态类中的所有方法和参数签名
创建动态类的实例对象
用反射获得构造方法
编写一个最简单的invocationHandler类
调用构造方法创建动态类的实例对象，并将编写的invocationHandler类的实例对象传进去
打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常
将创建动态类的实例对象的代理改成匿名内部类的形式编写
总结：
在单线程的情况下用StringBuilder，在多线程的情况下用StringBuffer ，都是往字符串上动态的添加内容
Eg：
package cn.itcast.day3;
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 {
public static void main(String[] args) throws Exception{
Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
System.out.println(clazzProxy1.getName());
System.out.println("----------begin constructors list----------");
/*$Proxy0()
$Proxy0(InvocationHandler,int)*/
Constructor[] constructors = clazzProxy1.getConstructors();
for(Constructor constructor : constructors){
String name = constructor.getName();
StringBuilder sBuilder = new StringBuilder(name);
sBuilder.append(‘(‘);
Class[] clazzParams = constructor.getParameterTypes();
for(Class clazzParam : clazzParams){
sBuilder.append(clazzParam.getName()).append(‘,‘);
}
if(clazzParams!=null && clazzParams.length != 0)
sBuilder.deleteCharAt(sBuilder.length()-1);
sBuilder.append(‘)‘);
System.out.println(sBuilder.toString());
}
System.out.println("----------begin methods list----------");
/*$Proxy0()
$Proxy0(InvocationHandler,int)*/
Method[] methods = clazzProxy1.getMethods();
for(Method method : methods){
String name = method.getName();
StringBuilder sBuilder = new StringBuilder(name);
sBuilder.append(‘(‘);
Class[] clazzParams = method.getParameterTypes();
for(Class clazzParam : clazzParams){
sBuilder.append(clazzParam.getName()).append(‘,‘);
}
if(clazzParams!=null && clazzParams.length != 0)
sBuilder.deleteCharAt(sBuilder.length()-1);
sBuilder.append(‘)‘);
System.out.println(sBuilder.toString());
}
System.out.println("----------begin create instance object----------");
//Object obj = clazzProxy1.newInstance();
Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
class MyInvocationHander1 implements InvocationHandler{
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
return null;
}
}
Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHander1());
System.out.println(proxy1);
proxy1.clear();
//proxy1.size();
//System.out.println("111111111111111");
Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
return null;
}
});
final ArrayList target = new ArrayList();//方法中的内部类要能访问局部//变量，局部变量必须加final
Collection proxy3 = (Collection)getProxy(target,new MyAdvice());
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size());
System.out.println(proxy3.getClass().getName());
}
private static Object getProxy(final Object target,final Advice advice) {
Object proxy3 = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
/*new Class[]{Collection.class},*/
target.getClass().getInterfaces(),
new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
/*long beginTime = System.currentTimeMillis();
Object retVal = method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() + " running time of " + (endTime - beginTime));
return retVal;*/
advice.beforeMethod(method);
Object retVal = method.invoke(target, args);
advice.afterMethod(method);
return retVal;
}
}
);
return proxy3;
}
}
总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息？
三个方面：
生成的类中有哪些方法，通过让其他实现哪些接口的方式进行告知
产生的类字节码必须有个一个关联的类加载器对象
生成的类中的方法是怎样的也得由我们提供，把我们的代码写在一个约定好的接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入我的代码，提供执行代码的对象是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
用Proxy.newInstance方法直接一步就创建出代理对象
猜想分析动态生成的类的内部代码
动态生成的类实现了Collection接口(可以实现若干接口)，生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。
构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？
实现的Collection接口中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？
Client程序调用objProxy.add(“abc”);方法时，涉及三要素：objProxy对象、add方法、”abc”参数
代理类生成Collection接口的方法运行原理
Int size(){
Return handler.invoke(this,this.getClass().getMethod(“size”),null);
}
void clear(){
handler.invoke(this,this.getClass().getMethod(“clear”),null);
}
需要说明的是代理类继承了所有的Object类的方法，但是只会把hashCode，equals和toString交给invcationHandler去处理
让动态生成的类成为目标类的代理
Javascript是一种动态语言，可以把程序代码在运行的时候筛一段代码进来运行eval(“x=1+1”);
?x=2
我现在有一种需求就是，将long beginTime=System.currentTimeMills();
Object retVal=method.invoke(target, args);
Long endTime=System.currentTimeMillis();在运行的时候筛进来，而不是提前编写好，这样的好处是说，这部分代码可以换，我写这串字符串进来就是执行这部分代码，我写另一部分字符串进来就运行那部分代码。
怎样将目标类传递进去？
直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有世界意义
为InvocationHandler实现类注入咪表类的实例对象，不能采用匿名内部类的形式了。
让匿名invocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量
将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API
将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接受者只要调用这个对象的方法，即等于执行了外界提供的代码！
为bind方法增加一个Advice参数
实现AOP功能的封装与配置
工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。
BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#xxx=java.util.ArrayList
xxx=cn.itcast.ProxyFactoryBean
xxx.target=java.util.ArrayList
xxx.advice=cn.itcast.MyAdvice
ProxyFactoryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
目标
通知
编写客户端应用：
编写实现Advice接口的类和配置文件中进行配置
调用BeanFactory获取对象
原文：http://www.cnblogs.com/fred-zhang/p/3555861.html