标签：java spring aop proxy invocationhandler
在学习spring的aop的时候，老师叫我们使用java的proxy和InvocationHandler来模拟spring的aop。
首先要了解什么是代理：所谓代理就是我想让小王去买包烟，但是我又不想直接通知小王，因为那样我感觉自己非常的掉价。所以我就叫小李去通知小王，让小王完成这件事。在这个过程中，我是一个主动方，小王是一个行为执行方，而小李就是一个代理。因为小李负责我和小王之间的关系，甚至小李也可以叫小王给自己再买一包烟（实际这就是动态代理的最大用处）。
动态代理模式有代理对象，被代理对象。而在代理模式中还需要注意的一点就是，我们生成的代理对象，一般是要和被代理对象使用相同的接口的，这样就可以面向接口编程，所有被代理对象有的方法，我们生成的代理对象也都有，并且方法的功能还增强了。
下面就用代码模拟一下：
package cn.wsy.dao;
/**
*
* 项目名称 spring_aop
* 作者 tim
* 创建时间 2014-7-25
* 类描述 用户dao接口
*/
public interface UserDao {
/**
* 保存
*/
public void save();
/**
* 删除
*/
public void delete();
}
package cn.wsy.dao.impl;
import cn.wsy.dao.UserDao;
/**
*
* 项目名称 spring_aop
* 作者 tim
* 创建时间 2014-7-25
* 类描述 UserDao接口的实现类
*/
public class UserDaoImpl implements UserDao {
@Override
public void save() {
System.out.println("UserDaoImpl save start...");
}
@Override
public void delete() {
// TODO Auto-generated method stub
System.out.println("UserDaoImpl delete start...");
}
}
package cn.wsy.interceptor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Date;
/**
*
* 项目名称 spring_aop
* 作者 tim
* 创建时间 2014-7-25
* 类描述 将需要织入的方法织入到被代理对象调用方法的前后
*/
public class LogInterceptor implements InvocationHandler{
/**被代理对象**/
private Object target;
/**需要织入的方法**/
public void beforeMethod(Method method){
System.out.println(method.getName()+"start"+new Date());
}
/**
* proxy 代理实例，一般用不到
* method 代理实例的方法，通过它可以对目标代理类进行发射调用
* args 代理实例的方法的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
//织入方法
beforeMethod(method);
//执行被代理对象的方法
method.invoke(target, args);
return null;
}
public Object getTarget() {
return target;
}
public void setTarget(Object target) {
this.target = target;
}
}
package cn.wsy.test;
import java.lang.reflect.Proxy;
import cn.wsy.dao.UserDao;
import cn.wsy.dao.impl.UserDaoImpl;
import cn.wsy.interceptor.LogInterceptor;
/**
* 项目名称 spring_aop
* 作者 lenovo
* 创建时间 2014-7-25
* 类描述 使用jdk 的proxy和 InvocationHandler模拟spring的aop
*/
public class AopTest {
public static void main(String[] args) {
UserDao userDao = new UserDaoImpl();
LogInterceptor log = new LogInterceptor();
log.setTarget(userDao);
/**
* 第一个参数是被代理对象的加载器，必须和被代理对象使用一个类加载器
* 第二个参数是代理对象实现的接口，该接口被代理对象也实现，保证返回的是面向接口的编程
* 第三个参数是派生出来的代理处理程序
*/
UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(
UserDao.class.getClassLoader(), new Class[] { UserDao.class },
log);
userDaoProxy.delete();
userDaoProxy.save();
}
}
首先我们的Proxy代理对象一个实现了和被代理对象相同的接口的，由此可知，我们的代理对象也拥有被代理对象的方法。那么问题在于代理对象的这些方法是怎么实现的呢。
我们肯定会想到它一定是调了InvocationHandler中的invoke方法。而在该方法中最主要的就是Method和args两个参数。如果得到这两个参数，那么代理对象调用InvocationHandler中的invoke方法就没有问题了。在Proxy的参数中有一个类启动器的参数，通过这个参数我们就可以得到调用的方法。例如：
userDaoProxy中也有一个save方法，那么
UserDao.class.getMethod就可以得到调用的方法名，那得到方法当然就可以得到参数了，从而就可以调用InvocationHandler中的invoke方法，那么就成功对被代理类的方法进行了织入。所以上面的问题也就解决了。从而动态代理的接口方法也就实现了。这也就是动态代理的过程啦。
如有不对的地方大家一起交流。
java proxy InvocationHandler 模拟 spring aop,布布扣,bubuko.com
java proxy InvocationHandler 模拟 spring aop
标签：java spring aop proxy invocationhandler
原文地址：http://blog.csdn.net/qfnu_cjt_wl/article/details/38112291
