动态替换目标进程的Java类

最新推荐文章于 2024-09-02 02:11:29 发布
最新推荐文章于 2024-09-02 02:11:29 发布
阅读量3.3k 收藏 1
点赞数
分类专栏： Java

动态替换目标进程的Java类

Posted on  February 12, 2013

我们都知道在Eclipse中调试代码时，可以直接修改代码，然后继续调试，不需要重新启动它，我一直很好奇这是怎么实现的。找了一段时间后，发现做起来很简单，原理如下：

你可以把目标进程想象成你的被调试程序，而客户进程想象成Eclipse本身。当某些类有变化时，客户进程能探测到这些类的变化，然后动态换掉它们，这样目标进程就可以用上新的类了。

对应的Eclipse工程如下：

其中RunAlways工程对应的就是目标进程，它的main函数里会不停new一个新的User类，然后打印它的名字

1
2
3
4
5
6
7
8
9
10
11
12
package test ;
public class Main {
     public static void main ( String [ ] args ) throws InterruptedException {
         while ( true ) {
             //替换前，打印出 firstName.lastName
             //被替换后，打印lastName.firstName
             System . out . println ( new User ( "firstName" , "lastName" ) . getName ( ) ) ;
             Thread . sleep ( 5000 ) ;
         }
     }
}

User类的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package test ;
public class User {
     private String firstName ;
  
     private String lastName ;
    
     public User ( String firstName , String lastName ) {
         this . firstName = firstName ;
         this . lastName = lastName ;
     }
    
     public String getName ( ) {
         return firstName + "." + lastName ;
     }
}

先启动它，假设对应的进程号是1234。

接下来是代理jar的编写，这个jar就包含一个类和一个manifest.mf文件。类的内容是

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package agent ;
import java . io . DataInputStream ;
import java . io . File ;
import java . io . FileInputStream ;
import java . lang . instrument . ClassDefinition ;
import java . lang . instrument . Instrumentation ;
public class MyAgent {
   //agentArgs就是VirtualMachine.loadAgent()的第二个参数
   public static void agentmain ( String agentArgs , Instrumentation inst )
     {
         try
         {
            System . out . println ( "args: " + agentArgs ) ;
            System . out . println ( "重新定义 test.User -- 开始" ) ;
           
            //把新的User类文件的内容读出来
              File f = new File ( agentArgs ) ;
              byte [ ] reporterClassFile = new byte [ ( int ) f . length ( ) ] ;
              DataInputStream in = new DataInputStream ( new FileInputStream ( f ) ) ;
              in . readFully ( reporterClassFile ) ;
              in . close ( ) ;
             
              //把User类的定义与新的类文件关联起来
              ClassDefinition reporterDef =
                  new ClassDefinition ( Class . forName ( "test.User" ) , reporterClassFile ) ;
              //重新定义User类， 妈呀， 太简单了
              inst . redefineClasses ( reporterDef ) ;
              System . out . println ( "重新定义 test.User  -- 完成" ) ;
         }
         catch ( Exception e )
         {
             System . out . println ( e ) ;
             e . printStackTrace ( ) ;
         }
     }
}

就几句话，看注释就明白了。manifest.mf是放在src/META-INF目录下，内容是
Manifest-Version: 1.0
Agent-Class: agent.MyAgent
Can-Redefine-Classes: true

最后一句是必须的，否则运行起来目标程序会有异常：

1
2
3
4
5
6
7
8
9
java . lang . UnsupportedOperationException : redefineClasses is not supported in this environment
     at sun . instrument . InstrumentationImpl . redefineClasses ( Unknown Source )
     at agent . MyAgent . agentmain ( MyAgent . java : 24 )
     at sun . reflect . NativeMethodAccessorImpl . invoke0 ( Native Method )
     at sun . reflect . NativeMethodAccessorImpl . invoke ( Unknown Source )
     at sun . reflect . DelegatingMethodAccessorImpl . invoke ( Unknown Source )
     at java . lang . reflect . Method . invoke ( Unknown Source )
     at sun . instrument . InstrumentationImpl . loadClassAndStartAgent ( Unknown Source )
     at sun . instrument . InstrumentationImpl . loadClassAndCallAgentmain ( Unknown Source )

从Eclipse中把这个工程导出为一个jar文件，记得要包含我们的manifest.mf文件。保存在e:/agent.jar(位置随便).

