devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JVM插桩之三：javaagent介绍及javassist介绍_javaagent和javassist

作者：凡人多烦事01 | 2024-04-19 08:23:18

赞

踩

javaagent和javassist

本文介绍一下,当下比较基础但是使用场景却很多的一种技术,稍微偏底层点,就是字节码插桩技术了...,如果之前大家熟悉了asm,cglib以及javassit等技术,那么下面说的就很简单了...,因为下面要说的功能就是基于javassit实现的,接下来先从javaagent的原理说起,最后会结合一个完整的实例演示实际中如何使用。

1、什么是javassist?

Javassist是一个开源的分析、编辑和创建Java字节码的类库。其主要的特点，在于简单，而且快速。直接使用java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成

2、Javassist 作用？

a.运行时监控插桩埋点

b.AOP动态代理实现(性能上比Cglib生成的要慢)

c.获取访问类结构信息:如获取参数名称信息

3、Javassist使用流程

4、 如何对WEB项目对象进行字节码插桩

1.统一获取HttpRequest请求参数插桩示例

2.获取HttpRequest参数遇到ClassNotFound的问题

3.Tomcat ClassLoader介绍，及javaagent jar包加载机制

4.通过class加载沉机制实现在javaagent引用jar包

javaagent的主要功能有哪些?

  1. 可以在加载java文件之前做拦截把字节码做修改
  2. 获取所有已经被加载过的类
  3. 获取所有已经被初始化过了的类（执行过了clinit方法，是上面的一个子集）
  4. 获取某个对象的大小
  5. 将某个jar加入到bootstrapclasspath里作为高优先级被bootstrapClassloader加载
  6. 将某个jar加入到classpath里供AppClassloard去加载
  7. 设置某些native方法的前缀，主要在查找native方法的时候做规则匹配

定义一个业务类，类里面定义几个方法，然后在执行这个方法的时候，会动态实现方法的耗时统计。

看业务类定义:

  1. package com.dxz.chama.service;
  2.  
  3. import java.util.LinkedList;
  4. import java.util.List;
  5.  
  6. /**
  7.  * 模拟数据插入服务
  8.  *
  9.  */
  10. public class InsertService {
  11.     
  12.     public void insert2(int num) {
  13.         List<Integer> list = new LinkedList<>();
  14.         for (int i = 0; i < num; i++) {
  15.             list.add(i);
  16.         }
  17.     }
  18.  
  19.     public void insert1(int num) {
  20.         List<Integer> list = new LinkedList<>();
  21.         for (int i = 0; i < num; i++) {
  22.             list.add(i);
  23.         }
  24.     }
  25.  
  26.     public void insert3(int num) {
  27.         List<Integer> list = new LinkedList<>();
  28.         for (int i = 0; i < num; i++) {
  29.             list.add(i);
  30.         }
  31.     }
  32. }

删除服务:

  1. package com.dxz.chama.service;
  2.  
  3. import java.util.List;
  4.  
  5. public class DeleteService {
  6.     public void delete(List<Integer>list){
  7.         for (int i=0;i<list.size();i++){
  8.             list.remove(i);
  9.         }
  10.     }
  11. }

ok,接下来就是要编写javaagent的相关实现:

定义agent的入口

  1. package com.dxz.chama.javaagent;
  2.  
  3. import java.lang.instrument.Instrumentation;
  4.  
  5. /**
  6.  * agent的入口类
  7.  */
  8. public class TimeMonitorAgent {
  9.     // peremain 这个方法名称是固定写法 不能写错或修改
  10.     public static void premain(String agentArgs, Instrumentation inst) {
  11.         System.out.println("execute insert method interceptor....");
  12.         System.out.println(agentArgs);
  13.         // 添加自定义类转换器
  14.         inst.addTransformer(new TimeMonitorTransformer(agentArgs));
  15.     }
  16. }

