java高分局之类热加载

java高分局之类热加载

有时候我们会遇到热加载的需求，即在修改了类的代码后，不重启的情况下动态的加载这个类。

先介绍一个java的类加载器 之前写过一篇关于类加载器的，请访问此地址：

http://blog.csdn.net/maosijunzi/article/details/42555617

看到这个问题，我想到有两种方式来实现：（能力有限，不知道还有没有其他的方案）

1：把原来的类信息卸载掉，然后重新加载此类。

2：新建一个类加载器（new），重新加载此类，不管原来的类信息，等待垃圾回收它。

第一种方案是行不通的，因为java并没有给我们提供手动卸载类信息的功能，也就是运行时方法区内的类信息是不能卸载的，

除非这个类已经不再使用，这时GC会自动把它回收掉。所以我们只能通过第二种方案来实现。

几个问题

在使用这种方案实现之前我们考虑几个问题，注意：下面的问题是在这种方案下提出的，也在这种方案下回答，不适用与其他方案。

1：是不是所有的类都能进行热加载呢？

我们程序的入口类都是系统类加载器加载的，也就是AppClassLoader加载的。当你重新使用系统类加载器加载这个类的时候

是不会被重新加载的。因为虚拟机会检测这个类是否被加载过，如果已经被加载过，那么就不会重新加载。所以由系统类加载器加载的

类，是不能进行热加载的。只有使用我们自定义的类加载器加载的类才能热加载。

2：自定义类加载器的父加载器应该是哪个加载器？

我们自定义类加载器的父加载器有两种选择，一个是系统类加载器（AppClassLoader），另一种是扩展类加载器（ExtClassLoader）。

首先我们要知道，扩展类加载器是系统类加载器的父加载器。

我们先考虑第一种，如果父加载器是系统类加载器（当然如果你不指定父加载器，默认就是系统类加载器），那么会出现一个现象，这个动态

加载的类不能出现在系统类加载器的classpath下。因为如果在系统类加载器的classpath下的话，当你用自定义类加载器去加载的时候，会先

使用父类加载器去加载这个类，如果父类加载器可以加载这个类就直接加载了，达不到热加载的目的。所以我们必须把要热加载的类从classpath

下删除。

在考虑第二种，如果父加载器是扩展类加载器，这时候热加载的类就可以出现在classpath下，但又会出现另一种现象，这个类中不能引用由系统

类加载器加载的类。因为这时候，自定义类加载器和系统类加载器是兄弟关系，他们两个加载器加载的类是互不可见的。这个问题貌似是致命的。

除非热加载的类中只引用了扩展类加载器加载的类（大部分javax开头的类）。

所以我们自定义的类加载器的父加载器最好是系统类加载器。

3：热加载的类要不要实现接口？

要不要实现接口，要根据由系统类加载器加载的类A中是否有热加载类B的引用。如果有B的引用，那么加载A的时候，系统类加载器就会去加载B，这时候B

不在classpath下，就会加载报错。这时候我们就需要为B定义一个接口，A类中只有接口的引用。这样我们使用系统类加载器加载接口，使用自定义

类加载器加载B类，这样我们就可以热加载B类。

如果A中没有B的引用的话，就灵活多了，可以实现接口，也可以不实现接口，都可以进行热加载。

解决了这三个问题后，实现代码就已经在我们心中了。下面直接看代码：
包结构如下：

源码：

package com.load.custom;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;

public class MyClassLoader extends ClassLoader {
    private String classpath;

    public MyClassLoader(String classpath){
        super(ClassLoader.getSystemClassLoader());
        this.classpath = classpath;
    }

    @Override
    public Class<?> findClass(String name) {
        System.out.println("加载类==="+name);
        byte[] data = loadClassData(name);
        return this.defineClass(name, data, 0, data.length);
    }