Client工程的Client类是这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package client ;
import java . lang . reflect . Field ;
import com . sun . tools . attach . VirtualMachine ;
public class Client {
     /**
  * @param args
  * @throws Exception
  */
     public static void main ( String [ ] args ) throws Exception {
         //注意，是jre的bin目录，不是jdk的bin目录
         System . setProperty ( "java.library.path" ,
                 "C:\\Program Files\\Java\\jdk1.7.0_13\\jre\\bin" ) ;
         Field fieldSysPath = ClassLoader . class . getDeclaredField ( "sys_paths" ) ;
         fieldSysPath . setAccessible ( true ) ;
         fieldSysPath . set ( null , null ) ;
         //目标进程的进程id -- 记得改成正确的数字
         VirtualMachine vm = VirtualMachine . attach ( "1234" ) ;
         //参数1：代理jar的位置
         //参数2， 传递给代理的参数
         vm . loadAgent ( "e:/agent.jar" , "e:/User.class" ) ;
     }
}

main函数的前四句是必须的，否则会有这样的异常:

1
2
3
4
java . util . ServiceConfigurationError : com . sun . tools . attach . spi . AttachProvider : Provider sun . tools . attach . WindowsAttachProvider could not be instantiated : java . lang . UnsatisfiedLinkError : no attach in java . library . path
Exception in thread "main" com . sun . tools . attach . AttachNotSupportedException : no providers installed
     at com . sun . tools . attach . VirtualMachine . attach ( VirtualMachine . java : 208 )
     at client . Client . main ( Client . java : 29 )

现在就差最后一步了，就是要提供新的User类,它跟旧的User类的差别就是把lastName和firstName调换了位置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package test ;
public class User {
     private String firstName ;
  
     private String lastName ;
    
     public User ( String firstName , String lastName ) {
         this . firstName = firstName ;
         this . lastName = lastName ;
     }
    
     //打印出来的位置变了
     public String getName ( ) {
         return lastName + "." + firstName ;
     }
}

直接把这个类对应的class文件复制到e:/User.class （简单起见，你可以随便放在什么地方）。写了半天，终于可以看看成果了，直接运行Client类。然后看看目标进程的输出：

firstName.lastName
args: e:/User.class
重新定义 test.User — 开始
重新定义 test.User — 完成
lastName.firstName
lastName.firstName

妈呀，User类真的被我们改了。有点美中不足的是这个类只能被改一次，能不能像Eclise那样每次e:/User.class有变化都重新加载呢，这对整天写Java的我们来说，简直难度为0，直接启动一个线程，不停看那个文件，只要修改时间有变化，就重新加载它：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package agent ;
import java . io . DataInputStream ;
import java . io . File ;
import java . io . FileInputStream ;
import java . lang . instrument . ClassDefinition ;
import java . lang . instrument . Instrumentation ;
public class ClassFileWatcher extends Thread {
     private File classFile ;
     private long lastModified = 0 ;
     private Instrumentation inst ;
     public ClassFileWatcher ( Instrumentation inst , File classFile ) {
         this . classFile = classFile ;
         this . inst = inst ;
         lastModified = classFile . lastModified ( ) ;
     }
    
     @Override
     public void run ( ) {
         while ( true ) {
             //如果class文件有变化，则重新加载
             if ( lastModified != classFile . lastModified ( ) ) {
                 lastModified = classFile . lastModified ( ) ;
                
               System . out . println ( "重新定义 test.User -- 开始" ) ;
                 byte [ ] reporterClassFile = new byte [ ( int ) classFile . length ( ) ] ;
                 DataInputStream in ;
                 try {
                     in = new DataInputStream ( new FileInputStream ( classFile ) ) ;
                     in . readFully ( reporterClassFile ) ;
                     in . close ( ) ;
                     // 把User类的定义与新的类文件关联起来
                     ClassDefinition reporterDef = new ClassDefinition (
                             Class . forName ( "test.User" ) , reporterClassFile ) ;
                     // 重新定义User类， 妈呀， 太简单了
                     inst . redefineClasses ( reporterDef ) ;
                     System . out . println ( "重新定义test.User  -- 完成" ) ;
                 } catch ( Exception e ) {
                     e . printStackTrace ( ) ;
                 }
             }
            
             try {
                 Thread . sleep ( 3000 ) ;
             } catch ( InterruptedException e ) {
                 e . printStackTrace ( ) ;
             }
         }
     }
   
}

