--- highlight: a11y-dark --- > 大家好，我是**半夏之沫** 😁😁 一名金融科技领域的**JAVA**系统研发😊😊
> 我希望将自己工作和学习中的经验以**最朴实**，**最严谨**的方式分享给大家，共同进步👉💓👈
> 👉👉👉👉👉👉👉👉💓**写作不易，期待大家的关注和点赞**💓👈👈👈👈👈👈👈👈
> 👉👉👉👉👉👉👉👉💓**关注微信公众号【技术探界】** 💓👈👈👈👈👈👈👈👈 新来的实习生妹妹故意刁难我，说想让我实现一个方法耗时统计工具，不能用切面，这能难倒我嘛，**Java Agent**安排上。 *** ## 前言本篇文章将实现一个超绝战损版的基于**Java Agent**的方法耗时统计工具。整体内容分为： 1. **Java Agent**原理简析； 2. 方法耗时统计工具实现； 3. 方法耗时工具的**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](https://docs.oracle.com/javase/8/docs/platform/jvmti/jvmti.html)。那么**Java Agent**可以理解为就是**JVM TI**的一种具体实现。关于**Java Agent**，可以概括其特性如下。 1. 是一个**jar**包； 2. 无法独立运行； 3. （**JDK1.5**）可以在程序运行前被加载，加载后会调用到**Java Agent**提供的入口函数**premain(String agentArgs, Instrumentation inst)**； 4. （**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**提供的重要方法如下所示。 ```java 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**中。 ### 二. 整体构思首先，因为是超绝战损版，所以我们的方法耗时统计，伪代码可以表示如下。 ```java 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**的能力，为相应的类添加方法耗时统计的代码片段，并完成重加载。最后，还需要编写一个测试程序来验证我们的超绝战损版方法耗时打印工具的功能。整体的一个流程示意图如下。

JVM-JavaAgent实现方法耗时统计流程图

### 三. 方法耗时统计工具实现现在开始代码实现。首先创建一个**Maven**工程，命名为**myagent-core**，**POM**文件如下所示。 ```xml 4.0.0 com.lee.learn.agent myagent-core 1.0-SNAPSHOT 8 8 javassist javassist 3.12.1.GA myagent-core maven-assembly-plugin src/main/resources/META-INF/MANIFEST.MF jar-with-dependencies make-assembly package single ``` **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**接口，代码现如下。 ```java public class MTransformer implements ClassFileTransformer { /** * 目标类的类全限定名和类加载器的映射，用于筛选出需要重定义的类。 * 映射类型是：Map[类全限定名, 类加载器]。 */ private final Map targetClassesMap = new HashMap<>(); /** * 初始化时就需要传入目标类集合，并转换成映射关系。 * * @param targetClasses 目标类的类对象集合。 */ public MTransformer(List> 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**，代码如下所示。 ```java 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> 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> clazzList, ClassLoader classLoader) throws IOException, ClassNotFoundException { Enumeration 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**就编写完毕，整个的工程目录如下所示。

JavaAgent工程目录图