    public byte[] loadClassData(String name) {
        try {
            name = name.replace(".", "//");
            FileInputStream is = new FileInputStream(new File(classpath + name + ".class"));
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int b = 0;
            while ((b = is.read()) != -1) {
                baos.write(b);
            }
            is.close();
            return baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

package com.load.manager;

/**
 * @author chuer
 * @Description: 此类的子类需要动态更新
 * @date 2015年5月13日 上午11:09:24 
 * @version V1.0
 */
public interface BaseManager {
    public void logic();
}

package com.load;

import com.load.custom.MyClassLoader;
import com.load.manager.BaseManager;

public class LoadInfo {

    private MyClassLoader myLoader;
    private long loadTime;
    private BaseManager manager;

    public LoadInfo(MyClassLoader myLoader,long loadTime){
        this.myLoader = myLoader;
        this.loadTime = loadTime;
    }
    public MyClassLoader getMyLoader() {
        return myLoader;
    }
    public void setMyLoader(MyClassLoader myLoader) {
        this.myLoader = myLoader;
    }
    public long getLoadTime() {
        return loadTime;
    }
    public void setLoadTime(long loadTime) {
        this.loadTime = loadTime;
    }
    public BaseManager getManager() {
        return manager;
    }
    public void setManager(BaseManager manager) {
        this.manager = manager;
    }



}

package com.load;

public class Logic {
    public void logic(){
        System.out.println("logic");
    }

}

package com.load;
import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

import com.load.custom.MyClassLoader;
import com.load.manager.BaseManager;

public class ManagerFactory {

    /**
     *记录热加载类的加载信息 
     */
    private static final Map<String,LoadInfo> loadTimeMap = new HashMap<>();

    public static final String CLASS_PATH = "D:/";

    public static final String MY_MANAGER = "com.load.manager.MyManager";


    public static BaseManager getManager(String className){
        File loadFile = new File(CLASS_PATH+className.replaceAll("\\.","/")+".class");
        long lastModified = loadFile.lastModified();

        //查看是否被家再过 ,如果没有被家再过则加载
        if(loadTimeMap.get(className) == null){
            load(className,lastModified);
        }else if(loadTimeMap.get(className).getLoadTime() != lastModified){//如果被加载过，查看加载时间，如果该类已经被修改，则重新加载
                load(className,lastModified);
        }

        return loadTimeMap.get(className).getManager();
    }


    private static void load(String className,long lastModified){

        MyClassLoader myLoader = new MyClassLoader(CLASS_PATH);
        Class<?> loadClass = null;
        try {
            loadClass = myLoader.loadClass(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        BaseManager manager = newInstance(loadClass);
        LoadInfo loadInfo2 = new LoadInfo(myLoader,lastModified);
        loadInfo2.setManager(manager);
        loadTimeMap.put(className, loadInfo2);
    }


    private static BaseManager newInstance(Class<?> cls){
        try {
            return (BaseManager)cls.getConstructor(new Class[]{}).newInstance(new Object[]{});
        } catch (InstantiationException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException
                | NoSuchMethodException | SecurityException e) {
            e.printStackTrace();
        }
        return null;
    }
}

package com.load;

import com.load.manager.BaseManager;

public class MsgHandler implements Runnable{



    @Override
    public void run() {

        while(true){
            BaseManager manager = ManagerFactory.getManager(ManagerFactory.MY_MANAGER);
            manager.logic();

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new MsgHandler()).start();

//      File loadFile = new File("D:/"+ManagerFactory.MY_MANAGER.replaceAll(".","/")+".class");
//      long lastModified = loadFile.lastModified();
//      System.out.println("com.load.manager.MyManager".replaceAll("\\.","/"));
    }

}

运行后，修改MyManager类后输出如下：

加载类===com.load.manager.MyManager
bbb
logic
bbb
logic
bbb
logic
bbb
logic
bbb
logic
加载类===com.load.manager.MyManager
aaaaaaaaaaaaaaaaaaaa
logic
aaaaaaaaaaaaaaaaaaaa
logic
aaaaaaaaaaaaaaaaaaaa
logic
aaaaaaaaaaaaaaaaaaaa
logic

可见，修改后重新加载了MyManager。到此热加载成功。

还有另一种方案可以进行类的热加载,
http://blog.csdn.net/maosijunzi/article/details/45918477