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去创建代理类,返回一个代理对象,同时调用定义好的增强函数(第三个参数)。当创建对象时候就是一个增强后的对象了。
Aop如何实现代理模式_第1张图片

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

你可能感兴趣的:(Spring,spring)