文章/答案/技术大牛

发布

社区首页 >专栏 >Java热更新

Java热更新

原创

jemuelmiao

发布于 2019-12-02 16:04:56

1.8K00

代码可运行

文章被收录于专栏：SunSun

运行总次数：0

代码可运行

1. 背景

最近参与开发一个java项目，每次修改调试时就需要重启进程，由于工程较大，进程初始化任务较多，重启较慢，严重影响了开发效率，因此花了点时间研究java热更新机制，在项目中引入热更新后，每次的修改可以立即看到结果，提高了开发效率。

本文会先简单介绍热更新需要使用到的技术：代理、动态字节码修改，然后分别讨论开源热更新工具SpringLoaded和商用热更新工具Jrebel的使用，最后总结下自己破解最新版Jrebel的方式。

2. JavaAgent

JavaAgent是java程序代理，可以在程序启动或运行时插入自定义代码执行指定操作，根据代理时机分为启动时代理和运行时代理，经常被用于字节码修正。

2.1 启动时代理

该特性是在JDK1.5之后引入，在启动程序时通过javaagent参数指定代理类，代理类需要实现静态函数premain，该函数会在main函数前执行，premain函数有两种定义方式：

public static void premain(String args, Instrumentation inst);
public static void premain(String args);

JVM首先尝试调用前者，如果没有实现，则尝试调用后者。

启动代理简单实现如下：

启动类

package com.tencent;
public class App {
    public static void main( String[] args ) {
        System.out.println("main");
    }
}

代理类

package com.tencent;
public class Agent {
    public static void premain(String args, Instrumentation inst) {
        System.out.println("premain");
    }
}

配置manifest

在代理类所在jar包的manifest中指定代理类，Premain-Class: com.tencent.Agent。如果项目是通过maven构建，可配置maven-jar-plugin插件参数，如下：

<configuration>
   <archive>
      <manifestEntries>
         <Premain-Class>com.tencent.Agent</Premain-Class>
      </manifestEntries>
   </archive>
</configuration>

运行

