首页 后端 Java 正文

JvmSandbox原理分析02-JVM AOP初探:JavaAgent

1、sandbox-core 入口

上一篇我们讲到了sandbox.sh最后执行的是我们熟悉的java -jar命令,用来拉起sandbox-core.jar包。

JvmSandbox原理分析02 JVM AOP初探:JavaAgent  第1张

接着,我们就应该寻找sandbox-core.jar这个jar包的入口文件在哪了,有两种寻找方法:

  • 第一种方法:解压jar包,查看META-INF/MANIFEST.MF文件,其中Main-Class这个key就指 定了模块入口类的全路径类名

 Manifest-Version: 1.0
 Archiver-Version: Plexus Archiver
 Created-By: Apache Maven
 Built-By: XWT
 Build-Jdk: 1.8.0_281
 Main-Class: com.alibaba.jvm.sandbox.core.CoreLauncher

  • 第二种方法:直接查看源码中的pom.xml文件,其中的maven-build插件就指定了模块的入口,manifest-mainClass表示通过java -jar执行该jar包时,main函数的入口为配置的全路径类名。

 ...
 <manifest>
     <mainClass>com.alibaba.jvm.sandbox.core.CoreLauncher</mainClass>
 </manifest>
 ...

ps:上述两种寻找模块入口的方式对于大家写惯了Springboot的同学来说或许有些陌生。其实Springboot也是这么做的,Springboot工程的入口其实并不在我们经常写的@Springboot注解下的main方法,这个方法其实会在真正的入口处被反射调用,详细可以参考这篇文章:你真的了解SpringBoot应用的启动入口么? - 掘金 (juejin.cn)

通过上述分析我们得知,sandbox.sh执行了java -jar后,最终会来到sandbox-core这个module下的com.alibaba.JVM.sandbox.core.CoreLauncher类的main方法中。

2、CoreLauncher.java分析

CoreLauncher.java的核心逻辑以及源码如下所示:

  • main方法首先会对执行参数args进行校验。通过上一篇分析sandbox.sh中我们可以得知,最后执行java -jar时会携带三个参数,他们分别是目标JVM进程的PID、sandbox-agent.jar路径、config配置信息,这三个参数会封装在args参数中。

  • 随后会调用CoreLauncher构造方法透传执行参数至attachAgent方法中。

  • attachAgent方法就是挂载javaagent的核心方法了。它首先获取目标JVM进程的虚拟机对象VirtualMachine,然后调用该对象的loadAgent方法加载sandbox-agent.jar这个agent jar包。

 package com.alibaba.jvm.sandbox.core;
 import com.sun.tools.attach.VirtualMachine;
 import org.apache.commons.lang3.StringUtils;
 import static com.alibaba.jvm.sandbox.core.util.SandboxStringUtils.getCauseMessage;
 /**
  * 沙箱内核启动器
  * Created by luanjia@taobao.com on 16/10/2.
  */
 public class CoreLauncher {
     public CoreLauncher(final String targetJvmPid, final String agentJarPath,
                         final String token) throws Exception {
         // 加载agent
         attachAgent(targetJvmPid, agentJarPath, token);
     }
     /**
      * 内核启动程序
      * @param args 参数: [0]PID [1]agent.jar's value [2]token
      * sandbox.sh执行后面带了 pid sandbox-agent.jar config 三个参数,这些参数会被传入到main函数的args数组当中
      */
     public static void main(String[] args) {
         try {
             // 检验参数是否符合要求
             if (args.length != 3 || StringUtils.isBlank(args[0]) || StringUtils.isBlank(args[1])
                     || StringUtils.isBlank(args[2])) {
                 throw new IllegalArgumentException("illegal args");
             }
             // 执行CoreLauncher方法,并传递三个参数
             new CoreLauncher(args[0], args[1], args[2]);
         } catch (Throwable t) {
             t.printStackTrace(System.err);
             System.err.println("sandbox load jvm failed : " + getCauseMessage(t));
             System.exit(-1);
         }
     }
     // 加载Agent
     private void attachAgent(final String targetJvmPid,
                              final String agentJarPath,
                              final String cfg) throws Exception {
         VirtualMachine vmObj = null;
         try {
             // attach目标的JVM
             vmObj = VirtualMachine.attach(targetJvmPid);
             if (vmObj != null) {
                 // attach成功后加载代理jar包。
                 vmObj.loadAgent(agentJarPath, cfg);
             }
         } finally {
             if (null != vmObj) {
                 vmObj.detach();
             }
         }
     }
 }

