Java Agent【java探针】及AspectJ

已于 2024-07-22 08:57:14 修改
阅读量1k 收藏 13
点赞数 24
分类专栏： Java零散知识学习 文章标签： java 开发语言
于 2024-06-26 01:51:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java_key_code/article/details/139971158
版权

在Java 语言中，织入切面分为：编译期织入(CTW: Compile-Time Weaving)、类加载期织入(LTW: Load-Time Weaving)和运行期织入(JDK代理和CGLIB)。编译期织入是指在Java编译期，将切面织入到类字节码中；而类加载期织入则指在类字节码加载到JVM时，织入切面；运行期织入则是采用CGLIB工具或JDK动态代理进行切面的织入。

什么是 Java Agent

Java Agent 又叫做 Java 探针，从JDK1.5 开始引入，可在类加载前修改class字节码。

Jvm启动参数 -javaagent 参数 俗称java探针技术(Premain方式)

使用方法：-javaagent:xxx.jar, 在main方法执行前查找jar中MANIFEST.MF文件的Premain-Class配置项，Premain-Class对应一个java类，然后执行方法premain(String options, Instrumentation instrumentation) 和premain(String options)，如果同时存在，执行前者。

示例说明：

一个普通业务类：

package org.aop.service;

public class UserService {
    public void say() {
        System.out.println("Hello World!!");
    }
}

Premain-Class类：CustomPremainAgent，方法premain只执行一次

package org.aop.agent;

import java.lang.instrument.Instrumentation;

public class CustomPremainAgent {
    public static void premain(String agentArgs, Instrumentation inst) {
        if (inst == null) {
            throw new UnsupportedOperationException("JDK5才开始支持!!! preMain -javaagent");
        }

        System.out.println("Running==>premain(String agentArgs, Instrumentation inst)");
        System.out.println("agentArgs : " + agentArgs);

        //加入自定义转换器
        inst.addTransformer(new CustomClassFileTransformer(), true);
    }

    public static void premain(String agentArgs) {
        System.out.println("Running==>premain(String agentArgs)");
    }
}

Instrumentation：premain方法参数，由jvm虚拟机自动传入，class字节码载入jvm时触发执行transform方法(只执行一次)。

ClassFileTransformer类：CustomPremainAgent，拦截UserService类，利用javassist工具修改UserService的class字节码，修改say()方法添加切面功能

package org.aop.agent;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;

