Java游戏服热更新

荣耀存于心，而非留于形。 --亚索

有时候，游戏服线上出了逻辑bug时，及因此可能导致玩家内存数据也错乱时，我们希望不停服就能修复bug或玩家数据，以避免停服维护可能造成的巨大损失，这在java中是有好些方法能够做到的。这就是常说中的热更。

这些方法的原理，其实都是利用java agent技术实现的。java agent可以理解为是JVM的一个“插件”，我们可以使用agent技术构建一个独立于应用程序的代理程序（即为Agent），用来协助监测、运行甚至替换其他JVM上的程序。通俗来说，就是可以利用它来热更。而实现java agent的功能在Java中是用Instrument实现的，位于rt.jar下的java.lang.instrument下。Instrument的最大作用，就是类定义动态改变和操作。

注：在cmd中输入java -help 就能看到java的启动选项javaagent

java agent.png

其中 agentlib 参数就用来跟要加载的 agent 的名字，如jdwp；javaagent 参数指定jvm启动时装入的java语言代理。jarpath文件中的mainfest文件必须有Premain-Class（启动前捆绑）或Agent-Class（运行时捆绑）属性。

需要注意的是，我们说的游戏服热更，通常指的一个类里的 方法体 热更，而不是指完全替换掉这个已经加载的类。我们应该知道，同一个类加载器只能加载这个类一次，再次加载时就会报错。我们利用java agent仅能在类class文件加载之前，或在运行期对已加载类做拦截，进而对字节码做变更。从而实现方法体的热更。（一个类被加载进JVM后，这个类的类信息、常量池，静态变量、域(Field)信息、方法信息等便已存在方法区了，这个类在堆中生成的对象可能正被很多地方引用着，而一个类的卸载又是时间不确定性的，因为不知GC何时才会回收，因此JVM难以做到完全替换一个类。但方法体里的逻辑，通常是放在栈中的，属于线程私有的，当它被一个对象重新调用时，通过对方法体的字节码修改，便能做到热更。这也可以看出，一个类的热更，是有诸多限制的，通过很多人已做的临床试验，如果一个类含有匿名内部类或lambda表达式，通常是不能热更的，进而导致这个类里的bug方法体也不能热更了，因此我们在写代码时一定要尽量避免写匿名内部类或lambda表达式。）（lambda表达式通常都带 -> 表示，另外有些匿名内部类在Windows的JVM中能热更，在linux上JVM却不能热更。）

1.利用JRE自带的jdwp agent
通常在远程游戏服的java的启动脚本里添上 -Xdebug -Xrunjdwp:transport=dt_socket,address=9990,server=y,suspend=n 就可以做热更。我们的eclipse热更也是这个原理。其中address=9990代表远程服务器的热更端口。然后在本地的开发工具如eclipse上，点击Debug Configurations，在里面的Remote Java Application选项中新建一个远程应用，点Browse选上对应的游戏服工程，然后填入远程服务器ip和上面启动项里的address端口，就可以连接远程游戏服修改方法体进行热更了，注意这个方法里的新逻辑，必须在重新被调用后才能生效。并且修改完后，需注意点击disconnect远程连接，即关闭远程连接，如果直接暴力叉掉，可能导致不能再次连上远程游戏服了。这在游戏服较少时可以这么做，如果游戏服较多，一个个连上去改那就麻烦死了。

远程debug游戏服.png
另附上这种方式启动脚本里的各种参数意义：
java agentlib各参数意义.png

2.利用Java agent 在启动时加载 instrument agent
Java SE 5时，java虚拟机提供了一套”代理”程序机制，可以支持第三方工具程序以代理的方式连接和访问 JVM，并利用 JVMTI （Java Virtual Machine Tool Interface）提供的丰富的编程接口，完成很多跟 JVM 相关的功能，比如类定义动态改变和操作。但在 Java SE 5 中，这种类定义动态改变和操作机制，Instrument 要求在运行前利用命令行参数或者系统参数来设置代理类，并编写一个Java类，在里面实现premain方法。
即在游戏服的启动参数里，需用
-javaagent:D:\Repositories\hotswap-agent\1.0\hotswap-agent-1.0.jar
指定代理的jar包，在这个jar包里实现premain(String agentArgs, Instrumentation inst)方法，并在这个premain方法里，实现我们的热更。当游戏服的main方法启动前，JVM会先进入这个代理包下的premain方法，因为它只在启动时进入，如果在游戏服长时间运行后，发现一个逻辑bug需要热更，这便需要一种方法能一直延续premain方法的“寿命”，使之在游戏服运行过程中，如有热更需要，便在此方法中执行。
因此，我们可以这样设计，在premain方法中，另开一个线程（或单线程池），这个线程每隔比如1s扫描某个文件夹，当文件夹中放入class文件时，便加载重定义这个class类，这个class文件，即我们的游戏逻辑bug类。
因此，我们的启动参数可添加如下：