CoreLauncher.java的核心逻辑如上所述,但是为什么这样做就能够在目标JVM还在运行期间挂载其他的jar包呢?

这就不得不说JVM提供给开发人员的Java Instrument这个“杀手级武器”了。

原本准备在第三节讲解Java Instrument相关知识,但这部分内容实在有点多,于是单独抽出一篇说明:【《待补充》】

上面的过程完成了后,目前的启动流程便成了这样:

JvmSandbox原理分析02 JVM AOP初探:JavaAgent  第2张

3、 sandbox-agent入口

第二节聊到了CoreLauncher.java通过VirtualMachine#loadAgent挂载sandbox-agent.jar这个jar包。大家也通过链接的文章了解了Java Instrument相关知识,接下来我们看看sandbox-agent的入口在哪里。(其实sandbox-agent这个module的类非常少,入口很容易就能够找到)

sandbox-agent这个module的pom.xml如下所示(只显示关键信息),Premain-Class和Agent-Class标签都指向了AgentLauncher这个类,说明入口都在这个类中。

 <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-assembly-plugin</artifactId>
     <executions>
         <execution>
             <goals>
                 <goal>attached</goal>
             </goals>
             <phase>package</phase>
             <configuration>
                 <descriptorRefs>
                     <descriptorRef>jar-with-dependencies</descriptorRef>
                 </descriptorRefs>
                 <archive>
                     <manifestEntries>
                         <Premain-Class>com.alibaba.jvm.sandbox.agent.AgentLauncher</Premain-Class>
                         <Agent-Class>com.alibaba.jvm.sandbox.agent.AgentLauncher</Agent-Class>
                         <Can-Redefine-Classes>true</Can-Redefine-Classes>
                         <Can-Retransform-Classes>true</Can-Retransform-Classes>
                     </manifestEntries>
                 </archive>
             </configuration>
         </execution>
     </executions>
 </plugin>

Premain-Class标签表示,当前jar包通过在虚拟机参数中指定-javaagent进行挂载时(启动时挂载),入口在AgentLauncher#premain方法中。

Agent-Class标签表示,当前jar包通过VirtualMachine#loadAgent方法挂载时(运行时挂载),入口在AgentLauncher#agentmain方法中。

Sandbox一般都是运行时挂载,因此我们的关注点可以转移到AgentLauncher#agentmain方法上了。

4、AgentLauncher#agentmain

agentmain方法如下所示,其中featureString参数是在加载agent时,通过方法参数cfg传递过来,这个参数其实是sandbox需要的配置文件。

 // CoreLauncher.java
 vmObj.loadAgent(agentJarPath, cfg);
 
 /**
  * 运行时加载
  * @param featureString 为 CoreLauncher.java 传递的 cfg 参数
  * @param inst inst
  */
 public static void agentmain(String featureString, Instrumentation inst) {
     // 设置启动模式为 attach
     LAUNCH_MODE = LAUNCH_MODE_ATTACH;
     // 解析配置,String->Map
     final Map<String, String> featureMap = toFeatureMap(featureString);
     // 获取名称空间
     String namespace = getNamespace(featureMap);
     // 获取token
     String token = getToken(featureMap);
     // 安装sandbox的核心方法
     InetSocketAddress inetSocketAddress = install(featureMap, inst);
     // 将安装结果写入到sandbox.token文件当中
     writeAttachResult(namespace, token, inetSocketAddress);
 }

这个方法比较简单,解析完配置参数后就开始安装过程,最后将安装结果append到sandbox.token文件当中。方法中的其他逻辑都比较简单,大家看一下就行了,我们接下来分析最为核心的install方法。

