Aop如何实现代理模式
Aop实现方法
上篇文章讲解了aop的概念，就是从类中抽取出方法，加强后再放回去，分为两种代理，JDK动态代理，Cglib代理。第一种当有接口的时候，第二种为没有接口的时候。
JDK动态代理
这里还是举那个例子，假设要完成客户类的项目，首先定义一个接口
public interface UserDao
{
public void save(); //定义一个保存方法
public void delete(); //定义一个删除方法
}然后让你给实现该类方法
public class UserDaoImpl implements UserDao
{
public void safe()
{
System.out.println("保存方法执行");
}
public void delete()
{
System.out.println("删除方法执行");
}
}然后让你将每个方法加上用户校验的步骤，上篇中说，如果实现多个接口，好几十种方法，你不可能每个方法种都加上用户校验，虽然很简单，复制粘贴 ，但是很冗余。所以这里用代理模式来实现该方法。
首先定义代理类，就是代理UserDaoImpl的类。
public calss UserImplProxy implements InvocationHandler //实现回调接口，它会实现一个invoke函数，就是你要在哪个类里面实现加强，哪个就继承该接口
{
private UserDao userDao; //定义一个接口
public jdkProxy(UserDao userDao)
{
this.userDao=userDao; //向上转型实例接口，它们用的都是java运行时多态技术，或者叫运行期绑定技术，在测试类里向上转型
}
public Object createProxy()
{
Object proxy= Proxy.newProxyInstance(userDao.getClass().getClassLoader(),userDao.getClass().getInterfaces(),this);//返回一个object类，就是你要代理的对象。
return proxy; //返回代理对象，这里其实已经完成增强封装。
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //invoke表示回调的意思，这里实现增强函数的操作在这里，当在上面newProxyInstance的第三个参数将该invoke函数封装在了里面调用的时候就会自动调用invoke，每个函数都会自动调用invoke
if("safe".equals(method.getName())) //实现拦截，当函数名称为save时候进行操作，实现校验。
{
System.out.println("用户校验执行");
}
return method.invoke(userDao,args); //回调函数，反射调用这个method执行save方法
}
}newProxyInstance函数参数里第一个参数为类加载器，就是你要代理的对象的类，第二个参数为接口加载器，就是代理对象实现的接口，第三个参数为你要实现加强函数的类对象，比如就在该类里面实现了加强函数invoke，所以就用this。这里就是产生了一个代理对象。
对于第三个参数不理解的可以阅读下面文章
Java动态代理InvocationHandler和Proxy学习笔记
在测试类里：
public class test {
@Test
public void test()
{
UserDao tt=new UserDaoImple(); //此处为向上转型实现接口，实例化接口
UserDao proxy; //定义一个接口对象
proxy=(UserDao)new jdkProxy(tt).createProxy();//用代理类来实例化接口，实例化后的对象就是增强后的
proxy.safe();
}
}Test测试后会出现下面结果
用户校验执行
保存方法执行这里实现了增强操作，但是还有一点就是你要求增强方法在原函数方法之前还是之后，后面讲解用配置方法来实现代理模式。
总结
jdk动态代理就是再创建一个类，传入该类一个向上转型后的接口对象，根据该对象用newProxyInstance去创建代理类，返回一个代理对象，同时调用定义好的增强函数（第三个参数）。当创建对象时候就是一个增强后的对象了。
Cglib动态代理
若没有实现任何接口，就是一个光秃秃的类，那么就简单了。就使用Cglib代理，其实cglib原理就是创建一个子类，然后实现加强但不像纵向继承那么麻烦。
首先定义一个用户类
public class UserDao {
public void save()
{
System.out.println("这是Sava方法");
}
public void delete()
{
System.out.println("这是delete方法");
}
}
还是上面那个业务场景，要对该类里面方法实现增强。实现用户校验功能
首先定义代理类
public class UserDaoProxy implements MethodInterceptor { //MethodInterceptor和InvocationHandler道理一样，你要将实现加强的函数放在哪个类，哪个类就实现该接口，同时也会让你实现增强函数
private UserDao userDao;
public UserDaoProxy(UserDao userDao)
{
this.userDao=userDao; //根据构造函数来获取需要代理对象的属性，来创造代理类
}
public Object CreateProxy ()
{
//创建核心类 它是一个字节码增强器，可以用来为无接口的类创建代理，它的功能与java自带的Proxy类挺相似的。它会根据某个给定的类创建子类
Enhancer enhancer=new Enhancer();
//获得需要代理的类。因为之前说了，cglib原理是创建一个子类
enhancer.setSuperclass(userDao.getClass()); //由传过来的对象可以获得它的属性即它是哪个类的
//设置回调函数，和jdk动态代理newProxyInstance一样，从这里调用增强函数，因为该类实现了MethodInterceptor接口，所以就在这个类里写增强函数，所以这里用this表示增强函数就在该类里
enhancer.setCallback(this);
//创建代理对象，很简单，将增强后的方法封装到Object类里，就可以根据这个创建对象
Object proxy=enhancer.create();
return proxy;
}
//这里就是增强函数，和JDK里的invoke（）函数一样，可以对照一下
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
if("save".equals(method.getName())) //当调用方法名称为save实现增强
{
System.out.println("用户校验");
}
return methodProxy.invokeSuper(proxy,args); //调用原来的save方法
}
}然后用Test来测试一下
public class test {
@Test
public void demo1()
{
UserDao userDao=new UserDao(); //定义一个对象
UserDao userDao1=(UserDao) newUserDaoProxy(userDao).CreateProxy(); //这里是向上转型，将子类对象赋值给父类对象
userDao1.save();
}
}
输出结果如下所示
用户校验
这是Sava方法由此可以看出实现了增强
总结
当你需要实现接口后的类需要增强的时候，用JDK动态代理，当没有实现接口时候，就为Cglib动态代理，这两种方法类似，都是将你要代理的类进行封装，也就是函数增强，但并不是重写函数，而是在函数里增加了方法。非常简单并且减少了代码量。这上面两个例子只是笨方法来帮助理解代理模式。下一篇文章为通过配置文件来实现代理模式。