public class CustomClassFileTransformer implements ClassFileTransformer {

    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
        if (className.equals("org/aop/service/UserService")) {
            ClassPool classPool = ClassPool.getDefault();
            try {
                CtClass ctClass = classPool.get("org.aop.service.UserService");
                CtMethod ctMethod = ctClass.getDeclaredMethod("say");
                ctMethod.insertBefore("System.out.println(\"-javassist-- before say() ---\");");
                ctMethod.insertAfter("System.out.println(\"-javassist-- after say() ---\");");
                ctClass.detach();
                return ctClass.toBytecode();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return new byte[0];
    }
}

MANIFEST.MF：在类路径META-INF下创建MANIFEST.MF文件

Manifest-Version: 1.0
Premain-Class: org.aop.agent.CustomPremainAgent
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Class-Path: javassist-3.20.0-GA.jar
Build-Jdk-Spec: 1.8
Created-By: Maven Jar Plugin 3.2.0

然后将CustomPremainAgent.java、CustomClassFileTransformer.java、META-INF/MANIFEST.MF编译后打包.

如果用maven打包可以不用手动创建MANIFEST.MF文件

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.2.0</version>
    <configuration>
        <includes>
            <include>org/aop/agent/CustomPremainAgent.class</include>
            <include>org/aop/agent/CustomClassFileTransformer.class</include>
        </includes>
        <archive>
            <!--自动添加META-INF/MANIFEST.MF -->
            <manifest>
                <addClasspath>true</addClasspath>
            </manifest>
            <manifestEntries>
                <Premain-Class>org.aop.agent.CustomPremainAgent</Premain-Class>
                <Can-Redefine-Classes>true</Can-Redefine-Classes>
                <Can-Retransform-Classes>true</Can-Retransform-Classes>
            </manifestEntries>
        </archive>
    </configuration>
</plugin>

最后打包路径：D:/workspace/demo/target/user-service-agent.jar

测试代码：

public static void main(String[] args) {
    UserService service = new UserService();
    service.say();
}

在vm参数中加入：-javaagent:D:/workspace/demo/target/user-service-agent.jar

运行结果：

从JDK6开始，引入一种新的方式：Agentmain方式.
Premain只能在类加载之前修改字节码，类加载之后无能为力。而Agentmain恰恰可以弥补这缺点。Agentmain 可以在类加载之后再次加载这个类。

使用方法：VirtualMachine.loadAgent("XXX.jar", agentArgs), 在main方法执行中查找jar中MANIFEST.MF文件的Agent-Class配置项，Agent-Class对应一个java类，然后执行方法agentmain(String options, Instrumentation instrumentation) 和agentmain(String options)，如果同时存在，执行前者。

示例说明：

Agent-Class类：CustomAgentmainAgent，方法agentmain只执行一次

package org.aop.agent;

import org.aop.service.UserService;

import java.lang.instrument.Instrumentation;

public class CustomAgentmainAgent {
    public static void agentmain(String agentArgs, Instrumentation inst) {
        if (inst == null) {
            throw new UnsupportedOperationException("JDK6才开始支持!!! agentmain -javaagent");
        }

        System.out.println("Running==>agentmain(String agentArgs, Instrumentation inst)");
        System.out.println("agentArgs : " + agentArgs);

        //加入自定义转换器
        inst.addTransformer(new CustomClassFileTransformer(), true);
        try {
            //允许修改字节码
            inst.retransformClasses(UserService.class);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void agentmain(String agentArgs) {
        System.out.println("Running==>agentmain(String agentArgs)");
    }
}

MANIFEST.MF：在类路径META-INF下创建MANIFEST.MF文件

Manifest-Version: 1.0
Agent-Class: org.aop.agent.CustomAgentmainAgent
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Class-Path: javassist-3.20.0-GA.jar
Build-Jdk-Spec: 1.8
Created-By: Maven Jar Plugin 3.2.0

然后将CustomAgentmainAgent .java、CustomClassFileTransformer.java、META-INF/MANIFEST.MF编译后打包.

最后打包路径：D:/workspace/demo/target/user-service-agent.jar

测试代码：

import com.sun.tools.attach.VirtualMachine;
import org.aop.service.UserService;

import java.lang.management.ManagementFactory;
import java.util.concurrent.TimeUnit;

public class AgentmainTest {
    public static void main(String[] args) throws Exception {
        taskThread.start();
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (Exception e) {
            e.printStackTrace();
        }

        String pid = jvmPid();
        System.out.println("进程pid==>" + pid);
        agent(pid);
    }

    /**
     * 获取jvm进程ID
     * 还可以通过jdk内置命令：jps -l 获取jvm进程ID
     * @return
     */
    private static String jvmPid() {
        String thisJvmName = ManagementFactory.getRuntimeMXBean().getName();
        String thisJvmPid = thisJvmName.split("@")[0];
        return thisJvmPid;
    }

    /**
     * 模拟运行中的系统
     */
    private static Thread taskThread =  new Thread() {
        @Override
        public void run() {
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(3);
                    UserService service = new UserService();
                    service.say();
                    System.out.println("\n");
                } catch (Exception e) {}
            }
        }
    };