5、AgentLauncher#install

install方法逻辑比较多,这里先总的概括下install方法做了什么,并给出方法的全部代码,后面我们再对其中的细节慢慢分析,这里先注意下该方法传递了inst这个Instrumentation对象

install方法总的来说完成了以下几件事:

  • 将sandbox-spy这个jar包路径添加到Bootstrap Classloader的加载路径下

  • 初始化自定义的SandboxClassloader,反射加载Sandbox核心对象,实现沙箱类与业务类隔离

  • 启动Sandbox的内置jetty服务器(上一篇说的服务器就是在这个时候加载的),后续业务代码的增强等工作都在该服务器中执行。该服务器也提供了一些接口动态操作沙箱。

  • 返回Jetty服务器绑定信息,install方法执行完成。

完整的代码如下所示:

 /**
  * 在当前JVM安装jvm-sandbox
  * 注意 install传递了inst这个Instrumentation对象
  *
  * @param featureMap 启动参数配置
  * @param inst       inst
  * @return 服务器IP:PORT
  */
 private static synchronized InetSocketAddress install(final Map<String, String> featureMap, final Instrumentation inst) {
     final String namespace = getNamespace(featureMap);
     final String propertiesFilePath = getPropertiesFilePath(featureMap);
     final String coreFeatureString = toFeatureString(featureMap);
     try {
         final String home = getSandboxHome(featureMap);
         // SANDBOX_SPY_JAR_PATH
         JarFile spyJarFile = new JarFile(new File(getSandboxSpyJarPath(home)));
         // 将Spy注入到BootstrapClassLoader,我们需要将spy类的代码增强到目标JVM中
         inst.appendToBootstrapClassLoaderSearch(spyJarFile);
         // 构造自定义的类加载器,尽量减少Sandbox对现有工程的侵蚀
         final ClassLoader sandboxClassLoader = loadOrDefineClassLoader(namespace,getSandboxCoreJarPath(home));
 
         // CoreConfigure类定义
         final Class<?> classOfConfigure = sandboxClassLoader.loadClass(CLASS_OF_CORE_CONFIGURE);
         // 反射CoreConfigure类实例
         final Object objectOfCoreConfigure = classOfConfigure.getMethod("toConfigure", String.class, String.class)
                 .invoke(null, coreFeatureString, propertiesFilePath);
         // CoreServer类定义
         final Class<?> classOfProxyServer = sandboxClassLoader.loadClass(CLASS_OF_PROXY_CORE_SERVER);
         // 反射CoreServer单例,这里可以观察 com.alibaba.jvm.sandbox.core.server#getInstance 方法,
         // ProxyCoreServer只是代理,执行都在JettyCoreServer中
         final Object objectOfProxyServer = classOfProxyServer.getMethod("getInstance").invoke(null);
         // CoreServer.isBind()
         final boolean isBind = (Boolean) classOfProxyServer.getMethod("isBind").invoke(objectOfProxyServer);
         // 如果未绑定,则需要绑定一个地址
         if (!isBind) {
             try {
                 // 注意这里绑定的时候传递了 Instrumentation 这个类,这个类主要负责对目标JVM中的代码进行增强
                 // 现在主要逻辑都在 com.alibaba.jvm.sandbox.core.server.jetty.JettyCoreServer#bind 中了
                 classOfProxyServer
                         .getMethod("bind", classOfConfigure, Instrumentation.class)
                         .invoke(objectOfProxyServer, objectOfCoreConfigure, inst);
             } catch (Throwable t) {
                 classOfProxyServer.getMethod("destroy").invoke(objectOfProxyServer);
                 throw t;
             }
         }
         // 返回服务器绑定的地址
         return (InetSocketAddress) classOfProxyServer.getMethod("getLocal").invoke(objectOfProxyServer);
     } catch (Throwable cause) {
         throw new RuntimeException("sandbox attach failed.", cause);
     }
 }

5.1、自定义SandboxClassloader

install最开始的代码都是些配置解析的操作,大家看看就可以了。

