AOP、AspectJ、JDK动态代理、CGLIB

这篇具有很好参考价值的文章主要介绍了AOP、AspectJ、JDK动态代理、CGLIB。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

AOP

  1. AOP(Aspect Orient Programming),作为面向对象编程的一种补充,广泛应用于处理一些具有横切性质的系统级服务,如事务管理、安全检查、缓存、日志记录管理等。
  2. AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理,AOP 代理则可分为静态代理和动态代理两大类。
  3. 其中静态代理是指使用AOP框架提供的命令进行编译,从而在编译阶段就可生成AOP代理类,因此也称为编译时增强;代表框架如:AspectJ
  4. 动态代理则在运行时借助于JDK动态代理、CGLIB 代码生成类库。在内存中“临时”生成AOP动态代理类,因此也被称为运行时增强。

AspectJ

  1. AspectJ其实是一套独立的面向切面编程的解决方案,与Spring没有关联关系。
  2. AspectJ 下载地址(http://www.eclipse.org/aspectj/downloads.php)
  3. 简单demo如下:
public class SayHelloService {
    public void say(){
        System.out.print("Hello  AspectJ");
    }
}

public aspect LogAspect {
    pointcut logPointcut():execution(void SayHelloService.say());
    after():logPointcut(){
         System.out.println("记录日志 ...");
    }
}

执行命令   ajc -d . SayHelloService.java LogAspect.java
生成 SayHelloService.class
执行命令    java SayHelloService
输出:
Hello AspectJ  
记录日志
  1. ajc.exe 可以理解为 javac.exe 命令,都用于编译 Java 程序,区别是 ajc.exe 命令可识别 AspectJ 的语法;我们可以将 ajc.exe 当成一个增强版的 javac.exe 命令;
  2. 执行ajc命令后的 SayHelloService.class 文件不是由原来的 SayHelloService.java 文件编译得到的,该 SayHelloService.class 里新增了打印日志的内容——这表明 AspectJ 在编译时“自动”编译得到了一个新类,这个新类增强了原有的 SayHelloService.java 类的功能,因此 AspectJ 通常被称为编译时增强的 AOP 框架。

JDK动态代理

  1. JDK的动态代理的写法比较固定,需要先定义一个接口和接口的实现类,然后再定义一个实现了InvocationHandler接口的实现类。然后调用Proxy类的newInstance()方法即可。示例代码如下:
//先定义一个接口:UserService,接口中有两个方法
public interface UserService {

    int insert();

    String query();
}

//再定义一个UserService接口的实现类:UserServiceImpl
public class UserServiceImpl implements UserService{

    @Override
    public int insert() {
        System.out.println("insert");
        return 0;
    }

    @Override
    public String query() {
        System.out.println("query");
        return null;
    }
}

//再定义一个InvocationHandler接口的实现类:UserServiceInvocationHandler。
//在自定义的InvocationHandler中,定义了一个属性:target
//定义这个属性的目的是为了在InvocationHandler中持有对目标对象的引用,target属性的初始化是在构造器中进行初始化的。
public class UserServiceInvocationHandler implements InvocationHandler {

    // 持有目标对象
    private Object target;

    public UserServiceInvocationHandler(Object target){
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("invocation handler");
        // 通过反射调用目标对象的方法
        return method.invoke(target,args);
    }
}

//通过Proxy.newProxyInstance()方法创建代理对象
public class MainApplication {
    public static void main(String[] args) {
        // 指明一个类加载器,要操作class文件,怎么少得了类加载器呢
        ClassLoader classLoader = MainApplication.class.getClassLoader();
        // 为代理对象指定要是实现哪些接口,这里我们要为UserServiceImpl这个目标对象创建动态代理,所以需要为代理对象指定实现UserService接口
        Class[] classes = new Class[]{UserService.class};
        // 初始化一个InvocationHandler,并初始化InvocationHandler中的目标对象
        InvocationHandler invocationHandler = new UserServiceInvocationHandler(new UserServiceImpl());
        // 创建动态代理
        UserService userService = (UserService) Proxy.newProxyInstance(classLoader, classes, invocationHandler);
        // 执行代理对象的方法,通过观察控制台的结果,判断我们是否对目标对象(UserServiceImpl)的方法进行了增强
        userService.insert();
    }
}

//输出:
invocation handler
insert
  1. 如何获取这个增强后的代理对象源码呢?通过在main方法增加一行代码:
//jdk8亲测可以
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

//高版本jdk请使用这个
System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
  1. 然后运行程序,就会在项目的根目录下生成一个包:com.sun.proxy。包下有一个文件$Proxy0.class。在idea打开,发现就是所产生代理类的源代码,源代码如下:
public final class $Proxy0 extends Proxy implements UserService {
    private static Method m1;
    private static Method m3;
    private static Method m4;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int insert() throws  {
        try {
            return (Integer)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String query() throws  {
        try {
            return (String)super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.tiantang.study.UserService").getMethod("insert");
            m4 = Class.forName("com.tiantang.study.UserService").getMethod("query");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}
  1. 通过源码我们发现,$Proxy0类继承了Proxy类,同时实现了UserService接口,所以JDK只能通过接口去实现动态代理。因为Java中不支持多继承,而JDK的动态代理在创建代理对象时,默认让代理对象继承了Proxy类。
  2. $Proxy0实现了UserService接口,所以重写了接口中的两个方法($Proxy0同时还重写了Object类中的几个方法)。所以当我们调用query()方法时,先是调用到$Proxy0.query()方法,在这个方法中,直接调用了super.h.invoke()方法,父类是Proxy,父类中的h就是我们定义的InvocationHandler,所以这儿会调用到UserServiceInvocationHandler.invoke()方法。因此当我们通过代理对象去执行目标对象的方法时,会先经过InvocationHandler的invoke()方法,然后在通过反射method.invoke()去调用目标对象的方法,因此每次都会先打印invocation handler这句话。
  3. Spring中有挺多功能都是使用的JDK动态代理增强来实现的,如声明式事务@Transactional,声明异步方法@Async。但如果我们用的是this对象来调用相应的方法,没有用代理对象去调用方法。那其实方法是没有得到增强处理的,也就是我们常见的事务失效等场景。

CGLIB

  1. CGLIB(Code Generation Library)它是一个代码生成类库。它可以在运行时候动态是生成某个类的子类。
  2. Jdk代理生成的代理类只有一个,因而其编译速度是非常快的;而由于被代理的目标类是动态传入代理类中的,在执行完代理方法后再通过反射去调用目标对象的方法。所以Jdk代理的执行效率相对来说低一点;
  3. Cglib代理需要为每个目标类生成相应的子类,因而在实际运行过程中,其可能会生成非常多的子类,过多的子类始终不是太好的,因为这影响了虚拟机编译类的效率;但由于在调用过程中,代理类的方法是已经静态编译生成了的(已经在子类中把目标对象的方法进行织入了),因而Cglib代理的执行效率相对来说高一些。
  4. CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM(Java字节码操控框架),来转换字节码并生成新的类。
  5. 具体实现可以参考Spring中ConfigurationClassPostProcessor对带有@Configuration注解的类的增强处理。具体方法路径参考此文章文末:https://blog.csdn.net/ab1024249403/article/details/127329871

文章来源地址https://www.toymoban.com/news/detail-674501.html

到了这里,关于AOP、AspectJ、JDK动态代理、CGLIB的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【spring】jdk动态代理和cglib动态代理的区别

    一、说明 1.spring aop中的动态代理主要有两种方式,jdk动态代理和cglib动态代理 2.从实现接口、继承父类的角度讨论区别 3.从限制角度讨论区别 4.从性能上讨论区别 二、区别 1.jdk动态代理只提供接口类的代理,如果目标类不是接口,只能用cglib代理 2.jdk动态代理会在运行时为目

    2024年02月16日
    浏览(40)
  • Spring之CGLIB和JDK动态代理底层实现

    目录 CGLIB 使用示例-支持创建代理对象,执行代理逻辑 使用示例-多个方法,走不同的代理逻辑 JDK动态代理 使用示例-支持创建代理对象,执行代理逻辑 ProxyFactory 如何自动在CGLIB和JDK动态代理转换 使用示例-使用CGLIB代理方式 使用示例-使用JDK动态代理方式 Spring会自动在JDK动态

    2024年04月25日
    浏览(28)
  • Android里使用AspectJ实现AOP

     前言 已经正式从NET转型JAVA。今后开始多写一点JAVA相关的文章。 Aspectj提供一种在字符串里编程的模式,即在字符串里写函数,然后程序启动的时候会动态的把字符串里的函数给执行了。 例如: 这里的execution就是一个函数,我们调用它,然后传递的参数是【* *(..)】。 Aspe

    2024年02月22日
    浏览(31)
  • Java里使用AspectJ实现AOP

     前言 已经正式从NET转型JAVA。今后开始多写一点JAVA相关的文章。 因为已经正式转Java了,所以,对于Java的一些判断,应该就比以前更准确了。总得来说,java有好的东西,有不好的东西,就语言本身和java的常用组件来讲,并不能判断,java比其他语言高一个档次,当然,也不

    2024年02月22日
    浏览(36)
  • Spring学习(五):一篇讲清楚动态代理(jdk和cglib)的使用、原理和源码

    目录 一、jdk动态代理的基本使用 二、cglib动态代理的基本使用 2.1 方法一:method.invoke() 方法反射调用 2.2 方法二(spring使用的这个方法): methodProxy.invoke() 2.3 方法三:methodProxy.invokeSuper() 三、jdk实现代理的原理  四、jdk实现代理的源码 五、jdk对代理的优化  六、cglib实现动

    2023年04月14日
    浏览(44)
  • JDK 动态代理(Spring AOP 的原理)(面试重点)

            也叫委托模式.定义:为其他对象提供⼀种代理以控制对这个对象的访问.它的作⽤就是通过提供⼀个代理类,让我们 在调⽤⽬标⽅法的时候,不再是直接对⽬标⽅法进⾏调⽤,⽽是通过代理类间接调⽤,在某些情况下,⼀个对象不适合或者不能直接引⽤另⼀个对象,⽽代

    2024年01月22日
    浏览(39)
  • JDK动态代理和CGLIB动态代理

    JDK动态代理和CGLIB动态代理 ① JDK动态代理只提供接口的代理,不支持类的代理,要求被代理类实现接口。JDK动态代理的核心是InvocationHandler接口和Proxy类,在获取代理对象时,使用Proxy类来动态创建目标类的代理类(即最终真正的代理类,这个类继承自Proxy并实现了我们定义的

    2024年02月07日
    浏览(43)
  • 【动态代理】JDK动态代理与cglib动态代理源码解析

    UserService ,接口类 UserServiceImpl ,实现类 使用代理,测试效果。 控制台输出: Proxy#newProxyInstance ,生成代理类的实例。 核心在于 getProxyClass0 ,生成代理类的类信息 使用自定义的InvocationHandler作为参数,调用构造函数获取代理类对象实例 WeakCache#get ProxyClassFactory#apply ,实现了

    2024年02月04日
    浏览(43)
  • 代理模式:静态代理+JDK/CGLIB 动态代理

    代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问,这样就可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功能。 代理模式的主要作用是扩展目标对象的功能,比如说在目标对象的某个方法

    2024年02月13日
    浏览(35)
  • 通俗易懂 快速理解 JDK动态代理 和 cglib动态代理

    动态代理的实现方案有两种, JDK动态代理 和 CGLIB动态代理 ,区别在于JDK自带的动态代理,必须要有接口,而CGLIB动态代理有没有接口都可以。 JDK动态代理 :JDK原生的实现方式,需要被代理的目标类必须实现接口。因为这个技术要求 代理对象和目标对象实现同样的接口 (兄

    2024年02月08日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包