接下来看最重要的Transformer的实现:

  1. package com.dxz.chama.javaagent;
  2.  
  3. import java.lang.instrument.ClassFileTransformer;
  4. import java.lang.instrument.IllegalClassFormatException;
  5. import java.lang.reflect.Modifier;
  6. import java.security.ProtectionDomain;
  7. import java.util.Objects;
  8.  
  9. import javassist.ClassPool;
  10. import javassist.CtClass;
  11. import javassist.CtMethod;
  12. import javassist.CtNewMethod;
  13.  
  14. /**
  15.  * 类方法的字节码替换
  16.  */
  17. public class TimeMonitorTransformer implements ClassFileTransformer {
  18.  
  19.    private static final String START_TIME = "\nlong startTime = System.currentTimeMillis();\n";
  20.    private static final String END_TIME = "\nlong endTime = System.currentTimeMillis();\n";
  21.    private static final String METHOD_RUTURN_VALUE_VAR = "__time_monitor_result";
  22.    private static final String EMPTY = "";
  23.    
  24.    private String classNameKeyword;
  25.    
  26.    public TimeMonitorTransformer(String classNameKeyword){
  27.       this.classNameKeyword = classNameKeyword;
  28.    }
  29.  
  30.    /**
  31.     *
  32.     * @param classLoader 默认类加载器
  33.     * @param className  类名的关键字 因为还会进行模糊匹配
  34.     * @param classBeingRedefined
  35.     * @param protectionDomain
  36.     * @param classfileBuffer
  37.     * @return
  38.     * @throws IllegalClassFormatException
  39.      */
  40.    public byte[] transform(ClassLoader classLoader, String className, Class<?> classBeingRedefined,
  41.          ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
  42.       className = className.replace("/", ".");
  43.       CtClass ctClass = null;
  44.       try {
  45.          //使用全称,用于取得字节码类
  46.          ctClass = ClassPool.getDefault().get(className);
  47.          //匹配类的机制是基于类的关键字 这个是客户端传过来的参数 满足就会获取所有的方法 不满足跳过
  48.          if(Objects.equals(classNameKeyword, EMPTY)||(!Objects.equals(classNameKeyword, EMPTY)&&className.indexOf(classNameKeyword)!=-1)){
  49.             //所有方法
  50.             CtMethod[] ctMethods = ctClass.getDeclaredMethods();
  51.             //遍历每一个方法
  52.             for(CtMethod ctMethod:ctMethods){
  53.                //修改方法的字节码
  54.                transformMethod(ctMethod, ctClass);   
  55.             }
  56.          }
  57.          //重新返回修改后的类
  58.          return ctClass.toBytecode();
  59.       } catch (Exception e) {
  60.          e.printStackTrace();
  61.       }
  62.       
  63.       return null;
  64.    }
  65.  
  66.    /**
  67.     * 为每一个拦截到的方法 执行一个方法的耗时操作
  68.     * @param ctMethod
  69.     * @param ctClass
  70.     * @throws Exception
  71.      */
  72.     private void transformMethod(CtMethod ctMethod, CtClass ctClass) throws Exception {
  73.         // 抽象的方法是不能修改的，或者方法前面加了final关键字
  74.         if ((ctMethod.getModifiers() & Modifier.ABSTRACT) > 0) {
  75.             return;
  76.         }
  77.         //获取原始方法名称
  78.         String methodName = ctMethod.getName();
  79.         String monitorStr = "\nSystem.out.println(\"method " + ctMethod.getLongName() + " cost:\" + (endTime - startTime) + \"ms.\");";
  80.         //实例化新的方法名称
  81.         String newMethodName = methodName + "$impl";
  82.         //设置新的方法名称
  83.         ctMethod.setName(newMethodName);
  84.         //创建新的方法，复制原来的方法，名字为原来的名字
  85.         CtMethod newMethod = CtNewMethod.copy(ctMethod, methodName, ctClass, null);
  86.         
  87.         StringBuilder bodyStr = new StringBuilder();
  88.         //拼接新的方法内容
  89.         bodyStr.append("{");
  90.  
  91.         //返回类型
  92.         CtClass returnType = ctMethod.getReturnType();
  93.  
  94.         //是否需要返回
  95.         boolean hasReturnValue = (CtClass.voidType != returnType);
  96.  
  97.         if (hasReturnValue) {
  98.             String returnClass = returnType.getName();
  99.             bodyStr.append("\n").append(returnClass + " " + METHOD_RETURN_VALUE_VAR + ";");
  100.         }
  101.         
  102.         bodyStr.append(START_TIME);
  103.         if (hasReturnType) {
  104.             bodyStr.append("\n").append(METHOD_RETURN_VALUE_VAR + " = ($r)" + newMethodName + "($$);");
  105.         } else {
  106.             bodyStr.append("\n").append(newMethodName + "($$);");
  107.         }
  108.  
  109.         bodyStr.append(END_TIME);
  110.         bodyStr.append(monitorStr);
  111.  
  112.         if (hasReturnValue) {
  113.             bodyStr.append("\n").append("return " + METHOD_RETURN_VALUE_VAR + " ;");
  114.         }
  115.          
  116.         bodyStr.append("}");
  117.         //替换新方法
  118.         newMethod.setBody(bodyStr.toString());
  119.         //增加新方法
  120.         ctClass.addMethod(newMethod);
  121.     }
  122. }