代理类改成这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package agent ;
import java . io . File ;
import java . lang . instrument . Instrumentation ;
public class MyAgent {
   //agentArgs就是VirtualMachine.loadAgent()的第二个参数
   public static void agentmain ( String agentArgs , Instrumentation inst )
     {
         try
         {
            System . out . println ( "args: " + agentArgs ) ;
            //把新的User类文件的内容读出来
              File f = new File ( agentArgs ) ;
              ClassFileWatcher watcher = new ClassFileWatcher ( inst , f ) ;
              watcher . start ( ) ;
             
         }
         catch ( Exception e )
         {
             System . out . println ( e ) ;
             e . printStackTrace ( ) ;
         }
     }
}

现在重新把整个过程再跑一遍，然后用新的User.class覆盖e:/User.class，每次覆盖后，你就会发现目标进程已经用上了新的版本，酷啊。

donnyxia1128
关注
专栏目录
Java使用BTrace动态替换线上class文件
qq_28834355的博客
05-12 435
概述 BTrace的功能主要是动态替换线上正在运行的class文件，一般用来增加打印所需要的日志。 安装BTrace 下载地址：https://github.com/btraceio/btrace/releases/tag/v1.3.11
别翻了，这篇文章绝对让你深刻理解java类的加载以及ClassLoader源码分析【JVM篇二】
热门推荐
宜春
12-01 5万+
点进文章的盆友不如先来做一道非常常见的面试题，如果你能做出来，可能你早已掌握并理解了java的类加载机制，若结果出乎你的意料，那就很有必要来了解了解java的类加载机制了。代码如下嗯哼？其实上面程序并不是关键，可能真的难不倒各位，不妨做下面一道面试题可好？如果下面这道面试题都做对了，那没错了，这篇文章你就不用看了，真的。
java动态替换系统类,DCEVM，Java类动态替换初级实验说明
weixin_42562079的博客
03-13 636
概述DCEVM，全称Dynamic Code Evolution，一个JVM补丁程序，其目的就是实现运行时的类替换。最新的项目地址为：https://dcevm.github.io/下面将从安装、验证、搭建测试环境、测试等几个方面进行简要说明。安装首先登录网址：https://dcevm.github.io/，站点中明确给出了Binaries(二进制程序)的下载链接，该项目分为两个版本的发布程序，...
java.lang.Instrument 动态修改替换类代码
kangojian的专栏
10-10 4928
java.lang.Instrument包是在JDK5引入的，程序员通过修改方法的字节码实现动态修改类代码。 这通常是在类的main方法调用之前进行预处理的操作，通过java指定该类的代理类来实现。   1. 代理 (agent) 是在你的main方法前的一个拦截器 (interceptor)，也就是在main方法执行之前，执行agent的代码。 agent的代码与你的main方法在同一个
【Java】Java类动态替换Class
林多
01-27 539
基于上面的几个方法，可以实现动态替换Class对象。可以在代码中，利用上面的方式，将FunctionA动态替换为FunctionB。Java提供的ClassLoader可用于动态加载的Java类，可以通过多种形式获取ClassLoader。通过这个方法，可以获取类中所有声明的构造函数。要创建类对象的话，需要知道Class的构造函数，以及构造函数的各个参数。Method类提供的newInstance，可以用于创建并返回指定类的实例。通过Java的Class对象，可以实现动态替换Class。
【java】类的热替换，让程序动态起来
zcrazy的博客
12-08 1514
什么是java热替换？ 在运行的Java系统中进行类（对象）的替换升级。 实现热替换的 第一步就是动态编译，将.java文件编译成为.class文件 第二步是动态加载，编写一个自定义的类加载器，将编译好的类加载到运行环境中去 类的加载是由不同的加载器共同完成的 BootstrapClassLoader负责sum.boot.class.path路径下类的加载，默认为jre/lib或者-Xbootclasspath指定的jar包 ExtClassLoader 负责java.ext...
Java动态替换class：agentmain + attach + transformer
gao_grace的博客
03-08 1265
前段时间，用了阿里开发的arthas，对于它是如何动态介入java程序的很感兴趣，最近有时间，就自己研究了一下，写了个简单的项目试了试。
java批量替换word内容_word多个文档替换内容
weixin_29172963的博客
02-27 1281
替换文件夹下所有文档的内容，需要替换的文档不能打开，采用宏进行批量替换，亲测成功，测试是word2016根据简书作者改编https://www.jianshu.com/p/9d348b8015b6?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation第一步...
Java热替换（一）
GonnaFlyNow的博客
11-21 1156
通过java agent、attach api、instrumentation技术，实现java的class文件热替换。
Java_覆盖引导的JVM进程内模糊测试.zip
05-22
这使得我们可以在运行时动态地加载或修改类，这对于模糊测试来说非常有用，因为它允许我们插入特殊的行为或者监控代码，以便更有效地测试目标程序。 模糊测试在JVM进程内进行的优势在于可以直接对字节码级别进行...
java字节码例子 可以动态修改类 bcel
03-22
NULL 博文链接：https://andilyliao.iteye.com/blog/899925
java 动态替换_java中的动态加载和热替换
weixin_36156538的博客
02-13 549
https://blog.csdn.net/u010833547/article/details/54312052*************************************************************1.C++编写的程序需要经过编译称为目标文件，然后在程序执行之前进行链接后才可以称为可以运行的可执行程序，这个链接可以发生在程序运行之前，也可以发生在程序运行后(在...
java 动态替换_利用springloaded进行java class动态替换
weixin_39940253的博客
02-13 516
我们知道对于一个java文件，如Test.java，首先需要通过javac命令(javac Test.java)进行编译，生成class文件，再将class文件在jvm上进行加载运行，也就是java命令(java Test)。但是对于以下应用场景：正在运行的java程序，即class文件已经在jvm中运行加载，如果原来的java程序有所改动，重新生成了class文件，但是又不希望kill掉原先的j...
javassist 动态修改 jar 包中 class
Primary_wind的专栏
06-23 1945
请注意，Javassist仅在运行时修改了类的字节码，不会直接修改Jar包中的类文件。如果你需要将修改后的类保存到Jar包中，你需要在运行时将其另存为新的类文件，并将其添加到目标Jar包中。使用Javassist，可以通过修改现有的类或创建新的类来实现动态修改Jar包中的类。需要注意的是，对于受保护的或私有的方法和字段，你需要使用相应的Javassist方法来进行访问和修改。此外，Javassist还提供了丰富的API，可以进行更复杂的类操作，如修改类的继承关系、添加接口实现等。方法获取了需要修改的类（
java高级-动态注入替换类Instrumentation
12-13 369
介绍 利用java.lang.instrument(容器类) 做动态 Instrumentation(执行容器) 是 Java SE 5 的新特性。 使用 Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至能够替换和修改某些类的定义。 这个功能为虚拟机监控提供了支撑。 基本用法 1. 编写 prema...
Java 实体类字段注解参数的动态修改
新生代码农的博客
04-17 914
注：麻烦大家关注我的公众号，会每日更新，面试题笔试题都会更新，麻烦大家多多关注。
Java反射机制：动态访问和修改类属性
最新发布
weixin_41329415的博客
09-02 111
Java反射机制：动态访问和修改类属性 大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ Java的反射机制是一种强大的工具，它允许程序在运行时访问和修改类的属性和方法。通过反射，我们可以在不直接引用类的情况下，动态地创建对象、调用方法、修改字段等。本文将深入探讨Java反射机制的工作原理...
java 热更新class_【JRebel 作者出品--译文】Java class 热更新：关于对象，类，类加载器...
weixin_30546201的博客
02-13 571
一篇大神的译文，勉强(嗯。。相当勉强)地放在类加载器系列吧，第8弹：一、前言手里是锤子，看哪里都是钉子。最近学习类加载器的感觉就是如此，总是在想，利用它可以做到什么？ 可以做到类隔离、不停服务执行动态调试代码，但是，还能做什么呢？毕竟，Tomcat 出到现在了，也不支持更新某一个class 而不重启应用(这里重启应用的意思是，不是重启 Tomcat，而是重新部署 webapp)，而热部署同样也是一...
进程程序替换（自主实现shell）
weixin_34314962的博客
06-17 167
进程替换 　　替换进程所运行的程序 　　流程：将另一段代码加载到内存中，通过页表将原来进程的映射关系重新建立到新的程序在内存中的地址，相当于替换了进程所运行程序以及所要处理的数据 　　　　　　（替换了代码段，重新初始化数据段） 　　目的：让程序执行其他任务 　　如何替换：exec函数家族 　　　　execl　　execlp　　execle　　execv　　execvp (这五个为库函...
使用Java ProcessBuilder执行DOS命令：删除文件
`ProcessBuilder`类就是Java提供的一种方式，允许我们构建和启动一个新的进程，从而执行这些命令。`ProcessBuilder`不仅支持单个命令，还可以处理复杂的命令行参数和环境变量设置。 ### 使用`ProcessBuilder`执行...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值