1
public abstract class ClassLoader {
2

3
    /*
4
     * 类加载器的父加载器
5
     */
6
    private final ClassLoader parent;
7

8
    /**
9
     * 根据类的全限定名加载类
10
     *
11
     * @param name 类名称
12
     * @return     加载的Class对象
13
     * @throws ClassNotFoundException 没有发现指定类异常
14
     */
15
    public Class<?> loadClass(String name) throws ClassNotFoundException {
16
        // 调用loadClass方法加载类，其中设置resolve=false，表示不立即解析类
17
        return loadClass(name, false);
18
    }
19

20
    /**
21
     * 根据类的全限定名加载类
22
     *
23
     * @param name    类名称
24
     * @param resolve 是否解析这个类，true=解析，false=不解析
25
     * @return 加载的Class对象
26
     * @throws ClassNotFoundException 没有发现指定类异常
27
     */
28
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
29
        synchronized (getClassLoadingLock(name)) {
30
            // 检查类是否已经被加载
31
            Class<?> c = findLoadedClass(name);
32
            // 如果没有加载过
33
            if (c == null) {
34
                // 如果有父类加载器，则委托给父加载器去加载
35
                // 如果没有父类加载器，则判断 Bootstrap 类加载器是否加载过
36
                if (parent != null) {
37
                    c = parent.loadClass(name, false);
38
                } else {
39
                    c = findBootstrapClassOrNull(name);
40
                }
41
                // 如果父类加载器都加载失败，则当前类加载器尝试自行加载
42
                if (c == null) {
43
                    c = findClass(name);
44
                }
45
            }
46
            // 据 resolve 参数决定是否解析类
47
            if (resolve) {
48
                resolveClass(c);
49
            }
50
            return c;
51
        }
52
    }
53

54
    /**
55
     * 查找并加载指定名称的类
56
     *
57
     * @param name 类名称
58
     * @return Class对象
59
     * @throws ClassNotFoundException 没有发现指定类异常
60
     */
61
    protected Class<?> findClass(String name) throws ClassNotFoundException {
62
        //1. 根据传入的类名，到在特定目录下去寻找类文件，把字节码文件读入内存
63
        // ...
64
        //2. 调用 defineClass 将字节数组转成 Class 对象
65
        return defineClass(buf, off, len)；
66
    }
67

68
    /**
69
     * 将一个 byte[] 转换为 Class 类的实例
70
     *
71
     * @param name 类名称，如果不知道此名称，则该参数为 null
72
     * @param b    组成类数据的字节数组
73
     * @param off  类数据的起始偏移量
74
     * @param len  类数据的长度
75
     * @return Class对象
76
     * @throws ClassFormatError 类格式化异常
77
     */
78
    protected final Class<?> defineClass(byte[] b, int off, int len) throws ClassFormatError {
79
        ...
80
    }
81

82
}

1
import java.io.ByteArrayOutputStream;
2
import java.io.File;
3
import java.io.FileInputStream;
4
import java.io.IOException;
5
import java.io.InputStream;
6

7
public class FileSystemClassLoader extends ClassLoader {
8

9
    private String rootDir;
10

11
    public FileSystemClassLoader(String rootDir) {
12
        this.rootDir = rootDir;
13
    }
14

15
    /**
16
     * 获取类的字节码
17
     *
18
     * 注: 重写 findClass() 方法
19
     */
20
    @Override
21
    protected Class<?> findClass(String name) throws ClassNotFoundException {
22
        // 实现一些自定义功能
23
        System.out.println("实现一些自定义功能...");
24
        // 获取类的字节数组
25
        byte[] classData = getClassData(name);
26
        if (classData == null) {
27
            throw new ClassNotFoundException();
28
        } else {
29
            return defineClass(name, classData, 0, classData.length);
30
        }
31
    }
32

33
    private byte[] getClassData(String className) {
34
        // 读取字节码文件
35
        String path = classNameToPath(className);
36
        try (InputStream ins = new FileInputStream(path)) {
37
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
38
            int bufferSize = 4096;
39
            byte[] buffer = new byte[bufferSize];
40
            int bytesNumRead = 0;
41
            while ((bytesNumRead = ins.read(buffer)) != -1) {
42
                baos.write(buffer, 0, bytesNumRead);
43
            }
44
            return baos.toByteArray();
45
        } catch (IOException e) {
46
            e.printStackTrace();
47
        }
48
        return new byte[0];
49
    }
50

51
    /**
52
     * 得到类文件的完全路径
53
     *
54
     * @param  className 类名称
55
     * @return 类文件的完全路径
56
     */
57
    private String classNameToPath(String className) {
58
        return rootDir + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
59
    }
60

61
}

1
public class Sample {
2

3
    private Sample instance;
4

5
    public void setSample(Object instance) {
6
        System.out.println("开始初始化对象: " + instance.toString());
7
        this.instance = (Sample) instance;
8
    }
9

10
}

1
import java.lang.reflect.Method;
2

3
public class ClassIdentity {
4

5
    public void testClassIdentity() {
6
        // 指定加载字节码的目录
7
        String classDataRootPath = "D:\\";
8
        // 使用自定义类加载器进行加载
9
        FileSystemClassLoader fscl = new FileSystemClassLoader(classDataRootPath);
10
        // 指定字节码包名(如果编译时的类没有指定包，则直接输入类名Sample)
11
        String className = "mydlq.club.Sample";
12
        try {
13
            // 加载 Sample 类，使用反射创建 Sample 对象
14
            Class<?> class1 = fscl.loadClass(className);
15
            Object obj1 = class1.getDeclaredConstructor().newInstance();
16
            // 使用反射调用方法 setSample(Object instance) 方法
17
            Method sampleMethod = class1.getMethod("setSample", java.lang.Object.class);
18
            sampleMethod.invoke(obj1, obj1);
19
        } catch (Exception e) {
20
            e.printStackTrace();
21
        }
22
    }
23

24
    public static void main(String[] args) {
25
        new ClassIdentity().testClassIdentity();
26
    }
27

28
}