其实也很简单就两个类就实现了要实现的功能,那么如何使用呢？需要把上面的代码打成jar包才能执行,建议大家使用maven打包,下面是pom.xml的配置文件

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.  
  6.     <groupId>com.dxz</groupId>
  7.     <artifactId>chama</artifactId>
  8.     <version>0.0.1-SNAPSHOT</version>
  9.     <packaging>jar</packaging>
  10.  
  11.     <name>chama</name>
  12.     <url>http://maven.apache.org</url>
  13.  
  14.     <properties>
  15.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  16.     </properties>
  17.  
  18.     <dependencies>
  19.         <dependency>
  20.             <groupId>javassist</groupId>
  21.             <artifactId>javassist</artifactId>
  22.             <version>3.12.1.GA</version>
  23.         </dependency>
  24.  
  25.         <!-- https://mvnrepository.com/artifact/cglib/cglib -->
  26.         <dependency>
  27.             <groupId>cglib</groupId>
  28.             <artifactId>cglib</artifactId>
  29.             <version>3.2.5</version>
  30.         </dependency>
  31.  
  32.         <!-- https://mvnrepository.com/artifact/oro/oro -->
  33.         <dependency>
  34.             <groupId>oro</groupId>
  35.             <artifactId>oro</artifactId>
  36.             <version>2.0.8</version>
  37.         </dependency>
  38.         <dependency>
  39.             <groupId>junit</groupId>
  40.             <artifactId>junit</artifactId>
  41.             <version>3.8.1</version>
  42.             <scope>test</scope>
  43.         </dependency>
  44.     </dependencies>
  45.     <build>
  46.         <plugins>
  47.             <plugin>
  48.                 <groupId>org.apache.maven.plugins</groupId>
  49.                 <artifactId>maven-compiler-plugin</artifactId>
  50.                 <configuration>
  51.                     <source>1.8</source>
  52.                     <target>1.8</target>
  53.                     <encoding>utf-8</encoding>
  54.                 </configuration>
  55.             </plugin>
  56.             <plugin>
  57.                 <groupId>org.apache.maven.plugins</groupId>
  58.                 <artifactId>maven-shade-plugin</artifactId>
  59.                 <version>3.0.0</version>
  60.                 <executions>
  61.                     <execution>
  62.                         <phase>package</phase>
  63.                         <goals>
  64.                             <goal>shade</goal>
  65.                         </goals>
  66.                         <configuration>
  67.                             <transformers>
  68.                                 <transformer
  69.                                     implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
  70.                                     <manifestEntries>
  71.                                         <Premain-Class>com.dxz.chama.javaagent.TimeMonitorAgent</Premain-Class>
  72.                                     </manifestEntries>
  73.                                 </transformer>
  74.                             </transformers>
  75.                         </configuration>
  76.                     </execution>
  77.                 </executions>
  78.             </plugin>
  79.         </plugins>
  80.     </build>
  81. </project>

强调一下,红色标准的非常关键,因为如果要想jar能够运行,必须要把运行清单打包到jar中,且一定要让jar的主类是Permain-Class,否则无法运行,运行清单的目录是这样的.

mvn -clean package

如果打包正确的话,里面的内容应该如下所示:

OK至此整体代码和打包就完成了,那么接下来再讲解如何使用

部署方式:

1 基于IDE开发环境运行

首先,编写一个service的测试类如下:

  1. package com.dxz.chama.service;
  2.  
  3. import java.util.LinkedList;
  4. import java.util.List;
  5.  
  6. public class ServiceTest {
  7.     public static void main(String[] args) {
  8.         // 插入服务
  9.         InsertService insertService = new InsertService();
  10.         // 删除服务
  11.         DeleteService deleteService = new DeleteService();
  12.         System.out.println("....begnin insert....");
  13.         insertService.insert1(1003440);
  14.         insertService.insert2(2000000);
  15.         insertService.insert3(30003203);
  16.  
  17.         System.out.println(".....end insert.....");
  18.         List<Integer> list = new LinkedList<>();
  19.         for (int i = 0; i < 29988440; i++) {
  20.             list.add(i);
  21.         }
  22.         System.out.println(".....begin delete......");
  23.         deleteService.delete(list);
  24.         System.out.println("......end delete........");
  25.  
  26.     }
  27. }