我们首先来说下关于classloader相关的代码,就是下面这三行:

 // 将sandbox-spy这个jar包保证成JarFile文件
 JarFile spyJarFile = new JarFile(new File(getSandboxSpyJarPath(home)));
 // 将Spy注入到BootstrapClassLoader,我们需要将spy类的代码增强到目标JVM中
 inst.appendToBootstrapClassLoaderSearch(spyJarFile);
 
 // 构造自定义的类加载器,尽量减少Sandbox对现有工程的侵蚀
 final ClassLoader sandboxClassLoader = loadOrDefineClassLoader(namespace,getSandboxCoreJarPath(home));

将sandbox-spy这个jar包注入到BootstrapClassLoader加载路径下,这里提前说下sandbox-spy这个包的作用:我们可以认为这个包里的代码是一系列的模板代码,后期Sandbox会通过ASM框架将这些代码转化成字节码增加到业务代码的字节码当中,实现对业务代码的增强功能。 官方把这个包认为是间谍类,能够埋点在业务代码中,获取业务代码执行过程中的一些信息。

但spy类为什么要被BootstrapClassLoader加载呢?

按理说,埋点在业务代码中,仅需要ApplicationClassloader就完全足够了,后来经过某位大佬的提醒,如果要增强JDK里面的代码,ApplicationClassloader就不够用了,大家都知道,JDK的代码加载是ExtensionClassloader和BootstrapClassLoader。因此,将spy添加到BootstrapClassLoader的类路径,只要不破坏双亲委托机制,都能够被spy类增强,这是一种比较保险的做法

之后就是初始化SandboxClassLoader,这个自定义类加载器主要负责加载沙箱中的类,它的实现破坏了双亲委托机制,能够保证沙箱中的类与业务代码的类完全隔离。减少Sandbox对现有工程的侵蚀。

经过上面两行代码后,整个工程的Classloader模型大致如下图所示:

JvmSandbox原理分析02 JVM AOP初探:JavaAgent  第3张

5.2、反射加载

5.2.1、反射CoreConfigure对象

完成SandboxClassloader的初始化后,首先加载的是com.alibaba.jvm.sandbox.core.CoreConfigure这个类,从类名很容易知道该类主要存储了沙箱的核心配置信息。之后利用加载的类反射调用toConfigure()方法,将我们之前设置的配置信息保存在CoreConfigure类当中,并实例化一个CoreConfigure对象。

 // CoreConfigure类定义
 final Class<?> classOfConfigure = sandboxClassLoader.loadClass(CLASS_OF_CORE_CONFIGURE);
 // 反射CoreConfigure类实例
 final Object objectOfCoreConfigure = classOfConfigure.getMethod("toConfigure", String.class, String.class)
         .invoke(null, coreFeatureString, propertiesFilePath);

toConfigure方法比较简单,如下所示。就是调用构造方法,然后解析配置,大家感兴趣的可以深入看看。

 // CoreConfigure.java
 public static CoreConfigure toConfigure(final String featureString, final String propertiesFilePath) {
     return instance = new CoreConfigure(featureString, propertiesFilePath);
 }
 private CoreConfigure(final String featureString,
                       final String propertiesFilePath) {
     final Map<String, String> featureMap = toFeatureMap(featureString);
     final Map<String, String> propertiesMap = toPropertiesMap(propertiesFilePath);
     this.featureMap.putAll(merge(featureMap, propertiesMap));
 }

5.2.2、反射CoreServer对象

第二个加载的类是com.alibaba.jvm.sandbox.core.server.ProxyCoreServer,完成类加载后反射调用getInstance方法获取Server对象。

 // CoreServer类定义
 final Class<?> classOfProxyServer = sandboxClassLoader.loadClass(CLASS_OF_PROXY_CORE_SERVER);
 
 // 反射CoreServer单例,这里可以观察 com.alibaba.jvm.sandbox.core.server#getInstance 方法,
 // ProxyCoreServer只是代理,执行都在JettyCoreServer中
 final Object objectOfProxyServer = classOfProxyServer.getMethod("getInstance").invoke(null);

