用Java的动态代理模拟spring的AOP

动态代理的定义如下：
http://java.sun.com/j2se/1.3/docs/guide/reflection/proxy.html
A dynamic proxy class is a class that implements a list of interfaces specified at runtime such that a method invocation through one of the interfaces on an instance of the class will be encoded and dispatched to another object through a uniform interface.
也就是说要用动态代理，那么一个类的行为需要实现统一的一个或多个接口才能实现，当这个类实例的方法被调用的时候，可以对之进行一些拦截处理。

另外一种关于动态代理的定义：
所谓Dynamic Proxy(动态代理)是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称 它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

拦截的用处很大，比如spring中关于hibernate数据库操作的事务管理和连接管理

下面是我写的小例子:

被调用类的接口类
package aop;

public interface DAO {
     public abstract void execute();
}
被调用类的实现类
package aop;

public class DAOImpl implements DAO {

     public void execute() {
         System.out.println("DAOImpl executing!");
     }
}
动态代理类
package aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler {
     private Object obj;
     public DynamicProxy(String beanImplClass){
         try {
             Class c = Class.forName(beanImplClass);
             obj = c.newInstance();
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         } catch (InstantiationException e) {
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         }
     }

     public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {
         System.out.println("proxy executing before invoke");
         method.invoke(obj, args);
         System.out.println("proxy executing after invoke");
         return null;
     }

}
bean管理类
package aop;

import java.lang.reflect.Proxy;

public class ApplicationContext {
     public static final String BEANNAME = "DAOBean";
     public static final String BEANIMPLCLASS = "aop.DAOImpl";
    
     public static Object getBean(String name){
         if(BEANNAME.equals(name)){
             Class beanImplClass = null;
             try {
                  beanImplClass = Class.forName(BEANIMPLCLASS);
             } catch (ClassNotFoundException e) {
                 e.printStackTrace();
             }
             DynamicProxy dynamicProxy = new DynamicProxy(BEANIMPLCLASS);
             return Proxy.newProxyInstance(beanImplClass.getClassLoader(), beanImplClass.getInterfaces(), dynamicProxy);
         }else{
             return null;
         }
     }
}
客户端
package aop;

public class Client {
     public static final String BEANNAME = "DAOBean";
     public static void main(String[] args){
         DAO dao = (DAO)ApplicationContext.getBean(BEANNAME);
         dao.execute();
     }
}