    /**
     * agent attach
     *
     * @param pid
     */
    public static void agent(String pid) {
        try {
            System.out.println("=========准备增强类=========");
            VirtualMachine vm = VirtualMachine.attach(pid);
            vm.loadAgent("D:/workspace/demo/target/user-service-agent.jar", "org.aop.service.UserService");
            vm.detach();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
编译时，VirtualMachine可能无法编译，可以pom.xml添加如下依赖解决
<dependency>
    <groupId>jdk.tools</groupId>
    <artifactId>jdk.tools</artifactId>
    <version>1.8</version>
    <scope>system</scope>
    <!--<systemPath>${java.home}/lib/tools.jar</systemPath>-->
    <systemPath>C:/Program Files/Java/jdk-1.8/lib/tools.jar</systemPath>
</dependency>

运行结果：

什么是 AspectJ

AspectJ是一个面向切面的框架（AOP框架）。利用 -javaagent 实现的类加载期切面织入(LTW: Load-Time Weaving)

官网地址: Intro to AspectJ | Baeldung

源码地址：GitHub - eclipse-aspectj/aspectj

查看AspectJ jar包中的MANIFEST.MF可得知AspectJ的Premain-Class是 org.aspectj.weaver.loadtime.Agent

AspectJ从1.8.7版本开始支持Agentmain方式。

简单demo示例：

业务类：

package org.aop.service;

public class UserService {
    public void say() {
        System.out.println("Hello World!!");
    }
}

增强类：

package org.aop.aspectj;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class AspectConfig {

	@Pointcut("execution(* org.aop.service..*.*(..))")
	public void callAt() {
	}

	@Around("callAt()")
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("Around==>before");
		Object object = pjp.proceed();
		System.out.println("Around==>after");
		return object;
	}

	public static AspectConfig aspectOf() {
		return new AspectConfig();
	}
}

META-INF新增aop.xml文件

<aspectj>
	<aspects>
		<aspect name="org.aop.aspectj.AspectConfig"/>
		<weaver options="-verbose -showWeaveInfo">
			<include within="org.aop.service.*"/>
		</weaver>
	</aspects>
</aspectj>

测试代码：

package org.aop;

import org.aop.service.UserService;

/*
  AspectJ官网地址：https://www.baeldung.com/aspectj

  在类路径META-INF下创建 aop.xml文件
  内容：
	<aspectj>
		<aspects>
			<aspect name="org.spring.aop.aspectj.AspectConfig"/>
			<weaver options="-verbose -showWeaveInfo">
				<include within="org.spring.aop.service.*"/>
			</weaver>
		</aspects>
	</aspectj>

  jvm启动参数：-javaagent:C:/Users/用户目录/.m2/repository/org/aspectj/aspectjweaver/1.7.4/aspectjweaver-1.7.4.jar
 */
public class AspectJMain {

	public static void main(String[] args) {
		UserService service = new UserService();
		service.say();
	}
}

执行测试：

   添加vm参数：-javaagent:XXXXX/aspectjweaver-1.7.4.jar

可以重写AspectJ的Premain-Class和ClassFileTransformer，将修改后的类字节码写入文件，查看生成情况。

package org.aop.agent;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;

public class AspectAgent {
    /**
     * The instrumentation instance
     */
    private static Instrumentation s_instrumentation;

    /**
     * The ClassFileTransformer wrapping the weaver
     */
    private static ClassFileTransformer s_transformer = new ClassPreProcessorAgentAdapter();

    /**
     * JSR-163 preMain Agent entry method
     *
     * @param options
     * @param instrumentation
     */
    public static void premain(String options, Instrumentation instrumentation) {
        /* Handle duplicate agents */
        if (s_instrumentation != null) {
            return;
        }
        s_instrumentation = instrumentation;
        s_instrumentation.addTransformer(s_transformer);
    }

    /**
     * Returns the Instrumentation system level instance
     */
    public static Instrumentation getInstrumentation() {
        if (s_instrumentation == null) {
            throw new UnsupportedOperationException("Java 5 was not started with preMain -javaagent for AspectJ");
        }
        return s_instrumentation;
    }
}
package org.aop.agent;

import org.aspectj.weaver.loadtime.Aj;
import org.aspectj.weaver.loadtime.ClassPreProcessor;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.lang.instrument.ClassFileTransformer;
import java.nio.file.Files;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.ProtectionDomain;

/**
 * Java 1.5 adapter for class pre processor
 *
 * @author <a href="mailto:alex@gnilux.com">Alexandre Vasseur</a>
 */
public class ClassPreProcessorAgentAdapter implements ClassFileTransformer {

    /**
     * Concrete preprocessor.
     */
    private static ClassPreProcessor s_preProcessor;

    static {
        try {
            s_preProcessor = new Aj();
            s_preProcessor.initialize();
        } catch (Exception e) {
            throw new ExceptionInInitializerError("could not initialize JSR163 preprocessor due to: " + e.toString());
        }
    }

    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] bytes) {
        if (classBeingRedefined != null) {
            System.err.println("INFO: (Enh120375):  AspectJ attempting reweave of '" + className + "'");
        }
        byte[] newByte = s_preProcessor.preProcess(className, bytes, loader, protectionDomain);
        if (className.equals("org/aop/service/UserService")) { //写入文件
            this.writeFile(newByte);
        }
        return newByte;
    }

