动态代理简单来说就是当我们想调用某个对象的方法时，通常是通过对象直接调用对象自己的方法，然而有时我们并不能直接拿到给对象，而是只能拿到一个“代理”对象，通过代理对象去代理真实对象，调用真实对象的方法。那么问题来了，为什么不能直接拿到对象？代理对象代理真实对象又有写什么用呢？其实之所以用代理对象去代理（代处理）真实对象，就是想在真实对象调用方法前后做一些处理。java已经实现了动态代理，通过java.lang.reflect.InvocationHandler、java.lang.reflect.Method和java.lang.reflect.Proxy三个类实现。
package com.liujun.dynamicProxy;
/**
* 一个普通的接口
* @author asus
*
*/
public interface StudentI {
public void doing();
}
package com.liujun.dynamicProxy;
/**
* 普通对象的实现类
* @author asus
*
*/
public class RealStudent implements StudentI {
@Override
public void doing() {
System.out.println("我是一个学生");
}
}
package com.liujun.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 代理调用处理器
* @author asus
*
*/
public class ProxyHandler implements InvocationHandler {
//要代理的真实对象
private Object realObject;
public ProxyHandler(Object realObject) {
this.realObject=realObject;
}
@Override
public Object invoke(Object object, Method method, Object[] arg)
throws Throwable {
Object result;
//方法调用前
beforeDoing();
//调用真实对象的方法
result=method.invoke(this.realObject, arg);//调度方法的结果代表该对象obj的参数arg
//方法调用后
afterDoing();
return result;
}
/**
* 代理对象方法调用前调用该方法
*/
private void beforeDoing(){
System.out.println("beforeDoing()");
}
/**
* 代理对象方法调用后调用该方法
*/
private void afterDoing(){
System.out.println("afterDoing()");
}
}
package com.liujun.test;
import java.lang.reflect.Proxy;
import com.liujun.dynamicProxy.ProxyHandler;
import com.liujun.dynamicProxy.RealStudent;
import com.liujun.dynamicProxy.StudentI;
public class DynamicProxyTest {
public static void main(String[] args) {
//真实对象
StudentI student=new RealStudent();
//代理处理器
ProxyHandler proxyHandler=new ProxyHandler(student);
//通过代理处理器生成代理对象
StudentI proxyStuent=(StudentI) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), proxyHandler);
//代理对象代理调用真实对象的方法
proxyStuent.doing();
}
}
原文地址：http://blog.csdn.net/u010739551/article/details/43648723
