新来的实习生妹妹成心刁难我，
说想让我完结一个办法耗时核算东西，
不能用切面，
这能难倒我嘛，Java Agent安排上。
前言
本篇文章将完结一个超绝战损版的根据Java Agent的办法耗时核算东西。
全体内容分为：
- Java Agent原理简析；
- 办法耗时核算东西完结；
- 办法耗时东西的Springboot的starter包完结。
正文
一. Java Agent原理简析
理解啥是Java Agent前，需求先介绍一下JVM TI（JVM Tool Interface）。
JVM TI是JVM供给的用于拜访JVM各种状态的一套编程接口。根据JVM TI可以注册各种JVM工作钩子函数，当JVM工作产生时，触发钩子函数以对相应的JVM工作进行处理。关于JVM TI的详细文档，可以参阅JVMTM Tool Interface。
那么Java Agent可以理解为便是JVM TI的一种详细完结。关于Java Agent，可以概括其特性如下。
- 是一个jar包；
- 无法独立运转；
- （JDK1.5）可以在程序运转前被加载，加载后会调用到Java Agent供给的进口函数premain(String agentArgs, Instrumentation inst)；
- （JDK1.6开端）可以在程序运转中被加载，加载后会调用到Java Agent供给的进口函数agentmain(String agentArgs, Instrumentation inst)。
假如想要agentmain() 办法被调用，则需求将Agent程序attach到主进程的JVM上，这时就需求运用到com.sun.tools.attach包里供给的Attach API，Agent被attach到JVM后，agent的agentmain() 办法就会被调用。
最终说明一下Java Agent的进口函数中的类型为Instrumentation的参数。Instrument是JVM供给的一套可以对Java代码进行插桩操作的服务能力，JDK1.5的Instrument支撑在JVM发动并加载类时修正类，Instrument从JDK1.6开端支撑在程序运转时修正类。Instrument供给的重要办法如下所示。
public interface Instrumentation {
// ...
/**
* JDK1.5供给，注册一个{@link ClassFileTransformer}。
* 等同于addTransformer(transformer, false)。
*
* @param transformer {@link ClassFileTransformer}。
*/
void addTransformer(ClassFileTransformer transformer);
/**
* JDK1.6供给，注册一个{@link ClassFileTransformer}。
*
* @param transformer {@link ClassFileTransformer}。
* @param canRetransform false表明注册的{@link ClassFileTransformer}仅对初次加载的类收效，
* 即初次加载类时可以改动这个类的界说再完结加载；
* true表明注册的{@link ClassFileTransformer}可对已加载的类收效，即
* 可对已加载的类进行重界说偏重加载，重加载重界说的类时会覆盖已加载的类。
*/
void addTransformer(ClassFileTransformer transformer, boolean canRetransform);
/**
* JDK1.6供给，重界说偏重加载传入的类。
*
* @param classes 需求重界说偏重加载的类。
* @throws UnmodifiableClassException 传入的类无法被修正时抛出。
*/
void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;
// ...
}
也便是可以向Instrumentation注册ClassFileTransformer。
JDK1.5时只能经过addTransformer(ClassFileTransformer) 办法注册ClassFileTransformer，此时每个类被加载到JVM中之前会调用到注册的ClassFileTransformer的transform() 办法，并可以在其间先改动类界说后再将类加载到JVM中。
JDK1.6开端供给了addTransformer(ClassFileTransformer, boolean) 办法，当第二个参数传入false时，效果与addTransformer(ClassFileTransformer) 办法相同，当第二个参数传入true时，那么此时注册的ClassFileTransformer除了在类被加载到JVM中之前会调用到，还会在retransformClasses(Class<?>… classes) 办法调用时被调用到，也便是此时注册的ClassFileTransformer支撑对经过retransformClasses(Class<?>… classes) 办法传入的类进行重界说然后再重加载到JVM中。
二. 全体构思
首要，因为是超绝战损版，所以咱们的办法耗时核算，伪代码可以表明如下。
public class TestDemo {
public void execute() {
// 记载开端时刻
long beginTime = System.currentTimeMillis();
// 原办法办法体
// ...
// 记载结束时刻
long endTime = System.currentTimeMillis();
// 记载履行耗时
long executeTime = endTime - beginTime;
// 超绝战损版打印
System.out.println(executeTime);
}
}
其次，咱们需求编写一个Java Agent，且希望可以在程序运转时加载这个Java Agent，所以编写的Java Agent需求供给进口函数agentmain(String agentArgs, Instrumentation inst)，此时Java Agent需求经过com.sun.tools.attach包里供给的Attach API来加载并附加到主进程JVM上。
然后，在Java Agent中，咱们需求初始化ClassFileTransformer，然后将ClassFileTransformer注册到Instrumentation，再然后获取到需求重界说的类并经过Instrumentation的retransformClasses(Class<?>… classes) 办法将这些类传递到注册的ClassFileTransformer中。
接着，在咱们自界说的ClassFileTransformer中，需求凭借Javassist的能力，为相应的类增加办法耗时核算的代码片段，并完结重加载。
最终，还需求编写一个测验程序来验证咱们的超绝战损版办法耗时打印东西的功能。
全体的一个流程示意图如下。
三. 办法耗时核算东西完结
现在开端代码完结。首要创立一个Maven工程，命名为myagent-core，POM文件如下所示。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.lee.learn.agent</groupId>
<artifactId>myagent-core</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.12.1.GA</version>
</dependency>
</dependencies>
<build>
<finalName>myagent-core</finalName>
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<archive>
<manifestFile>src/main/resources/META-INF/MANIFEST.MF</manifestFile>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
POM文件中首要便是引进有必要的javassist的依托，以及经过打包插件将依托打入jar包。
然后需求创立src/main/resources/META-INF目录，然后在其间创立MANIFEST.MF文件，内容如下所示。
Agent-Class: com.lee.learn.agent.core.MethodAgent
Can-Redefine-Classes: true
Can-Retransform-Classes: true
特别注意最终有一个空行。
现在开端编写Java Agent的代码。首要是自界说一个转换器，命名为MTransformer，并完结ClassFileTransformer接口，代码现如下。
public class MTransformer implements ClassFileTransformer {
/**
* 方针类的类全限定名和类加载器的映射，用于挑选出需求重界说的类。
* 映射类型是：Map[类全限定名, 类加载器]。
*/
private final Map<String, ClassLoader> targetClassesMap = new HashMap<>();
/**
* 初始化时就需求传入方针类调集，并转换成映射联系。
*
* @param targetClasses 方针类的类方针调集。
*/
public MTransformer(List<Class<?>> targetClasses) {
targetClasses.forEach(targetClass ->
targetClassesMap.put(
targetClass.getName(),
targetClass.getClassLoader()));
}
/**
* 根据Javassist改造类办法，为每个办法增加打印履行耗时的逻辑。
*
* @param loader 需求改造的类的类加载器。
* @param className 需求改造的类的类全限定名。
* @param classBeingRedefined 有值时传入的便是正在被重界说的类的类方针，假如是类加载阶段那么传入为null。
* @param protectionDomain 改造类的保护域。
* @param classfileBuffer 类文件的输入字节缓冲区。
* @return 改造后的类文件字节缓存区，假如未履行改造，返回null。
*/
@Override
public byte[] transform(ClassLoader loader, String className,
Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
byte[] classfileBuffer) {
byte[] byteCode = classfileBuffer;
// 类加载器+类途径才能彻底确认一个类
// 根据类加载器和类途径进行方针类挑选
String targetClassName = className.replaceAll(PATH_SEP, REGEX_QUALIFIER);
if (targetClassesMap.get(targetClassName) == null
|| !targetClassesMap.get(targetClassName).equals(loader)) {
return byteCode;
}
try {
ClassPool classPool = ClassPool.getDefault();
CtClass ctClass = classPool.get(targetClassName);
// 对方针类的一切办法都刺进核算耗时逻辑
CtMethod[] declaredMethods = ctClass.getDeclaredMethods();
for (CtMethod ctMethod : declaredMethods) {
// 刺进核算耗时逻辑
transformMethod(ctMethod);
}
byteCode = ctClass.toBytecode();
ctClass.detach();
} catch (Exception e) {
e.printStackTrace();
}
return byteCode;
}
/**
* 为每个办法增加核算履行耗时的逻辑。
*
* @param ctMethod 概况见{@link CtMethod}。
*/
private void transformMethod(CtMethod ctMethod) throws Exception {
// 在办法内增加本地参数
ctMethod.addLocalVariable("beginTime", CtClass.longType);
ctMethod.addLocalVariable("endTime", CtClass.longType);
ctMethod.addLocalVariable("executeTime", CtClass.longType);
// 办法体之前增加核算开端时刻的代码
ctMethod.insertBefore("beginTime = System.currentTimeMillis();");
// 办法体结束位置增加获取结束时刻并核算履行耗时的代码
String endCode = "endTime = System.currentTimeMillis();" +
"executeTime = endTime - beginTime;" +
"System.out.println(executeTime);";
ctMethod.insertAfter(endCode);
}
}
在MTransformer的结构函数中，需求传入方针类的类方针的调集，意图便是做到动态的操控对哪些类增加办法耗时核算的逻辑。
最终界说Java Agent的主体类，命名为MethodAgent，代码如下所示。
public class MethodAgent {
public static final String REGEX_QUALIFIER = "\\.";
private static final String REGEX_CLASS_SUFFIX = "\\.class";
private static final String QUALIFIER = ".";
private static final String CLASS_SUFFIX = ".class";
public static final String PATH_SEP = "/";
private static final String SEP = ",";
private static final String EMPTY = "";
public static void agentmain(String agentArgs, Instrumentation instrumentation) {
if (agentArgs == null) {
return;
}
// 希望agentArgs传入的是一个以英文逗号分隔的多个途径
String[] basePackages = agentArgs.split(SEP);
List<Class<?>> targetClasses = new ArrayList<>();
for (String basePackage : basePackages) {
try {
// 获取到传入途径下的一切类的类方针
findClasses(basePackage, targetClasses, MethodAgent.class.getClassLoader());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
// 根据获取到的类的类方针调集创立MTransformer，并向Instrumentation注册MTransformer转换器
// 需求指定canRetransform为true，否则下面调用的retransformClasses()办法会不收效
instrumentation.addTransformer(new MTransformer(targetClasses), true);
try {
// 将一切方针类经过retransformClasses()办法传递到MTransformer转换器完结转换
instrumentation.retransformClasses(targetClasses.toArray(new Class<?>[0]));
} catch (Exception e) {
e.printStackTrace();
}
}
private static void findClasses(String basePackage, List<Class<?>> clazzList, ClassLoader classLoader)
throws IOException, ClassNotFoundException {
Enumeration<URL> resources = classLoader.getResources(basePackage.replaceAll(REGEX_QUALIFIER, PATH_SEP));
while (resources.hasMoreElements()) {
URL url = resources.nextElement();
String[] fileNames = new File(url.getPath()).list();
if (fileNames == null || fileNames.length == 0) {
return;
}
for (String fileName : fileNames) {
if (!fileName.endsWith(CLASS_SUFFIX)) {
findClasses(basePackage + QUALIFIER + fileName, clazzList, classLoader);
} else {
clazzList.add(Class.forName(basePackage + QUALIFIER + fileName.replaceAll(REGEX_CLASS_SUFFIX, EMPTY)));
}
}
}
}
}
至此Java Agent就编写结束，整个的工程目录如下所示。
可以先将Java Agent进行打包，并将得到的jar包放在磁盘的某个途径下，这儿就放在D盘的根途径下（D:\myagent-core-jar-with-dependencies.jar）。
下面编写测验工程。首要创立Maven工程，命名为myagent-local-test，POM文件如下所示。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.lee.learn.agent</groupId>
<artifactId>myagent-local-test</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>com.sun</groupId>
<artifactId>tools</artifactId>
<version>1.8</version>
<scope>system</scope>
<systemPath>${java.home}/../lib/tools.jar</systemPath>
</dependency>
</dependencies>
</project>
首要便是引进sun的东西包。
然后创立两个测验方针类，InnerTask坐落com.lee.learn.agent.test.inner包途径下，OuterTask坐落com.lee.learn.agent.test.outter包途径下，完结如下所示。
public class InnerTask {
public void execute() {
System.out.println("Begin to execute inner task.");
LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);
}
public void close() {
System.out.println("Begin to close inner task.");
LockSupport.parkNanos(1000 * 1000 * 1000 * 3L);
}
}
public class OuterTask {
public void execute() {
System.out.println("Start to execute outer task.");
LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);
}
public void close() {
System.out.println("Start to close outer task.");
LockSupport.parkNanos(1000 * 1000 * 1000 * 3L);
}
}
然后便是主测验办法，如下所示。
public class MainTest {
private static final String agentPath = "D:\\myagent-core-jar-with-dependencies.jar";
public static void main(String[] args) {
loadAgent();
InnerTask innerTask = new InnerTask();
innerTask.execute();
innerTask.close();
OuterTask outerTask = new OuterTask();
outerTask.execute();
outerTask.close();
}
private static void loadAgent() {
try {
// 获取主进程Id
String jvmId = getJvmId();
// Attach到主进程
VirtualMachine virtualMachine = VirtualMachine.attach(jvmId);
// 加载Java Agent，并指定包途径
virtualMachine.loadAgent(agentPath, "com.lee.learn.agent.test.inner");
virtualMachine.detach();
} catch (Exception e) {
e.printStackTrace();
}
}
private static String getJvmId() {
RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
String runtimeMXBeanName = runtimeMXBean.getName();
return runtimeMXBeanName.split("@")[0];
}
}
因为事前已经将Java Agent的jar包放在了D盘根途径下，所以在测验程序中attach到主进程中后，直接经过jar包加载Java Agent。
测验工程目录结构如下所示。
运转测验程序，打印如下所示。
四. 办法耗时核算东西的Springboot的starter包完结
第三节中的办法耗时核算东西，功能是完结了，并且首要便是依托一个Java Agent的jar包，可是实在是太粗陋了，作为超绝战损版也彻底不能看，缺点如下。
- Java Agent的jar包需求经过某种手段才能让运用程序找得到。例如容器中的一个运用，要运用这个Java Agent，首要要做的工作便是下载jar包，然后拷贝到容器中的某个途径下；
- 对用户代码产生了侵入。在测验程序中，编写了代码并调用了com.sun.tools.attach包的VirtualMachine的相关API才完结了attach主进程以及加载Java Agent，这在实际运用中，咱们必定都是不愿意做这个工作的。
鉴于第三节中的做法实在是不高雅，所以本节会编写一个办法耗时核算的starter包，只需求在Springboot工程中引用这个包，然后做少数装备，就可以完结和第三节相同的办法耗时核算效果。
全领会创立三个工程，如下所示。
- myagent-package工程。该工程仅需求做一件工作，便是寄存Java Agent的jar包；
- myagent-starter工程。starter包，首要完结的工作便是完结Java Agent的加载；
- myagent-starter-test工程。测验工程。
首要的做法和部分代码，参阅了Arthas的Springboot的starter包arthas-spring-boot-starter的完结。
1. myagent-package工程
创立一个Maven工程，命名为myagent-package，然后将Java Agent的jar包打成zip包并放在myagent-package工程的src/main/resources目录下，如下所示。
最终将myagent-package经过install安装到本地库房。
2. myagent-starter工程
创立一个Maven工程，POM文件如下所示。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<artifactId>spring-boot-parent</artifactId>
<groupId>org.springframework.boot</groupId>
<version>2.7.6</version>
</parent>
<groupId>com.lee.learn.agent</groupId>
<artifactId>myagent-starter</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>com.sun</groupId>
<artifactId>tools</artifactId>
<version>1.8</version>
<scope>system</scope>
<systemPath>${java.home}/../lib/tools.jar</systemPath>
</dependency>
<dependency>
<groupId>com.lee.learn.agent.package</groupId>
<artifactId>myagent-package</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.zeroturnaround</groupId>
<artifactId>zt-zip</artifactId>
<version>1.14</version>
</dependency>
</dependencies>
</project>
上述POM文件中引进的zt-zip是一个zip包东西，然后最关键的便是需求引进myagent-package的依托，Java Agent的jar包的压缩包就在这个依托包中。
myagent-starter的核心思路便是根据Springboot的SPI机制注册一个ApplicationListener监听器，监听的工作是ApplicationEnvironmentPreparedEvent，也便是在外部装备加载结束后就开端加载Java Agent。
现在先创立src/main/resources/META-INF目录，然后创立spring.factories文件，内容如下所示。
org.springframework.context.ApplicationListener=\
com.learn.agent.starter.MyAgentApplicationListener
自界说的工作监听器MyAgentApplicationListener完结如下所示。
public class MyAgentApplicationListener implements GenericApplicationListener {
private static final Class<?>[] EVENT_TYPES = {ApplicationEnvironmentPreparedEvent.class};
@Override
public boolean supportsEventType(ResolvableType eventType) {
return isAssignableFrom(eventType.getRawClass(), EVENT_TYPES);
}
@Override
public void onApplicationEvent(ApplicationEvent event) {
if (event instanceof ApplicationEnvironmentPreparedEvent) {
ConfigurableEnvironment environment = ((ApplicationEnvironmentPreparedEvent) event).getEnvironment();
try {
new MyAgentLoader(environment).load();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
private boolean isAssignableFrom(Class<?> type, Class<?>... supportedTypes) {
if (type != null) {
for (Class<?> supportedType : supportedTypes) {
if (supportedType.isAssignableFrom(type)) {
return true;
}
}
}
return false;
}
}
监听到ApplicationEnvironmentPreparedEvent工作后，就会创立一个MyAgentLoader加载器并调用其load() 办法。Java Agent的加载器MyAgentLoader完结如下。
public class MyAgentLoader {
private static final int TEMP_DIR_ATTEMPTS = 10000;
private static final String AGENT_ZIP_NAME = "myagent-core-jar-with-dependencies.zip";
private static final String AGENT_JAR_NAME = "myagent-core-jar-with-dependencies.jar";
private final ConfigurableEnvironment environment;
public MyAgentLoader(ConfigurableEnvironment environment) {
this.environment = environment;
}
public void load() throws IOException {
// 创立暂时目录用于寄存agent的jar包
File tempDir = createTempDir();
// 解压得到agent的jar包并放到暂时目录
URL agentJarUrl = this.getClass().getClassLoader().getResource(AGENT_ZIP_NAME);
ZipUtil.unpack(agentJarUrl.openStream(), tempDir);
// 拿到主进程Id
String jvmId = getJvmId();
String basePackage = environment.getProperty("myagent.basepackage");
try {
// Attach到主进程
VirtualMachine virtualMachine = VirtualMachine.attach(jvmId);
// 加载Java Agent，并传入包途径
virtualMachine.loadAgent(new File(tempDir.getAbsolutePath(), AGENT_JAR_NAME).getAbsolutePath(), basePackage);
virtualMachine.detach();
} catch (Exception e) {
e.printStackTrace();
}
}
private static File createTempDir() {
File baseDir = new File(System.getProperty("java.io.tmpdir"));
String baseName = "myagent-" + System.currentTimeMillis() + "-";
for (int counter = 0; counter < TEMP_DIR_ATTEMPTS; counter++) {
File tempDir = new File(baseDir, baseName + counter);
if (tempDir.mkdir()) {
return tempDir;
}
}
throw new IllegalStateException("Failed to create directory within " + TEMP_DIR_ATTEMPTS + " attempts (tried "
+ baseName + "0 to " + baseName + (TEMP_DIR_ATTEMPTS - 1) + ')');
}
private static String getJvmId() {
RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
String runtimeMXBeanName = runtimeMXBean.getName();
return runtimeMXBeanName.split("@")[0];
}
}
MyAgentLoader#load办法的首要思路如下。
- 创立用于寄存Java Agent的jar包的暂时目录；
- 从classpath下找到Java Agent的zip包；
- 将Java Agent的zip包解压到刚创立出来的暂时目录中；
- 拿到主进程Id；
- 从Environment中拿到装备的方针包途径；
- 根据VirtualMachine附加到主进程上；
- 加载Java Agent，并传入方针包途径。
至此starter包就编写结束。myagent-starter工程的目录结构如下所示。
最终还需求将myagent-starter经过install安装到本地库房。
3. myagent-starter-test工程
现在开端编写测验工程并完结测验，测验工程的目录结构如下所示。
是一个简单的三层架构，首要POM文件如下所示。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-parent</artifactId>
<version>2.7.6</version>
</parent>
<groupId>com.lee.learn.agent</groupId>
<artifactId>myagent-starter-test</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.leanr.agent.starter</groupId>
<artifactId>myagent-starter</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
然后MyController，MyService和MyDao的完结如下。
@RestController
public class MyController {
@Autowired
private MyService myService;
@GetMapping("/testagent")
public String testAgent() {
LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);
myService.testAgent();
System.out.println("MyController executed.");
return "Test Agent Success.";
}
}
@Service
public class MyService {
@Autowired
private MyDao myDao;
public void testAgent() {
LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);
myDao.testAgent();
System.out.println("MyService executed.");
}
}
@Repository
public class MyDao {
public void testAgent() {
LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);
System.out.println("MyDao executed.");
}
}
也便是模仿每个办法会耗时2秒。最终编写装备文件，如下所示。
myagent:
basepackage: com.lee.learn.agent.startertest.controller,com.lee.learn.agent.startertest.dao
装备仅对controller和dao包下的类进行办法耗时核算。
最终发动Springboot程序，并调用MyController接口，打印如下。
办法耗时核算确实只针对controller和dao包收效了，至此测验结束。
总结
Java Agent便是一个无法独立运转的jar包，其加载机遇可以是程序运转前和程序运转中，也便是根据Java Agent可以完结在程序运转前和程序运转中来动态的修正类。
办法耗时核算，简单的思路便是运用切面去切，首要想到的便是运用Spring的AOP来切，可是Spring的AOP都知道是根据动态署理，可是无论是JDK动态署理，仍是CGLIB动态署理，都有其局限性（貌似AspectJ可行，但这不是本文的重点），不是一切类都能切，所以本文采取的思路便是根据Java Agent再结合Javassist的能力，完结向方针类的办法刺进办法耗时核算的逻辑。
一个Java Agent的jar包，是一个很精美的jar包，可是有些时候想要这个jar包被加载，还真有点头疼，首要是放哪里怎么处理，所以供给一个Springboot的starter包貌似是一个很好的处理思路，只需求在程序中引进供给的starter包，那么咱们的程序最终无论是虚机部署，仍是容器部署，咱们都能拿到Java Agent并加载。
本文的办法耗时核算，之所以称为战损版，是因为只是做了耗时的一个打印，可是真实有用的是啥，那便是可以经过链路Id将办法调用链路以及耗时串起来，可是这也不是本文的重点。
假如觉得本篇文章对你有帮助，烦请点赞，保藏加重视。创造不易，感谢支撑！
本文正在参与「金石方案」