选择编辑配置:如下截图所示

service是指定要拦截类的关键字，如果这里的参数是InsertService，那么DeleteService相关的方法就无法拦截了。同理也是一样的。

chama-0.0.1-SNAPSHOT.jar这个就是刚刚编写那个javaagent类的代码打成的jar包,ok 让我们看一下最终的效果如何:

实际应用场景中,可以把这些结果写入到log然后发送到es中,就可以做可视化数据分析了...还是蛮强大的,接下来对上面的业务进行扩展,因为上面默认是拦截类里面的所有方法,如果业务需求是拦截类的特定的方法该怎么实现呢？其实很简单就是通过正则匹配,下面给出核心代码:

定义入口agent:

  1. package com.dxz.chama.javaagent.patter;
  2. import java.lang.instrument.Instrumentation;
  3.  
  4. public class TimeMonitorPatterAgent {
  5.     public static void premain(String agentArgs, Instrumentation inst) {
  6.         inst.addTransformer(new PatternTransformer());
  7.     }
  8. }

定义transformer:

  1. package com.dxz.chama.javaagent.patter;
  2.  
  3. import javassist.CtClass;
  4. import org.apache.oro.text.regex.PatternCompiler;
  5. import org.apache.oro.text.regex.PatternMatcher;
  6. import org.apache.oro.text.regex.Perl5Compiler;
  7. import org.apache.oro.text.regex.Perl5Matcher;
  8.  
  9. import java.lang.instrument.ClassFileTransformer;
  10. import java.lang.instrument.IllegalClassFormatException;
  11. import java.security.ProtectionDomain;
  12.  
  13. public class PatternTransformer implements ClassFileTransformer {
  14.     @Override
  15.     public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
  16.             ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
  17.         PatternMatcher matcher = new Perl5Matcher();
  18.         PatternCompiler compiler = new Perl5Compiler();
  19.         // 指定的业务类
  20.         String interceptorClass = "com.dxz.chama.service.InsertService";
  21.         // 指定的方法
  22.         String interceptorMethod = "insert1";
  23.         try {
  24.             if (matcher.matches(className, compiler.compile(interceptorClass))) {
  25.                 ByteCode byteCode = new ByteCode(0;
  26.                 CtClass ctClass = byteCode.modifyByteCode(interceptorClass, interceptorMethod);
  27.                 return ctClass.toBytecode(0;
  28.             }
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.         }
  32.         return null;
  33.     }
  34. }

修改字节码的实现:

  1. package com.dxz.chama.javaagent.patter;
  2.  
  3. import javassist.ClassPool;
  4. import javassist.CtClass;
  5. import javassist.CtMethod;
  6. import javassist.CtNewMethod;
  7.  
  8. public class ByteCode {
  9.     public CtClass modifyByteCode(String className, String method) throws Exception {
  10.         ClassPool classPool = ClassPool.getDefault();
  11.         CtClass ctClass = classPool.get(className);
  12.         CtMethod oldMethod = ctClass.getDeclaredMethod(method);
  13.         String oldMethodName = oldMethod.getName(0;
  14.         String newName = oldMethodName + "$impl";
  15.         oldMethod.setName(newName);
  16.  
  17.         CtMethod newMethod = CtNewMethod.copy(oldMethod, oldMethodName, ctClass, null);
  18.         StringBuffer sb = newe StringBuffer();
  19.         sb.append("{");
  20.         sb.append("\nSystem.out.println(\"start to modify bytecode\"); \n");
  21.         sb.append(newName + "($$);\n");
  22.         sb.append("System.out.println(\"call method" + oldMethodName + "took\"+(System.currentTimeMillis()-start))");
  23.         sb.append("}");
  24.         newMethod.setBody(sb.toString());
  25.         ctClass.addMethod(newMethod);
  26.         return ctClass;
  27.     }
  28. }

OK，

修改下pom中的

  1. <manifestEntries>
  2.     <Premain-Class>com.dxz.chama.javaagent.patter.TimeMonitorPatterAgent</Premain-Class>
  3. </manifestEntries>

这个时候再重新打包,然后修改上面的运行配置之后再看效果,只能拦截到insert1方法

最后 再说一下如何使用jar运行，其实很简单如下:把各个项目都打成jar,比如把上面的service打成service.jar,然后使用java命令运行:

java -javaagent:d://chama-0.0.1-SNAPSHOT.jar=Service -jar service.jar,效果是一样的!

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/450791
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号