-javaagent:D:\Repositories\hotswap-agent\1.0\hotswap-agent-1.0.jar="classPath=D:\svn-workspace\xykp-server\target\classes,interval=1000,logLevel=ALL"

实现premain的方法类：

public class HotSwapAgent {
    private static final Logger log = Logger.getLogger(HotSwapAgent.class.getName());
    private final Instrumentation instrumentation;
    private final String classPath;
    private int interval;
    private Level logLevel;

    public static void premain(String agentArgs, Instrumentation inst) {
        init(agentArgs, inst);
    }

    private static void init(String agentArgs, Instrumentation inst) {
        initArgs();//从上述的启动参数里，解析出classPath，interval，logLevel
        new HotSwapAgent(inst);
    }

    public HotSwapAgent(Instrumentation inst) {
        this.instrumentation = inst;
        log.setUseParentHandlers(false);
        log.setLevel(logLevel);
        ConsoleHandler consoleHandler = new ConsoleHandler();
        consoleHandler.setLevel(logLevel);
        log.addHandler(consoleHandler);
        HotSwapMonitor monitor = new HotSwapMonitor(this.instrumentation, this.classPath, this.interval);
        monitor.start();
        log.info("class path: " + this.classPath);
        log.info("scan interval (ms): " + this.interval);
        log.info("log level: " + this.logLevel);
    }
}

HotSwapMonitor的实现为：

public class HotSwapMonitor implements Runnable {
    private String classPath;
    private Instrumentation instrumentation;
    ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
    private int interval;
    private static final Logger logger = Logger.getLogger(HotSwapMonitor.class.getName());

    public HotSwapMonitor(Instrumentation instrumentation, String classPath, int interval) {
        this.instrumentation = instrumentation;
        this.classPath = classPath;
        this.interval = interval;
    }

    public void start() {
        this.executor.scheduleAtFixedRate(this, 0L, (long) this.interval, TimeUnit.MILLISECONDS);
    }

    public void run() {
        try {
            this.scanClassFile();
        } catch (Exception e) {
            logger.log(Level.SEVERE, "error", e);
        }

    }

    public void scanClassFile() throws Exception {
        File path = new File(this.classPath);
        File[] files = path.listFiles();
        if (files != null) {
            String classFilePath = null;
            boolean success = false;
            long now = System.currentTimeMillis();
            File[] bakFiles = files;
            int fileNum = files.length;

            for (int i = 0; i < fileNum; ++i) {
                File file = bakFiles[i];
                if (this.isClassFile(file)) {
                    classFilePath = file.getPath();
                    this.reloadClass(classFilePath);
                    logger.fine(String.format("Reload %s success", classFilePath));
                    file.delete();
                    success = true;
                }
            }

            if (success) {
                logger.fine(String.format("Reload success, cost time:%sms", System.currentTimeMillis() - now));
            }

        }
    }

    private void reloadClass(String classFilePath) throws Exception {
        File file = new File(classFilePath);
        byte[] buff = new byte[(int) file.length()];//将class文件的二进制码读入
        DataInputStream in = new DataInputStream(new FileInputStream(file));
        in.readFully(buff);
        in.close();
        HotSwapClassLoader loader = new HotSwapClassLoader();//定义一个类加载器
        Class<?> updateCalss = loader.findClass(buff);//找到该类
        ClassDefinition definition = new ClassDefinition(Class.forName(updateCalss.getName()), buff);
        this.instrumentation.redefineClasses(new ClassDefinition[]{definition});
    }

    private boolean isClassFile(File file) {
        return file.getName().contains(".class");
    }
}

在这里，定义了一个单线程池，每隔1000ms扫描启动参数里D:\svn-workspace\xykp-server\target\classes该文件夹（注意在linux下，即游戏服部署路径中的class文件夹），如果有热更的class文件，最终调用instrumentation.redefineClasses(new ClassDefinition[]{definition});实现类重定义。

