java自定义类加载器

类加载器加载类的过程，首先调用loadClass()方法，在该方法中调用findClass()方法。最后在findClass()方法中调用defineClass()方法。

loadClass源码：

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 检查此类是否已经被加载
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                // 没被加载使用双亲委派机制找到父类加载器递归执行此方法
                long t0 = System.nanoTime();
                try {
                    // parent == null 代表当前是扩展类加载器
                    if (parent != null) { 
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }
                // 父类加载器也没加载此类 自己尝试加载，假如调用loadClass()方法
                // 的类加载器是系统类加载器，那么第一次执行到这的类加载器是其父类加载器
                // 扩展类加载器
                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

自定义类加载器的实现方式大概有两种：1、继承ClassLoader类，重写loadClass()方法，2、继承ClassLoader类、重写findClass()方法。由于loadClass()方法主要的操作是实现双亲委派机制。所以这里选择重写findClass()方法。

public class MyClassLoader extends ClassLoader {

    // 此类加载器加载的路径
    private String root;

    public MyClassLoader(ClassLoader parent, String root) {
        super(parent);
        this.root = root;
    }

    public MyClassLoader(String root) {
        this.root = root;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {

        // IO流读取字节码文件为二进制流
        try (BufferedInputStream bis = new BufferedInputStream((new FileInputStream(root + name + ".class")));
             ByteArrayOutputStream bos = new ByteArrayOutputStream()) {

            int len;
            byte[] bytes = new byte[1024];
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);
            }
            bos.flush();
            bytes = bos.toByteArray();
            return defineClass(null,bytes,0,bytes.length);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

待加载类

public class Person {

    private int age;

    private String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

使用javac将其编译为class文件存到d盘

测试：

public static void main(String[] args) throws Exception {
        // class文件存放路径
        MyClassLoader classLoader = new MyClassLoader("d:/");
        // class文件名
        Class<?> person = classLoader.loadClass("Person");
        System.out.println(person.getDeclaredConstructor(int.class,String.class).
                newInstance(21,"张三"));
}

结果：
Person{age=21, name='张三'}

自定义类加载器的用途，实现热部署：

修改测试代码并启动

while (true) {
            MyClassLoader classLoader = new MyClassLoader("d:/");
            Class<?> person = classLoader.loadClass("Person");
            System.out.println(person.getDeclaredConstructor(int.class,String.class).
                    newInstance(21,"张三"));
            Thread.sleep(5000);
        }

修改Person类中的toString()方法，重新编译，将编译好的class文件放到d盘替换原class文件

@Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}' + "\n====测试热部署=====";
    }

程序输出结果：

Person{age=21, name='张三'}
Person{age=21, name='张三'}
Person{age=21, name='张三'}
Person{age=21, name='张三'}
Person{age=21, name='张三'}
Person{age=21, name='张三'}
====测试热部署=====
Person{age=21, name='张三'}
====测试热部署=====

这样就实现了热部署