java 动态字节码技术和类加载

发布时间：2022-03-01 12:04:02 作者：yexindonglai@163.com 阅读（793）

 

字节码有什么用？

1、对类的基本信息进行操作 ，可以新增、删除、修改类、属性和方法；
2、应用场景：Lombok 插件、AOP、动态修改class文件、网页上的在线执行java代码也是字节码实现的；
2、Lombok 插件就是用字节码实现，只用Data注解就可以给属性自动加上get和set方法
4、

常见的字节码操作类库：

    BCEL：  深入汇编底层语言进行类库操作；
    ASM：  轻量级字节码操作框架，直接涉及到jVM底层的操作和指令；高性能、高质量 
    CGLB： 生成类库，基于ASM实现
    javassist ：开源框架，编辑和创建Java字节码的类库，我们这里主要介绍javassist


javassist 框架

    优势：比反射开销小、性能高；但是比ASM低；跟cglib差不多，使用简单。很多开源框架都在使用它。可进行修改已有方法的方法体（插入代码到已有方法体）、新增方法  、 删除方法；
    缺点：不支持数组初始化、不支持内部类和匿名类、不支持continue和break表达式、不支持泛型和枚举、某些继承关系也不支持；

 

类加载器

我们的代码运行的时候，首先会将后缀为java的文件编译成后缀为 class 的文件，class文件中保存着java代码转换后的虚拟机指令，当需要使用到某个类时，虚拟机会加载它的 class 文件，并创建class对象，将class加载到虚拟机内存，这个过程称为类加载，类加载过程图如下：

我们使用一个对象的时候，在虚拟机底层已经帮我们加载好了class对象，所以我们直接用就好了；

