java 中 热部署与卸载关系

今天发现早年在大象笔记中写的一篇笔记，以前放在ijavaboy上的，如今它已经访问不了了。前几天又有同事在讨论这个问题。这里拿来分享一下。

 

在web应用开发或者游戏服务器开发的过程当中，咱们时时刻刻都在使用热部署。热部署的目的很简单，就是为了节省应用开发和发布的时间。好比，咱们在使用Tomcat或者Jboss等应用服务器开发应用时，咱们常常会开启热部署功能。热部署，简单点来讲，就是咱们将打包好的应用直接替换掉原有的应用，不用关闭或者重启服务器，一切就是这么简单。那么，热部署究竟是如何实现的呢？在本文中，我将写一个实例，这个实例就是一个容器应用，容许用户发布本身的应用，同时支持热部署。

 

在Java中，要实现热部署，首先，你得明白，Java中类的加载方式。每个应用程序的类都会被ClassLoader加载，因此，要实现一个支持热部署的应用，咱们能够对每个用户自定义的应用程序使用一个单独的ClassLoader进行加载。而后，当某个用户自定义的应用程序发生变化的时候，咱们首先销毁原来的应用，而后使用一个新的ClassLoader来加载改变以后的应用。而全部其余的应用程序不会受到一点干扰。先看一下，该应用的设计图：

 

 

 

有了整体实现思路以后，咱们能够想到以下几个须要完成的目标：

 

一、定义一个用户自定义应用程序的接口，这是由于，咱们须要在容器应用中去加载用户自定义的应用程序。

二、咱们还须要一个配置文件，让用户去配置他们的应用程序。

三、应用启动的时候，加载全部已有的用户自定义应用程序。

四、为了支持热部署，咱们须要一个监听器，来监听应用发布目录中每一个文件的变更。这样，当某个应用从新部署以后，咱们就能够获得通知，进而进行热部署处理。

 

实现部分：

 

首先，咱们定义一个接口，每个用户自定义的程序中都必须包含惟一一个实现了该接口的类。代码以下：

public interface IApplication {

        public void init();

        public void execute();

        public void destory();

}

在这个例子中，每个用户自定义的应用程序，都必须首先打包成一个jar文件，而后发布到一个指定的目录，按照指定的格式，而后首次发布的时候，还须要将应用的配置添加到配置文件中。因此，首先，咱们须要定义一个能够加载指定目录jar文件的类：

 public ClassLoader createClassLoader(ClassLoader parentClassLoader, String... folders) {

       List<URL> jarsToLoad = new ArrayList<URL>();
        for (String folder : folders) {
              List<String> jarPaths = scanJarFiles(folder);

               for (String jar : jarPaths) {

                     try {
                           File file = new File(jar);
                           jarsToLoad.add(file.toURI().toURL());

                    } catch (MalformedURLException e) {
                           e.printStackTrace();
                    }
              }
       }

       URL[] urls = new URL[jarsToLoad.size()];
       jarsToLoad.toArray(urls);

        return new URLClassLoader(urls, parentClassLoader);
}

 

这个方法很简单，就是从多个目录中扫描jar文件，而后返回一个新的URLClassLoader实例。至于scanJarFiles方法，你能够随后下载本文的源码。而后，咱们须要定义一个配置文件，用户须要将他们自定义的应用程序信息配置在这里，这样，该容器应用随后就根据这个配置文件来加载全部的应用程序：

<apps>
        <app>
               <name> TestApplication1</name >
               <file> com.ijavaboy.app.TestApplication1</file >
        </app>
        <app>
               <name> TestApplication2</name >
               <file> com.ijavaboy.app.TestApplication2</file >
        </app>
</apps>

这个配置是XML格式的，每个app标签就表示一个应用程序，每个应用程序，须要配置名称和那个实现了IApplication接口的类的完整路径和名称。

有了这个配置文件，咱们须要对其进行解析，在这个例子中，我使用的是xstream，很简单，你能够下载源码，而后看看就知道了。这里略过。这里须要提一下：每一个应用的名称(name),是相当重要的，由于该例子中，咱们的发布目录是整个项目发布目录下的applications目录，这是全部用户自定义应用程序发布的目录。而用户发布一个应用程序，须要首先在该目录下新建一个和这里配置的name同样名称的文件夹，而后将打包好的应用发布到该文件夹中。(你必须这样作，不然在这个例子中，你会发布失败)。

好了，如今加载jar的方法和配置都有了，下面将是整个例子的核心部分，对，就是应用程序管理类，这个类就是要完成对每个用户自定义应用程序的管理和维护。首先要作的，就是如何加载一个应用程序：

 