我们知道由于类加载器的作用域，父加载器是看不到子加载器中的类的，而子加载器是能看到父加载器中类的，同级别的自定义类加载器是相互不可见的。在游戏服中，游戏逻辑类应该都是应用加载器（或系统加载器）加载的，在reloadClass(String classFilePath)方法中，我们定义了一个HotSwapClassLoader();那在这里如何让HotSwapClassLoader对应用加载器可见呢？

public class HotSwapClassLoader extends ClassLoader {
    public HotSwapClassLoader() {
        super(Thread.currentThread().getContextClassLoader());
    }

    public Class<?> findClass(byte[] b) throws ClassNotFoundException {
        return this.defineClass((String) null, b, 0, b.length);//利用父类ClassLoader中defineClass方法找到（重定义）此类
    }
}

在这里，只要用线程的上下文加载器记录游戏服启动时的加载器就可以了，此时的线程上下文加载器记录的是根加载器，即null，因为instrument位于rt.jar下，再用它打破类加载的双亲委派模型，最终由应用加载器再加载这个类。

3.利用Java agent 在运行时加载 instrument agent
上述方法中，有个前提，那就是必须在启动参数里添加代理热更包，但是有些游戏公司可能不知道此方法的，或者忘了在启动里添加此参数，这时又不想停服希望能热更的，Java SE 6便提供了此方法：在JVM启动后，仍可以引入代理类，实现热更。但在它的代理类中，需实现agentmain(String agentArgs, Instrumentation inst)方法。
这种热更的实现，主要是采用JVM的attach机制实现的，如下：

VirtualMachine vm = VirtualMachine.attach(pid); 
vm.loadAgent(agentPath, agentArgs); 

它的原理是利用进程间通信来做的，即在游戏服进程外，另起一个进程，即我们的热更进程，通过attach机制发送信号给游戏服，从而让游戏服加载热更代理包，实现热更。

因此，我们还要写个程序，去给游戏服发信号：

