深入浅出 JVM 之类加载-类加载器

 1public 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}

 1import java.io.ByteArrayOutputStream;  
 2import java.io.File;  
 3import java.io.FileInputStream;  
 4import java.io.IOException;  
 5import java.io.InputStream;  
 6  
 7public 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}  

 1public 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}

 1import java.lang.reflect.Method;  
 2  
 3public 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}

1实现一些自定义功能...
2开始初始化对象: mydlq.club.Sample@b684286