cglib_dynamicProxy实现aop

Spring对接口实现类通过Dynamic Proxy实现AOP，而对于没有实现任何接口
的类通过CGLIB实现AOP机制的原因
public class TxHandler implements InvocationHandler {
 
  private Object originalObject;
 
  public Object bind(Object obj) {
   this.originalObject = obj;
   return Proxy.newProxyInstance(
      obj.getClass().getClassLoader(),
      obj.getClass().getInterfaces(),
         this);
}
public Object invoke(Object proxy, Method method, Object[]
  throws Throwable {
  Object result = null;
  if (!method.getName().startsWith("save")) {
    UserTransaction tx = null;
   try {
      tx = (UserTransaction) (
new InitialContext().lookup("java/
);
      result = method.invoke(originalObject, args);
      tx.commit();
    } catch (Exception ex) {
     if (null != tx) {
       try {
          tx.rollback();
        } catch (Exception e) {
        }
      }
    }
  } else {
    result = method.invoke(originalObject, args);
  }
  return result;
}
  Dynamic Proxy实现log aspect
 public class LogHandler implements InvocationHandler {
    private Logger logger =
            Logger.getLogger(this.getClass().getName());
   
    private Object delegate;
    public Object bind(Object delegate) {
        this.delegate = delegate;
        return Proxy.newProxyInstance(
                           delegate.getClass().getClassLoader(),
                           delegate.getClass().getInterfaces(),
                           this);
    }
    public Object invoke(Object proxy, Method method,
                         Object[] args) throws Throwable {
        Object result = null;
       
        try {
            log("method starts..." + method);
           
            result = method.invoke(delegate, args);
           
            logger.log(Level.INFO, "method ends..." + method);
        } catch (Exception e){
            log(e.toString());
        }
       
        return result;
    }
   
    private void log(String message) {
        logger.log(Level.INFO, message);
    }
}
 
  cglib说起来神奇，用起来一页纸不到就讲完了。
    它的原理就是用Enhancer类生成一个原有类的子类，则原有类的每个方法调用都会调用它的MethodInterceptor接口的public Object intercept(Object o,Method method,Object[] args,MethodProxy proxy)函数
    在intercept()函数里，你可以在执行Object result=proxy.invokeSuper(o,args);来执行原有函数，在执行前后加入自己的东西，也可以瞒天过海，完全干别的。
    1.AOP里讲了一百遍阿一百遍的log aspect在cglib是这样做的:
   public class LogDAOProxy implements MethodInterceptor
  {
       private Logger log=Logger.getLogger(AOPInstrumenter.class);
       private Enhancer enhancer=new Enhancer();
 
       //生成DAO的子类
       public Object getDAO(Class clz)
       {
           enhancer.setSuperclass(clz);
           enhancer.setCallback(this);
           return enhancer.create();
       }
 
      //默认拦截子类
      public Object intercept(Object o,Method method,Object[] args,MethodProxy proxy) throws Throwable
      {
           log.info("调用日志方法"+method.getName());
           Object result=proxy.invokeSuper(o,args);
           return result;
      }
}
    应用的代码:
    LOgDAOProxy proxy = new LogDAOProxy();
    GoodsDAO  dao = (GoodsDAO)proxy.getDAO(GoodsDAO.class);
    //dao.insert(goods);
2.而我今天小试菜刀实现的是一个高级的Decorator模式:
        上面的例子其实有点虚，因为DAO都是由Spring管理的，不能这么随便new出来。所以更实际采用Decorator模式，把方法实际扔给Spring管辖下的DAO去完成。但如果每个DAO, 每个方法的写Decorator函数会写死人的，所以用上cglib。注意黑体字的部分。
   public class LogDAOProxy implements MethodInterceptor
  {
       private Logger log=Logger.getLogger(AOPInstrumenter.class);
       private Object dao=null;
       private Enhancer enhancer=new Enhancer();
 
       //生成DAO的子类
       public Object getDAO(Class clz, Object dao)
       {
           this.dao = dao;
           enhancer.setSuperclass(clz);
           enhancer.setCallback(this);
           return enhancer.create();
       }
 
      //默认拦截子类
      public Object intercept(Object o,Method method,Object[] args,MethodProxy proxy) throws Throwable
      {
           log.info("调用日志方法"+method.getName());
           Object result=proxy.invoke(dao, args);
           return result;
      }
}
any other Things
　　
　　为方法调用增多一个参数的的代码段
　　
　　Object[] params = new Object[objects.length + 1];
        System.arraycopy(objects, 0, params, 0, objects.length);
        params[objects.length] = myParam;
        Object result = methodProxy.invoke(dao, params);