public class AgentMainTest {
    public static void main(String[] args){
        List<VirtualMachineDescriptor> listAfter = null;
        try {
            listAfter = VirtualMachine.list();
            for (VirtualMachineDescriptor vmd : listAfter) { //取出物理机上的所有游戏服
                System.out.println( "displayName:" + vmd.displayName());
                System.out.println( "toString:" + vmd.toString());
                if (!vmd.displayName().contains("xykp.gameserver")) { //游戏服进程标记
                    continue;
                }
                
                VirtualMachine vm = VirtualMachine.attach(vmd);
                vm.loadAgent("D:\\Repositories\\hotswap-agent\\1.0\\hotswap-agent-1.0.jar", "classPath=D:\\svn-workspace\\xykp\\target\\classes,interval=1000,logLevel=FINE");//热更包，及参数
                vm.detach();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}

然后在游戏服执行此程序，遍历该物理机上的所有游戏服，发信号通知它们加载热更代理包，然后进入代理包中的agentmain方法，实现热更。

    public static void premain(String agentArgs, Instrumentation inst) {
        init(agentArgs, inst);
    }

    public static void agentmain(String agentArgs, Instrumentation inst) {
        init(agentArgs, inst);
    }

此后，如果想方便后续的热更，所有热更逻辑与2中方法一样。

在2和3方法中，我们都提到了一个代理热更包hotswap-agent-1.0.jar，这个包即是将2中的HotSwapAgent、HotSwapMonitor、HotSwapClassLoader类打成hotswap-agent-1.0.jar包的，包名可随意取，打包方法根据是否maven项目或其他类型项目而不同，但是还有一个重要文件也要打进去，那就是MANNIFEST.MF文件，它相当于一个配置文件，用于指引Instrument采用何种方式热更。

Manifest-Version: 1.0
Ant-Version: Apache Ant 1.9.6
Created-By: 1.8.0_131-b11 (Oracle Corporation)
Agent-Class: xykp.HotSwapAgent
Premain-Class: xykp.HotSwapAgent
Can-Redefine-Classes: true

此外，这两种方式，不仅能热更已加载的类，还能加载新的类，因为新的类是第一次加载，那么我们在新类中就可以做很多事情了。

比如2和3方法中，通常只能热更方法体，其实我们还可以加入private static 方法的，而public static或其他非static方法是不能添加的，删除方法也只限于private static方法，但是如果我们引入新类，在新类中，我们是可以添加任何方法的。

public class HeroHandler2 {
    public static final int a = 55;
    public Map<Integer, Integer> map = new ConcurrentHashMap<Integer, Integer>();
    
    static{
        System.out.println("HeroHandler2 loaded~~~~~~~~~~~~~~~, a: " + a);
        
        RoleRepository repository = SpringProxy.getBean(RoleRepository.class);
        Role role = repository.get(1001L);
        role.setNick("Steven");
        repository.save(role);
    }
    
    public void add(){
        System.out.println("HeroHandler2 add() called~~~~~~~~~~~~~~~~~");
    }
    
    private static void add2(){
        System.out.println("HeroHandler2 add2() called~~~~~~~~~~~~~~~~~");
    }
    
    public static void add3(){
        System.out.println("HeroHandler2 add3() called~~~~~~~~~~~~~~~~~");
    }
}

在游戏服的其他逻辑里，我们就可以调用这个新类的方法了，以此换种方式调用非static方法及增加其它Field域：

    @HandlerMethod
    public void toggle(PlayerSession<Long> session, HeroToggleLockReq_1241026 req) {
        heroService.toggleHeroLock(session.getIdentity(), req.getHeroId());
        HeroHandler2 handler2 = new HeroHandler2();
        handler2.add();
        HeroHandler2.add3();
    }

另外，当这个类第一次加载时，是会执行static代码块里的代码的，在这个static代码中，我们甚至可以添加修复玩家内存数据逻辑，此为修复玩家内存数据的一种方式。另一种方式可以用groovy修改，将在后续博文介绍。

但是，需要注意的一点是，第2第3种方式新增新类时，新类的class文件虽然放到指定的扫描目录下了，但是它在项目结构的源目录中，还必须存在一份class文件，否则加载时会报classNotFoundException错误，因此如何把新类的class文件放到源目录下成为能否新增新类的关键。有的线上项目是打成jar包的，这种热更 新增 新类的方式可能不能实现，因为需要把这个class文件放入已打成jar包的相应目录下，而这个jar包又是放在远程linux服务器上且运行着的。有的项目不是打成jar包的才能这么做，从而增加新类。通常我们热更只需热更方法体足矣，这样便能修复线上大部分bug。

还有，线上项目的日志系统通常都是用log4j或slf4j的，而第2种方式是在main函数前启动的，此时日志系统都还没加载，因此这个热更包采用了JDK自带的java.util.logging日志系统，但是这样logging打印的日志就不会出现在log4j日志文件中了，导致文件是否加载成功只能通过class文件是否被删除来判断（在该篇文章的代码逻辑中），为什么没有热更成功，却无从得知了，因此我们需要一种方式使logging打印的日志也被记录下来或打印在log4j或slf4j日志文件中，从而方便我们查看为什么没有热更成功。可以这样加个新类：

public class LoggerPrint {
    private static FileHandler fileHandler;
    
    static{
        try {
            String path = LoggerPrint.class.getProtectionDomain().getCodeSource().getLocation().getPath();
            File file = new File(path);
            fileHandler = new FileHandler(file.getParentFile().getParentFile().getPath()+"/hotswap.log");//日志文件名及存放路径，如果路径中包含文件夹，要确保文件夹存在，否则会导致游戏启动不起来
            fileHandler.setFormatter(new SimpleFormatter());//logging默认为xml格式的日志，不方便查阅，因此用我们常见的日志格式输出
        } catch (SecurityException | IOException e) {
            e.printStackTrace();
        } 
    }
    
    public static FileHandler getFileHandler() { 
        return fileHandler;
    }
}

在HotSwapAgent或HotSwapMonitor中，只需添加一个静态代码块即可打印日志了：

    static{
        FileHandler fileHandler = LoggerPrint.getFileHandler();
        logger.addHandler(fileHandler);
    }

至于第2第3种方式更多原理及调用流程问题，请参考阿里大神李嘉鹏的博文，墙裂推荐：
JVM 源码分析之 javaagent 原理完全解读
JVM Attach机制实现

在这文章中，指出了热更的限制条件：

对比新老类，并要求如下：
父类是同一个
实现的接口数也要相同，并且是相同的接口
类访问符必须一致
字段数和字段名要一致
新增的方法必须是 private static/final 的
可以删除修改方法