public void createApplication(String basePath, AppConfig config){
      String folderName = basePath + GlobalSetting. JAR_FOLDER + config.getName();
      ClassLoader loader = this.jarLoader .createClassLoader(ApplicationManager. class.getClassLoader(), folderName);

       try {
             Class<?> appClass = loader. loadClass(config.getFile());

             IApplication app = (IApplication)appClass.newInstance();

             app.init();

              this.apps .put(config.getName(), app);

      } catch (ClassNotFoundException e) {
             e.printStackTrace();
      } catch (InstantiationException e) {
             e.printStackTrace();
      } catch (IllegalAccessException e) {
             e.printStackTrace();
      }

能够看到，这个方法接收两个参数，一个是基本路径，一个是应用程序配置。基本路径其实就是项目发布目录的地址，而AppConfig其实就是配置文件中app标签的一个实体映射，这个方法从指定的配置目录中加载指定的类，而后调用该应用的init方法，完成用户自定义应用程序的初始化。最后将，该加载的应用放入内存中。

如今，全部的准备工做，都已经完成了。接下来，在整个应用程序启动的时候，咱们须要加载全部的用户自定义应用程序，因此，咱们在ApplicationManager中添加一个方法：

 

 public void loadAllApplications(String basePath){

        for(AppConfig config : this.configManager.getConfigs()){
               this.createApplication(basePath, config);
       }
}

这个方法，就是将用户配置的全部应用程序加载到该容器应用中来。好了，如今咱们是否是须要写两个独立的应用程序试试效果了，要写这个应用程序，首先咱们新建一个java应用程序，而后引用这个例子项目，或者将该例子项目打包成一个jar文件，而后引用到这个独立的应用中来，由于这个独立的应用程序中，必需要包含一个实现了IApplication接口的类。咱们来看看这个例子包含的一个独立应用的样子：

public class TestApplication1 implements IApplication{

        @Override
        public void init() {
              System. out.println("TestApplication1-->init" );
       }

        @Override
        public void execute() {
              System. out.println("TestApplication1-->do something" );
       }

        @Override
        public void destory() {
              System. out.println("TestApplication1-->destoryed" );
       }

}

 

是否是很简单？对，就是这么简单。你能够照这个样子，再写一个独立应用。接下来，你还须要在applications.xml中进行配置，很简单，就是在apps标签中增长以下代码：

<app>
       <name> TestApplication1</name >
       <file> com.ijavaboy.app.TestApplication1</file >
</app>

 

接下来，进入到本文的核心部分了，接下来咱们的任务，就所有集中在热部署上了，其实，也许如今你还以为热部署很神秘，可是，我相信一分钟以后，你就不会这么想了。要实现热部署，咱们以前说过，须要一个监听器，来监听发布目录applications,这样当某个应用程序的jar文件改变时，咱们能够进行热部署处理。其实，要实现目录文件改变的监听，有不少种方法，这个例子中我使用的是apache的一个开源虚拟文件系统——common-vfs。若是你对其感兴趣，你能够访问 http://commons.apache.org/proper/commons-vfs/。这里，咱们继承其FileListener接口，实现fileChanged 便可：

 

public void fileChanged (FileChangeEvent event) throws Exception {

      String ext = event.getFile().getName().getExtension();
       if(!"jar" .equalsIgnoreCase(ext)){
              return;
      }

      String name = event.getFile().getName().getParent().getBaseName();

      ApplicationManager. getInstance().reloadApplication(name);

当某个文件改变的时候，该方法会被回调。因此，咱们在这个方法中调用了ApplicationManager的reloadApplication方法，重现加载该应用程序。

 

public void reloadApplication (String name){
      IApplication oldApp = this.apps .remove(name);

       if(oldApp == null){
              return;
      }

      oldApp.destory();     //call the destroy method in the user's application

      AppConfig config = this.configManager .getConfig(name);
       if(config == null){
              return;
      }

      createApplication(getBasePath(), config);

重现加载应用程序时，咱们首先从内存中删除该应用程序，而后调用原来应用程序的destory方法，最后按照配置从新建立该应用程序实例。

到这里，你还以为热部署很玄妙很高深吗？一切就是如此简单。好了，言归正传，为了让咱们自定义的监听接口能够有效工做起来，咱们还须要指定它要监听的目录：

 

 public void initMonitorForChange(String basePath){
        try {
               this.fileManager = VFS.getManager();

              File file = new File(basePath + GlobalSetting.JAR_FOLDER);
              FileObject monitoredDir = this.fileManager .resolveFile(file.getAbsolutePath());
              FileListener fileMonitorListener = new JarFileChangeListener();
               this.fileMonitor = new DefaultFileMonitor(fileMonitorListener);
               this.fileMonitor .setRecursive(true);
               this.fileMonitor .addFile(monitoredDir);
               this.fileMonitor .start();
              System. out.println("Now to listen " + monitoredDir.getName().getPath());

       } catch (FileSystemException e) {
              e.printStackTrace();
       }
}

这里，就是初始化监听器的地方，咱们使用VFS的DefaultFileMonitor完成监听。而监听的目录，就是应用发布目录applications。接下来，为了让整个应用程序能够持续的运行而不会结束，咱们修改下启动方法：

 public static void main(String[] args){

       Thread t = new Thread(new Runnable() {

               @Override
               public void run() {
                    ApplicationManager manager = ApplicationManager.getInstance();
                    manager.init();
              }
       });

       t.start();

        while(true ){
               try {
                    Thread. sleep(300);
              } catch (InterruptedException e) {
                    e.printStackTrace();
              }
       }
}

好了，到这里，一切都要结束了。如今，你已经很明白热部署是怎么一回事了，对吗？不明白？OK，还有最后一招，去看看源码吧！

 

源码我已经放到了GitHub上面了，地址： https://github.com/chenjie19891104/ijavaboy/tree/master/AppLoader，欢迎下载使用，你拥有一切的权利对其进行修改。

 

最后，若是本文有什么地方说的不许确，欢迎指正，谢谢！