类加载器常用方法( ClassLoader）

  • loadClass(String)

    • 当类加载请求到来时，先从缓存中查找该类对象，如果存在直接返回，如果不存在则交给该类加载去的父加载器去加载，倘若没有父加载则交给顶级启动类加载器去加载，最后倘若仍没有找到，则使用findClass()方法去加载；

  • findClass(String)

    • 根据名称或者位置加载Class字节码，然后使用defineClass 通常由子类去实现，如果需要自定义ClassLoader的话，必须重写该方法。

  • defineClass(byte[] b, int off, int len)

    • defineClass()方法是用来将byte字节流解析成JVM能够识别的Class对象(ClassLoader中已实现该方法逻辑)，通过这个方法不仅能够通过class文件实例化class对象，也可以通过其他方式实例化class对象，如通过网络接收一个类的字节码，然后转换为byte字节流创建对应的Class对象，defineClass()方法通常与findClass()方法一起使用，一般情况下，在自定义类加载器时，会直接覆盖ClassLoader的findClass()方法并编写加载规则，取得要加载类的字节码后转换成流，然后调用defineClass()方法生成类的Class对象，简单地说就是把class字节码文件转化为虚拟机能识别的Class对象

  • resolveClass(Class≺?≻ c)

    • 使用该方法可以使用类的Class对象创建完成也同时被解析。前面我们说链接阶段主要是对字节码进行验证，为类变量分配内存并设置初始值同时将字节码文件中的符号引用转换为直接引用。

 

重新加载class  ，重写 findClass 方法

刚刚我们说到，使用  findClass(String)  方法可以实现重新加载class字节码文件，因为 findClass 方法在ClassLoader里面是  protected 修饰的，只能被子类调用，而且他里面没有实现方法，只抛出一个 ClassNotFoundException 的异常

所以我们需要重写 findClass 方法，让他能被外部对象调用，并添加加载class字节码文件的逻辑代码，代码如下：

  1. package com;
  2. import java.io.InputStream;
  3. import java.net.URL;
  4. public class MyClassLoader extends ClassLoader{
  5.     /**
  6.      * 加载class文件
  7.      * 重写此方法的目的是为了能让此方法被外部调用，父类的 findClass 是 protected 修饰的，只能被子类调用
  8.      * @param name   类的全类名 示例： com.xd.User
  9.      * @return
  10.      * @throws ClassNotFoundException
  11.      */
  12.     @Override
  13.     public Class<?> findClass(String name) throws ClassNotFoundException {
  14.         try {
  15.             // 获取class文件名称  去掉包路径
  16.             String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
  17.             // 获取文件输入流
  18.             InputStream is = this.getClass().getResourceAsStream(fileName);
  19.             // 读取字节
  20.             byte[] b = new byte[is.available()];
  21.             is.read(b);
  22.             // 将byte字节流解析成jvm能够识别的Class对象
  23.             return defineClass(name, b, 0, b.length);
  24.         } catch (Exception e) {
  25.             throw new ClassNotFoundException();
  26.         }
  27.     }
  28. }

 

使用javassist创建class字节码文件并运行

使用之前需要先导入相关的包

  1.         <!-- 字节码操作框架 -->
  2.         <dependency>
  3.             <groupId>org.javassist</groupId>
  4.             <artifactId>javassist</artifactId>
  5.             <version>3.20.0-GA</version>
  6.         </dependency>
  7.  
  8.         <!-- 处理解析json的类 -->
  9.         <dependency>
  10.             <groupId>com.alibaba</groupId>
  11.             <artifactId>fastjson</artifactId>
  12.             <version>1.2.76</version>
  13.         </dependency>

1、实战，接下来我们来创建于一个class类并执行里面的方法，代码如下

  1. package com;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import javassist.*;
  5.  
  6. import java.io.IOException;
  7. import java.lang.reflect.Constructor;
  8. import java.lang.reflect.InvocationTargetException;
  9. import java.lang.reflect.Method;
  10. import java.net.URL;
  11. import java.net.URLDecoder;
  12. public class MainCreate {
  13.  
  14.     /**
  15.      * 创建class类
  16.      * @param args
  17.      * @throws ClassNotFoundException
  18.      * @throws IOException
  19.      * @throws CannotCompileException
  20.      * @throws NotFoundException
  21.      * @throws NoSuchMethodException
  22.      * @throws IllegalAccessException
  23.      * @throws InvocationTargetException
  24.      * @throws InstantiationException
  25.      */
  26.     public static void main(String[] args) throws Exception {
  27.         new MainCreate().createClass();
  28.     }
  29.     
  30.     public void  createClass() throws Exception {
  31.  
  32.  
  33.         String className = "com.User";
  34.         Class cla = this.getClass();
  35.         // 获取class文件 所在绝对路径
  36.         URL resource = cla.getResource("/");
  37.         //获取class路径
  38.         String path = URLDecoder.decode(resource.getPath(), "UTF-8");
  39.  
  40.  
  41.         // 使用字节码技术修改class类文件信息
  42.  
  43.         ClassPool pool = ClassPool.getDefault(); // 从类池创建实例
  44.         CtClass ctClass = pool.makeClass(className);
  45.  
  46.         // 创建 loginName属性
  47.         CtField loginName = CtField.make("private String loginName;", ctClass);
  48.  
  49.         // 创建 pwd 属性
  50.         CtField pwd = CtField.make("private String password;", ctClass);
  51.  
  52.         // 年龄属性
  53.         CtField age = CtField.make("private Integer age;", ctClass);
  54.  
  55.         // 添加属性
  56.         ctClass.addField(loginName);
  57.         ctClass.addField(pwd);
  58.         ctClass.addField(age);
  59.  
  60.         // 创建loginName的get 和 set 方法
  61.         CtMethod loginSetMethod = CtMethod.make("public void setLoginName(String loginName){this.loginName = loginName;}", ctClass);
  62.         CtMethod loginGetMethod = CtMethod.make("public String getLoginName(){return this.loginName;}", ctClass);
  63.  
  64.         // 创建password的get 和 set 方法
  65.         CtMethod passwordSetMethod = CtMethod.make("public void setPassword(String password){this.password =  password;}", ctClass);
  66.         CtMethod passwordGetMethod = CtMethod.make("public String getPassword(){return this.password;}", ctClass);
  67.  
  68.         // 创建age的get 和 set 方法
  69.         CtMethod ageSetMethod = CtMethod.make("public void setAge(Integer age) { this.age = age; }", ctClass);
  70.         CtMethod ageGetMethod = CtMethod.make("public Integer getAge() { return age; }", ctClass);
  71.  
  72.         // 添加上面的get和set方法方法
  73.         ctClass.addMethod(loginGetMethod);
  74.         ctClass.addMethod(loginSetMethod);
  75.         ctClass.addMethod(passwordSetMethod);
  76.         ctClass.addMethod(passwordGetMethod);
  77.         ctClass.addMethod(ageSetMethod);
  78.         ctClass.addMethod(ageGetMethod);
  79.  
  80.  
  81.         // 添加show方法，无参方法，用来打印 一些信息
  82.         CtMethod showMethod = CtMethod.make("public void show(){System.out.println(\"我是用字节码创建出来的方法\");}", ctClass);
  83.         ctClass.addMethod(showMethod);
  84.         
  85.         // 添加show方法，有参 方法
  86.         CtMethod showHaveMethod = CtMethod.make("public void show(Integer num ,String value){System.out.println(\"我是用字节码创建出来的方法，num：\"+num+\",value：\"+value);}", ctClass);
  87.         ctClass.addMethod(showHaveMethod);
  88.  
  89.         // 添加有参构造函数  , 第一个参数是int 类型，第二个和第三个参数都是string类型
  90.         CtConstructor ctConstructor = new CtConstructor(
  91.                 new CtClass[]{
  92.                         pool.get("java.lang.Integer"),
  93.                         pool.get("java.lang.String"),
  94.                         pool.get("java.lang.String")},
  95.                 ctClass);
  96.         // 创建构造函数的方法主题内容，就是 {}里面的内容 $n 表示第n个参数
  97.         ctConstructor.setBody("{this.age = $1;this.loginName = $2; this.password = $3;}");
  98.         //添加构造器
  99.         ctClass.addConstructor(ctConstructor);
  100.         
  101.         // 添加无参构造函数  
  102.         CtConstructor defaultConstructor = new CtConstructor(
  103.                 new CtClass[]{},
  104.                 ctClass);
  105.         // 创建构造函数的方法主题内容，就是 {}里面的内容
  106.         defaultConstructor.setBody("{}");
  107.         //添加构造器
  108.         ctClass.addConstructor(defaultConstructor);
  109.  
  110.         // 获取类路径
  111.         String classFilePath = path;
  112.         System.out.println("classFilePath: " + classFilePath);
  113.         // 将类写入到 指定文件夹
  114.  
  115.         ctClass.writeFile(classFilePath);
  116.  
  117.         // 重新加载class
  118.         MyClassLoader classLoader = new MyClassLoader();
  119.         Class<?> userClass = classLoader.findClass(className);
  120.         // 使用无参构造函数创建实例
  121. //        Constructor constructor = userClass.getConstructor();
  122. //        Object o = constructor.newInstance();
  123.  
  124.         // 执行有参数构造函数创建实例
  125.         Constructor constructor = userClass.getConstructor(Integer.class, String.class, String.class);
  126.         // 创建实例；执行有参构造函数
  127.         Object o = constructor.newInstance(1, "user", "pwd");
  128.         System.out.println(JSON.toJSONString(o));
  129.  
  130.         // 执行无参show方法
  131.         Method show = userClass.getDeclaredMethod("show");
  132.         show.invoke(o);
  133.  
  134.         //执行有参show方法
  135.         Method showHave = userClass.getDeclaredMethod("show", Integer.class, String.class);
  136.         showHave.invoke(o,2,"hello");
  137.     }
  138. }

 

2、创建出来的class文件通过反编译后内容如下

3、运行main后打印结果如下

 

使用javassist修改class字节码文件并执行

1、动态加载技术其实就是通过修改class文件并且热部署执行的， 我们熟悉的热部署 就是这么实现的，好吧，说的有点懵，还是接上代码吧：

UserUpdate.java （需要修改的类）

  1. package org;
  2.  
  3. public class UserUpdate {
  4.     public void  show(){
  5.         System.out.println("我是版本1.0");
  6.     }
  7. }

 

MainUpdate.java 

  1. package org;
  2.  
  3. import com.MyClassLoader;
  4. import com.User;
  5. import com.alibaba.fastjson.JSON;
  6. import com.sun.xml.internal.ws.api.message.ExceptionHasMessage;
  7. import javassist.*;
  8.  
  9. import java.io.File;
  10. import java.io.IOException;
  11. import java.lang.reflect.Constructor;
  12. import java.lang.reflect.InvocationTargetException;
  13. import java.lang.reflect.Method;
  14. import java.net.URL;
  15. import java.net.URLDecoder;
  16.  
  17. public class MainUpdate {
  18.  
  19.  
  20.     /**
  21.      * 动态修改class类
  22.      * @param args
  23.      * @throws ClassNotFoundException
  24.      * @throws IOException
  25.      * @throws CannotCompileException
  26.      * @throws NotFoundException
  27.      * @throws NoSuchMethodException
  28.      * @throws IllegalAccessException
  29.      * @throws InvocationTargetException
  30.      * @throws InstantiationException
  31.      */
  32.     public static void main(String[] args) throws Exception {
  33.         new MainUpdate().updateClass();
  34.  
  35.     }
  36.  
  37.     /**
  38.      * 修改class文件
  39.      * @throws Exception
  40.      */
  41.     public void updateClass() throws Exception {
  42.         String className = "org.UserUpdate";
  43.  
  44.         Class<?> cla = this.getClass();
  45.         // 获取class文件 所在绝对路径
  46.         URL resource = cla.getResource("/");
  47.         //获取class路径
  48.         String path = URLDecoder.decode(resource.getPath(), "UTF-8");
  49.  
  50.  
  51.         // 使用字节码技术修改class类文件信息
  52.  
  53.         ClassPool pool = ClassPool.getDefault(); // 从类池创建实例
  54.         // TODO 关键代码，读取全类名编译后的 class文件
  55.         CtClass ctClass = pool.get(className);
  56.  
  57.         // 创建 loginName属性
  58.         CtField loginName = CtField.make("private String loginName;", ctClass);
  59.  
  60.         // 创建 pwd 属性
  61.         CtField pwd = CtField.make("private String password;", ctClass);
  62.         // 创建 age属性
  63.         CtField age = CtField.make("private Integer age;", ctClass);
  64.  
  65.         // 添加属性
  66.         ctClass.addField(loginName);
  67.         ctClass.addField(pwd);
  68.         ctClass.addField(age);
  69.  
  70.         // 创建loginName的get 和 set 方法
  71.         CtMethod loginSetMethod = CtMethod.make("public void setLoginName(String loginName){this.loginName = loginName;}", ctClass);
  72.         CtMethod loginGetMethod = CtMethod.make("public String getLoginName(){return this.loginName;}", ctClass);
  73.  
  74.         // 创建password的get 和 set 方法
  75.         CtMethod passwordSetMethod = CtMethod.make("public void setPassword(String password){this.password =  password;}", ctClass);
  76.         CtMethod passwordGetMethod = CtMethod.make("public String getPassword(){return this.password;}", ctClass);
  77.  
  78.         // 创建age的get 和 set 方法
  79.         CtMethod ageSetMethod = CtMethod.make("public void setAge(Integer age) { this.age = age; }", ctClass);
  80.         CtMethod ageGetMethod = CtMethod.make("public Integer getAge() { return age; }", ctClass);
  81.  
  82.         // 添加方法
  83.         ctClass.addMethod(loginGetMethod);
  84.         ctClass.addMethod(loginSetMethod);
  85.         ctClass.addMethod(passwordSetMethod);
  86.         ctClass.addMethod(passwordGetMethod);
  87.         ctClass.addMethod(ageSetMethod);
  88.         ctClass.addMethod(ageGetMethod);
  89.  
  90.  
  91.         // 添加构造函数  , 第一个参数是int 类型，第二个和第三个参数都是string类型
  92.         CtConstructor ctConstructor = new CtConstructor(
  93.                 new CtClass[]{
  94.                         pool.get("java.lang.Integer"),
  95.                         pool.get("java.lang.String"),
  96.                         pool.get("java.lang.String")},
  97.                 ctClass);
  98.         // 创建构造函数的方法主题内容，就是 {}里面的内容 $n 表示第n个参数
  99.         ctConstructor.setBody("{this.age = $1;this.loginName = $2; this.password = $3;}");
  100.         //添加构造器
  101.         ctClass.addConstructor(ctConstructor);
  102.  
  103.  
  104.         // 添加构造函数  ,无参数构造函数  TODO 因为class类里面已经有一个默认的无参构造函数了，所以不需要再次添加，否则会报错
  105. //        CtConstructor defaultConstructor = new CtConstructor(
  106. //                new CtClass[]{},
  107. //                ctClass);
  108. //        // 创建构造函数的方法主题内容，就是 {}里面的内容
  109. //        defaultConstructor.setBody("{}");
  110. //        //在添加默认构造器
  111. //        ctClass.addConstructor(defaultConstructor);
  112.  
  113.  
  114.  
  115.         // 获取类路径
  116.         String classFilePath = path;
  117.         System.out.println("classFilePath: " + classFilePath);
  118.         // 将类写入到 指定文件夹
  119.         ctClass.writeFile(classFilePath);
  120.  
  121.  
  122.         // 重新加载class
  123.         MyClassLoader classLoader = new MyClassLoader();
  124.         Class<?> userClass = classLoader.loadClass(className);
  125.         // 使用无参构造函数创建实例
  126. //        Constructor constructor = userClass.getConstructor();
  127. //        Object o = constructor.newInstance();
  128.  
  129.         // 执行有参数构造函数创建实例
  130.         Constructor constructor = userClass.getConstructor(Integer.class, String.class, String.class);
  131.         // 创建实例；执行有参构造函数
  132.         Object o = constructor.newInstance(1, "user", "pwd");
  133.         UserUpdate user = (UserUpdate) o;
  134.  
  135.         System.out.println(JSON.toJSONString(user));
  136.         System.out.println(JSON.toJSONString(o));
  137.  
  138.         // getDeclaredMethod 获取当前类的show方法
  139.         Method show = userClass.getDeclaredMethod("show");
  140.         show.invoke(o);
  141.  
  142.     }
  143. }

2、运行后，我们可以看到修改后的class文件通过反编译后内容如下

3、控制台输出内容如下

关键字： Java

上一篇： 设计模式 -- 单例模式

下一篇： java静态代码块执行顺序

评论区
博主信息
博客搜索
热门推荐
点击排行
扫我关注
响应式图片
隔壁邻居
叶新东老师的博客-CSDN 所得皆惊喜的博客 java小虚竹的博客 小雨青年的博客 我爱画图