可以先将**Java Agent**进行打包，并将得到的**jar**包放在磁盘的某个路径下，这里就放在**D**盘的根路径下（**D:\myagent-core-jar-with-dependencies.jar**）。下面编写测试工程。首先创建**Maven**工程，命名为**myagent-local-test**，**POM**文件如下所示。 ```xml 4.0.0 com.lee.learn.agent myagent-local-test 1.0-SNAPSHOT 8 8 com.sun tools 1.8 system ${java.home}/../lib/tools.jar ``` 主要就是引入**sun**的工具包。然后创建两个测试目标类，**InnerTask**位于**com.lee.learn.agent.test.inner**包路径下，**OuterTask**位于**com.lee.learn.agent.test.outter**包路径下，实现如下所示。 ```java 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); } } ``` 然后就是主测试方法，如下所示。 ```java 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**包，但是实在是太简陋了，作为超绝战损版也完全不能看，缺点如下。 1. **Java Agent**的**jar**包需要通过某种手段才能让应用程序找得到。例如容器中的一个应用，要使用这个**Java Agent**，首先要做的事情就是下载**jar**包，然后拷贝到容器中的某个路径下； 2. 对用户代码产生了侵入。在测试程序中，编写了代码并调用了**com.sun.tools.attach**包的**VirtualMachine**的相关**API**才实现了**attach**主进程以及加载**Java Agent**，这在实际使用中，大家肯定都是不愿意做这个事情的。鉴于第三节中的做法实在是不优雅，所以本节会编写一个方法耗时统计的**starter**包，只需要在**Springboot**工程中引用这个包，然后做少量配置，就能够实现和第三节一样的方法耗时统计效果。整体会创建三个工程，如下所示。 1. **myagent-package**工程。该工程仅需要做一件事情，就是存放**Java Agent**的**jar**包； 2. **myagent-starter**工程。**starter**包，主要完成的事情就是完成**Java Agent**的加载； 3. **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**目录下，如下所示。

ZIP包存放目录图

最后将**myagent-package**通过**install**安装到本地仓库。 #### 2. myagent-starter工程创建一个**Maven**工程，**POM**文件如下所示。 ```xml 4.0.0 spring-boot-parent org.springframework.boot 2.7.6 com.lee.learn.agent myagent-starter 1.0-SNAPSHOT 8 8 org.springframework.boot spring-boot-starter com.sun tools 1.8 system ${java.home}/../lib/tools.jar com.lee.learn.agent.package myagent-package 1.0-SNAPSHOT org.zeroturnaround zt-zip 1.14 ``` 上述**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**实现如下所示。 ```java 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**实现如下。 ```java 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**方法的主要思路如下。 1. 创建用于存放**Java Agent**的**jar**包的临时目录； 2. 从**classpath**下找到**Java Agent**的**zip**包； 3. 将**Java Agent**的**zip**包解压到刚创建出来的临时目录中； 4. 拿到主进程**Id**； 5. 从**Environment**中拿到配置的目标包路径； 6. 基于**VirtualMachine**附加到主进程上； 7. 加载**Java Agent**，并传入目标包路径。至此**starter**包就编写完毕。**myagent-starter**工程的目录结构如下所示。

myagent-starter工程的目录结构图

最后还需要将**myagent-starter**通过**install**安装到本地仓库。 #### 3. myagent-starter-test工程现在开始编写测试工程并完成测试，测试工程的目录结构如下所示。

测试工程目录结构图

是一个简单的三层架构，首先**POM**文件如下所示。 ```xml 4.0.0 org.springframework.boot spring-boot-parent 2.7.6 com.lee.learn.agent myagent-starter-test 1.0-SNAPSHOT 8 8 org.springframework.boot spring-boot-starter-web com.leanr.agent.starter myagent-starter 1.0-SNAPSHOT ``` 然后**MyController**，**MyService**和**MyDao**的实现如下。 ```java @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秒。最后编写配置文件，如下所示。 ```yml myagent: basepackage: com.lee.learn.agent.startertest.controller,com.lee.learn.agent.startertest.dao ``` 配置仅对**controller**和**dao**包下的类进行方法耗时统计。最后启动**Springboot**程序，并调用**MyController**接口，打印如下。

Starter测试结果图

方法耗时统计确实只针对**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**将方法调用链路以及耗时串起来，但是这也不是本文的重点。如果觉得本篇文章对你有帮助，烦请点赞，收藏加关注。创作不易，感谢支持！ *** > 大家好，我是**半夏之沫** 😁😁 一名金融科技领域的**JAVA**系统研发😊😊
> 我希望将自己工作和学习中的经验以**最朴实**，**最严谨**的方式分享给大家，共同进步👉💓👈
> 👉👉👉👉👉👉👉👉💓**写作不易，期待大家的关注和点赞**💓👈👈👈👈👈👈👈👈
> 👉👉👉👉👉👉👉👉💓**关注微信公众号【技术探界】** 💓👈👈👈👈👈👈👈👈 ***本文正在参加[「金石计划」](https://juejin.cn/post/7207698564641996856/ "https://juejin.cn/post/7207698564641996856/")***