java -javaagent:agent-1.0-SNAPSHOT.jar -cp ./* com.tencent.App

2.2 运行时代理

该特性是在JDK1.6之后引入，在程序启动后通过加载代理类并运行静态函数agentmain执行代码，agentmain函数有两种定义方式：

public static void agentmain(String args, Instrumentation inst);
public static void agentmain(String args);

JVM首先尝试调用前者，如果没有实现，则尝试调用后者。

运行时代理简单实现

加载代理类

import com.sun.tools.attach.VirtualMachine;
public class Server {
    public static void main( String[] args ) {
       String pid = 目标进程pid;
       VirtualMachine vm = VirtualMachine.attach(pid);
       vm.loadAgent("path/to/agent jar");
       vm.detach();
    }
}

代理类

public class Agent {
    public static void agentmain(String args, Instrumentation inst) {
        System.out.println("agentmain");
    }
}

一般情况，会启动两个进程，一个是目标进程，用于运行代理类，一个是加载进程，用于等待指令加载代理类。

配置manifest

配置与启动代理类似，Premain-Class改为Agent-Class。

3. Instrument

Instrument技术可以实时修改字节码，使得在不改变原程序的基础上，增加监控等辅助功能，甚至可以修改原程序的类定义等。目前Java字节码生成框架主要有：ASM、Javassist、Byte Buddy。以下使用Javassist实现简单耗时统计。

启动类

package com.tencent;
public class App {
   public static void main( String[] args ) {
       try {
          App app = new App();
          app.fun();
          Thread.sleep(500);
       } catch (Exception e) {
          System.out.println(e);
       }        
   }
   public static void fun() {
       Thread.sleep(1000);
   }
}

代理类

package com.tencent;
public class Agent {
    public static void premain(String args, Instrumentation inst) {
        inst.addTransformer(new TimeTransformer());
    }
}

字节码修改类

public class TimeTransformer implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader,
                            String className,
                            Class<?> classBeingRedefined,
                            ProtectionDomain protectionDomain,
                            byte[] classfileBuffer)
        throws IllegalClassFormatException {
        if (!className.replace("/", ".").equals("com.tencent.App")) {
            return null;
        }
        try {
            ClassPool classPool = ClassPool.getDefault();
            CtClass ctClass = classPool.get("com.tencent.App");
            CtMethod[] methods = ctClass.getDeclaredMethods();
            for (CtMethod orgMethod : methods) {
                String orgMethodName = orgMethod.getName();
                String newMethodName = orgMethodName + "New";
                orgMethod.setName(newMethodName);
                CtMethod newMethod = CtNewMethod.copy(orgMethod, orgMethodName, ctClass, null);
                StringBuilder body = new StringBuilder();
                body.append("{\n");
                body.append("long startTime = System.currentTimeMillis();\n");
                body.append(newMethodName + "($$);\n");
                body.append("long endTime = System.currentTimeMillis();\n");
                body.append("System.out.println(\"[" + orgMethodName + "]:\" + " + "(endTime-startTime) + " + "\"ms\");\n");
                body.append("}\n");
                newMethod.setBody(body.toString());
                ctClass.addMethod(newMethod);
            }
            return ctClass.toBytecode();
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        return null;
    }
}

TimeTransformer实现在com.tencent.App类中使用原方法名生成新方法，在新方法中调用原方法，并在调用前后加上时间统计，以此计算函数耗时。

配置manifest

需要配置Can-Retransform-Classes: true

运行

需要加入javassist依赖包。

4. Java热更新

目前Java热更新主要有三种方式：

定义不同的ClassLoader，当监听到文件变化后，通过新的ClassLoader加载新文件，已有对象的状态需要更新，如果有类的相关依赖还需要手动设置。
通过instrument技术修改字节码，代理class的加载过程。典型的有SpringLoaded、Jrebel框架。
修改JVM支持Class动态加载。

方式1实现简单，但当项目复杂时，需要手动维护的状态更新较多。方式2一般以代理参数形式接入应用，对原应用无需做任何修改，下面介绍的SpringLoaded和Jrebel均采用这种方式进行热更新。方式3并非官方提供，通用性值得考虑。

5. SpringLoaded

Springloaded是一款开源的java热更新工具，可以直接监测jar包变化，能够实时增删改方法、属性。

5.1 简单使用

启动类

public class App {
    public static void main( String[] args ) {
        Hot hot = new Hot();
        while (true) {
            hot.run();
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
            }
        }
    }
}

业务类

//修改前
public class Hot {
    public void run() {
        System.out.println("run");
    }
}

//修改后
public class Hot {
    public void run() {
        System.out.println("run");
        extra();
    }
    public void extra() {
        System.out.println("extra");
    }
}

此处我将启动类、业务类分别编译为app-1.0-SNAPSHOT.jar、utils-1.0-SNAPSHOT.jar，后者包含经常需要改动的逻辑，修改后重新打包，替换原jar包可看到实时变化。

5.2 运行

java -javaagent:/path/to/springloaded-1.2.9.jar -noverify -cp ./* -Dspringloaded=watchJars=utils-1.0-SNAPSHOT.jar com.tencent.App

参数说明：

javaagent：指定springloaded的jar包所在路径。

watchJars：需要监听变化的jar包，监听多个jar使用:进行分隔。

创建demo使用SpringLoaded时可以正常使用，但我在项目中加入SpringLoaded时，会有很多报错，看日志是很多type无法注册，使用的是最新版1.2.6，因此实际未选择该开源工具。

6. Jrebel

Jrebel是一款商用的热更新工具，收费标准是每年550刀，通过监听指定目录中class文件的变化进行热更新，能够实时增删改方法、属性。

6.1 Jrebel热更新原理

原理说明：

定义一个类C如下：

public class C extends X {
	int y = 5;
	int method1(int x) {
		return x + y;
	}
}

初始启动程序时，jrebel通过instrument技术修改类定义，在方法调用中插入代理层，代理层将请求路由到具体实现上，路由规则为始终选择当前系统中最新版本的实现，插入代理如下：

public class C extends X {
	int y = 5;
	int method1(int x) {
		Object[] o = new Object[1];
		o[0] = x;
		return Runtime.redirect(this, o, "C", "method1", "(I)I");
	}
}

程序启动加载的类C的初始实现版本如下：

public abstract class C0 {
	public static int method1(C c, int x) {
		int tmp1 = Runtime.getFieldValue(c, "C", "y", "I");
		return x + tmp1;
	}
}

当类C的定义修改为如下：

public class C {
	int y = 5;
	int z() {
		return 10;
	}
	int method1(int x) {
		return x + y + z();
	}
	...
}

下次系统使用类C时，jrebel检测到类定义发生变化，会重新加载类的实现版本，如下：

public class C1 {
	public static int z(C c) {
		return 10;
	}
	public static int method1(C c, int x) {
		int tmp1 = Runtime.getFieldValue(c, "C", "y", "I");
		int tmp2 = Runtime.redirect(c, null, "C", "z", "(V)I");
		return x + tmp1 + tmp2;
	}
	...
}

由于代理规则始终选择最新版本的实现进行路由，因此会执行新逻辑。

6.2 Jrebel使用

下载jrebel

下载地址：https://jrebel.com/software/jrebel/download/prev-releases/，本文采用最新版2019.1.1。

注册jrebel

注册地址：https://jrebel.com/software/jrebel/trial/，注册后会获得license key，该license免费试用10天。

激活jrebel

解压jrebel，运行activate-gui.cmd或activate-gui.sh，选择Activation code，输入license key，激活后当前用户目录下会生成.jrebel文件夹，文件夹下包含许可证jrebel.lic，配置文件jrebel.prefs。

启动

java -Drebel.dirs=/path/to/classes/dir -Drebel.log=true -agentpath:/path/to/jrebel/lib/libjrebel64.so -noverify -cp ...

参数说明：

rebel.dirs：jrebel监听的class文件目录，初始时将要监听的jar包解压到此目录，需要修改时，将修改后的jar包覆盖解压到此目录。

agentpath：指定官网下载的jrebel压缩包中的liejrebel64.so路径，热更时需要用到压缩包中的其他文件，如jrebel.jar，需要保持该压缩包的完整性。

6.3 Jrebel破解

我在项目开发中加入Jrebel试用下来还是很不错，大部分情况下都可以热更新，在开发中确实可以节省不少时间，但每年550刀的收费标准还是略高了，于是我花了一点时间大概研究了一下jrebel关于license的反编译代码，总结了下最新版（2019.1.1）破解方式如下。

Jrebel的jar包是经过jar的混淆技术处理过的，反编译后很难重新编译成功，因此如果需要更改jar包的话只能直接修改class文件的字节码，然后重新打包。

Jrebel试用版许可证控制流程：

当使用试用版许可证时，默认使用期限为10天，使用日期相关配置会存储在jrebel.prefs中，程序运行时会根据jrebel.prefs中配置来判断许可证的有效性，在保证许可证不变的情况下，最简单的破解办法是定期删除jrebel.prefs并重建。当然此文并没有采用这种方式，而是通过修改字节码破解。

6.3.1 签名校验破解

许可证对应的数据结构定义在com/zeroturnaround/licensing/UserLicense.class中，主要包含两部分：注册信息和签名，其中注册信息我们可以通过反序列化查看，大概信息如下（具体含义可自行研究）：

{lastName=miao, GeneratedBy=AUTO, Email=741785694@qq.com, Organization=tc, enterprise=true, Product=JRebel, GeneratedOn=Tue Apr 23 14:39:17 CST 2019, validFrom=Tue Apr 23 14:39:17 CST 2019, OrderId=, limitedFrom=Tue Apr 23 14:39:17 CST 2019, version=1.27, Name=jemuel miao, Seats=1, uid=543971cc72a8e62a983010e17564daaec6ca2e26, firstName=jemuel, Type=evaluation, validUntil=Wed Apr 22 14:39:17 CST 2020, override=false, limitedUntil=Wed Apr 22 14:39:17 CST 2020, validDays=10}

因为没有加密秘钥，所以签名没法伪造，只能通过改代码直接绕过签名校验。签名校验入口在com/zeroturnaround/oc.class中，如下：

public class oc {
    ...
    public static boolean a(eca var0, UserLicense var1) {
        eed var2 = new eed(new dpw());
        var2.a(false, var0);
        var2.a(var1.getLicense(), 0, var1.getLicense().length);
        return var2.a(var1.getSignature());
    }
}

由上面反编译的代码可以看出只需要该函数返回true即可跳过签名校验，有两种方式：

修改oc.class，将逻辑改为return true，对应字节码为04 AC。
修改eed.class，将eed.class中return false全改为return true。

为了保证字节码长度不变，此处我选择修改eed.class，本文采用dirtyJOE作为字节码修改工具。

当函数名称被混淆后，可以根据函数签名进行识别，选中函数后双击进入编辑字节码界面

找到所有03 AC的地方修改为04 AC。至此，签名校验已绕过。

6.3.2 许可证日期破解

许可证日期设置入口在com/zeroturnaround/kl.class中，读取日期存在两种情况：不存在jrebel.prefs配置文件和存在jrebel.prefs配置文件。

不存在jrebel.prefs配置文件

private static Object[] a() {
        try {
            HashMap var0 = new HashMap();
            GregorianCalendar var1 = new GregorianCalendar();
            Date var2 = (Date)var1.getTime().clone();
            Date var3 = (Date)var1.getTime().clone();
            var1.add(6, 10);
            Date var4 = (Date)var1.getTime().clone();
            MessageDigest var5 = MessageDigest.getInstance("SHA-1");
            var5.update(a((Serializable)var2));
            byte[] var6 = var5.digest();
            var0.put("start-date", var2);
            var0.put("digest", var6);
            byte[] var7 = a((Serializable)var0);
            return new Object[]{abt.a(var7), var3, var4};
        } catch (NoSuchAlgorithmException var8) {
            throw new RuntimeException("Problem initializing JRebel diff file", var8);
        }
    }

存在jrebel.prefs配置文件

private static Object[] a(String var0) {
        try {
            byte[] var1 = abt.a(var0);
            ObjectInputStream var2 = new ObjectInputStream(new ByteArrayInputStream(var1));
            Map var3 = (Map)var2.readObject();
            Date var4 = (Date)var3.get("start-date");
            byte[] var5 = (byte[])var3.get("digest");
            MessageDigest var6 = MessageDigest.getInstance("SHA-1");
            var6.update(a((Serializable)var4));
            byte[] var7 = var6.digest();
            GregorianCalendar var8 = new GregorianCalendar();
            var8.setTime(var4);
            Date var9 = (Date)var8.getTime().clone();
            var8.add(10, 240);
            Date var10 = (Date)var8.getTime().clone();
            return new Object[]{MessageDigest.isEqual(var5, var7), var9, var10};
        } catch (NoSuchAlgorithmException var11) {
        } catch (IOException var12) {
        } catch (ClassNotFoundException var13) {
        }
        return new Object[]{Boolean.FALSE, null, null};
    }