    //写入文件
    private void writeFile(byte[] newByte) {
        try {
            String dirPath = System.getProperty("user.dir") + "/src/proxy";
            Path outDirPath = Paths.get(dirPath);
            Files.createDirectories(outDirPath);
            Path outPath = Paths.get(dirPath + "/UserService$Proxy01.class");
            Files.write(outPath, newByte, new OpenOption[0]);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

记得重新生成MANIFEST.MF配置内容，重新打包，修改 -javaagent:XXX/自己的.jar.

java_key_code
关注
  • 24
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javaagent+javassist
12-25
环境JDK1.8 IDEA项目 javaagent+javassist 下载后导入即可
Java Agent探针技术
yangyanping20108的博客
11-22 1724
Java Agent探针，JVM 一旦跑起来，对于外界来说，它就是一个黑盒。而 Java Agent 可以像一支针一样插到 JVM 内部，探到我们想要的东西，并且可以注入东西进去。
LF-Spy(Java服务器探针)
05-09
LF-Spy是一个基于单独jsp页面的Java服务器探针，使用它您可以方便的获得您所处Java服务器的系统信息，是您了解您所在空间真实情况的重要工具。LF-Spy能够自动测试目标Java服务器的网络连接速度、MAC地址、服务器硬盘剩余空间、服务器运算能力、服务器的内存资源损耗、cpu占用率、硬盘大小、页面执行时间等参数。并提供服务器基本信息，服务器组件支持情况，及从request、response、application、session、cookies中截获参数等辅助功能。
java探针
yhd723948277的博客
03-13 168
注入字节码的一种方式，日后补充
JAVA探针
热门推荐
点点的博客
08-28 1万+
一、需求 Tomcat： （1）模块启动时间 （2）模块交互耗时 二、现状 现代APM体系，基本都是参考Google的Dapper（大规模分布式系统的跟踪系统）的体系来做的。通过跟踪请求的处理过程，来对应用系统在前后端处理、服务端调用的性能消耗进行跟踪，关于Dapper的介绍可以看这个链接：http://bigbully.github.io/Dapper-translation/ 下面重点选...
SrvProbe++(java) - web服务器探针
09-22
用来查看到web服务器的信息！ 使用方法： 1.可以单个查看web服务器版本，并打开网址。 2.将多个网址放到记事本中。然后将文件拖入到程序中，运行检测即可（使用了多线程）！ 3.支持检测最近的nginx漏洞。 注意：linux下无法使用拖文件功能.程序很简单，不过大家支持哈原创，给两分应该不贵呀，谢谢！
Aspectj,java,aop工具
11-18
AspectJ是Java编程语言的一个重要扩展，它引入了面向切面编程（AOP）的概念，使得开发者能够更方便地处理横切关注点，如日志、事务管理、权限检查等。面向切面编程是一种编程范式，旨在提高软件的模块化程度，将核心...
aspectj-1.9.6.jar
04-07
《AspectJ 1.9.6.jar：Java AOP编程的基石》 AspectJ是Java平台上的一种面向切面编程（AOP）框架，它允许开发者将关注点分离，提高代码的可维护性和可复用性。AspectJ 1.9.6.jar文件是AspectJ库的核心组成部分，它...
java Spring aop所需Jar包
06-02
1. **AspectJ**: AspectJ是Java平台上的一个开源项目，它提供了全面的面向切面编程(AOP)支持。AspectJ提供了一种编译时和运行时的AOP解决方案，允许开发者定义“切面”，这些切面可以包含业务逻辑、通知（advice）和...
java aspectj.jar+aspectjrt.jar+aspectjweaver.jar
08-30
java aop 三个jar包， 文件列表: aspectj-1.8.10.jar,aspectjrt.jar,aspectjweaver.jar 配置方法 aop:aspectj-autoproxy 亲测可正常运行, 资源来于网络,非本人原创
Java探针技术--javaAgent
qq_45443475的博客
08-25 2616
Java探针技术--javaAgent
【JAVA基础☞探针技术】Java探针-Java Agent技术
JKX_geek的博客
03-08 311
个人博客导航页（点击右侧链接即可打开个人博客）：大牛带你入门技术栈 1、原理：基于javaAgent和Java字节码注入技术的java探针工具技术原理 2、原理分析 动态代理功能实现说明，我们利用javaAgent和ASM字节码技术开发java探针工具，实现原理如下： jdk1.5以后引入了javaAgent技术，javaAgent是运行方法之前的拦截器。我们利用javaAgen...
java技术：Java Agent探针技术
最新发布
guanglihuan的专栏
03-08 561
Java Agent 是一种特殊类型的工具，可以在 JVM 启动时或运行时加载。它们广泛用于监控、性能分析、代码热替换、以及其他需要修改字节码或访问 JVM 内部信息的场景。探针（Probe）通常指的是监控工具中的一部分，用来收集数据或监控应用的行为。
Java探针 Instrumentation
私欲日生，如地上尘，一日不扫，便又有一层。着实用功，便见道无终穷，愈探愈深，必使精白无一毫不彻方可。
12-24 275
我们知道只要是java程序，运行的入口就一定是main方法。Java探针技术相当于变相的改变了这个约定，提供了一种外挂，只要用了这个外挂(即在程序的运行时参数中加了-javaagent)，就可以先执行外挂jar包中的premain方法，然后再执行原程序中的main方法。这样就提供了一个在真正的程序执行前，可以修改并重新加载字节码的机会。 作者：whslowly 链接：https://www.jianshu.com/p/90f149d6cf95 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商
Java的AspectJ代码举例
03-21
以下是一个简单的AspectJ代码示例： ``` @Aspect public class LoggingAspect { @Before("execution(* com.example.service.*.*(..))") public void logBefore(JoinPoint joinPoint) { System.out.println("Before executing " + joinPoint.getSignature().getName() + " method"); } @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result") public void logAfterReturning(JoinPoint joinPoint, Object result) { System.out.println("After executing " + joinPoint.getSignature().getName() + " method with result " + result); } @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "exception") public void logAfterThrowing(JoinPoint joinPoint, Throwable exception) { System.out.println("Exception thrown by " + joinPoint.getSignature().getName() + " method with message " + exception.getMessage()); } } ``` 这是一个简单的日志切面，它会在执行 com.example.service 包中的任何方法之前、之后和抛出异常时打印日志。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值