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动态代理，这两种方法类似，都是将你要代理的类进行封装，也就是函数增强，但并不是重写函数，而是在函数里增加了方法。非常简单并且减少了代码量。这上面两个例子只是笨方法来帮助理解代理模式。下一篇文章为通过配置文件来实现代理模式。