ProxyCoreServer#getInstance方法如下所示,该方法也是反射调用JettyCoreServer#getInstance方法实例化一个JettyCoreServer。这也能够更好体现ProxyCoreServer命名含义,表名它仅是一个代理Server,具体实现还是由classOfCoreServerImpl指定。

这里作者应该是想让CoreServer的实现更加可扩展些,如果有些同学不想用JettyServer,而是想要使用自己实现的Server,只需要实现CoreServer接口后,替换classOfCoreServerImpl即可。

 ...
 <manifest>
     <mainClass>com.alibaba.jvm.sandbox.core.CoreLauncher</mainClass>
 </manifest>
 ...0

获得CoreServer实例对象后,反射调用JettyCoreServer#isBind方法判断服务器是否已经初始化。如果没有初始化,则再反射调用JettyCoreServer#bind方法初始化JettyServer,其中沙箱的初始化也在JettyServer的初始化过程中完成

我们注意下,在调用JettyCoreServer#bind方法时,我们传递了Instrumentation 这个对象,这个对象是后期字节码重写(增强)的核心对象

bind方法会在第6小节详细分析,这里暂时先不给出代码了。

 ...
 <manifest>
     <mainClass>com.alibaba.jvm.sandbox.core.CoreLauncher</mainClass>
 </manifest>
 ...1

5.3、返回绑定信息

最后也比较简单,反射调用JettyCoreServer#getLocal方法获取服务器ip、port信息并返回。

 ...
 <manifest>
     <mainClass>com.alibaba.jvm.sandbox.core.CoreLauncher</mainClass>
 </manifest>
 ...2

6、总结

完成了上述过程后,Sandbox-core的启动与Agent挂载的过程差不多完成了,我们这里简单总结下:

sandbox.sh脚本运行后,会通过java -jar运行CoreLauncher.java中的main函数,main函数会通过attach agent的方式将sandbox-agent挂载到目标JVM上,sandbox-agent会自定义SandboxClassloader实现类隔离,并通过该类加载器反射加载JettyServer,完成后续的操作。

目前启动流程便可以由下图描述:

JvmSandbox原理分析02 JVM AOP初探:JavaAgent  第4张

原文:https://juejin.cn/post/7101675446127263751
打赏
海报

本文转载自互联网,旨在分享有价值的内容,文章如有侵权请联系删除,部分文章如未署名作者来源请联系我们及时备注,感谢您的支持。

转载请注明本文地址:https://www.shouxicto.com/article/5558.html

相关推荐

Java 将XML转为Excel文件

Java 将XML转为Excel文件

   1、sandbox-core 入口    上一篇我们讲到了sandbox.sh最后执行的是我们熟悉的java -jar...

Java 2022.08.26 0 1439

Java 在Excel中添加水印

Java 在Excel中添加水印

   1、sandbox-core 入口    上一篇我们讲到了sandbox.sh最后执行的是我们熟悉的java -jar...

Java 2022.08.26 0 1330

发布评论

ainiaobaibaibaibaobaobeishangbishibizuichiguachijingchongjingdahaqiandaliandangaodw_dogedw_erhadw_miaodw_tuzidw_xiongmaodw_zhutouganbeigeiliguiguolaiguzhanghahahahashoushihaixiuhanheixianhenghorse2huaixiaohuatonghuaxinhufenjiayoujiyankeaikeliankouzhaokukuloukunkuxiaolandelinileimuliwulxhainiolxhlikelxhqiuguanzhulxhtouxiaolxhwahahalxhzanningwennonuokpinganqianqiaoqinqinquantouruoshayanshengbingshiwangshuaishuijiaosikaostar0star2star3taikaixintanshoutianpingtouxiaotuwabiweifengweiquweiwuweixiaowenhaowoshouwuxiangjixianhuaxiaoerbuyuxiaokuxiaoxinxinxinxinsuixixixuyeyinxianyinyueyouhenghengyuebingyueliangyunzanzhajizhongguozanzhoumazhuakuangzuohenghengzuoyi
支付宝
微信
赞助本站