Java 类机制（2）---- 类加载过程

public class Main {
    
    public static void main(String[] args) {
        System.out.println("This is a simple class!");
    }
}

private static int value1 = 3;

private static final int value1 = 3;

public class InvokeOrder {
    static int v = 1;

    static {
        System.out.println(Thread.currentThread() + ": InvokeOrder cinit invoke: v = " + v);
    }

    int vv = 2;

    {
        System.out.println(Thread.currentThread() + ": InvokeOrder init invoke: vv = " + vv);
    }

    InvokeOrder() {
        System.out.println(Thread.currentThread() + ": InvokeOrder constructor invoke");
    }

    static class SubClass extends InvokeOrder {
        static int x = 3;

        static {
            System.out.println(Thread.currentThread() + ": SubClass: cinit invoke: x = " + x);
        }

        int xx = 4;

        {
            System.out.println(Thread.currentThread() + ": SubClass init invoke: xx = " + xx);
        }

        SubClass() {
            System.out.println(Thread.currentThread() + ": SubClass constructor invoke");
        }
    }

    public static void main(String[] args) {
        SubClass subClass = new SubClass();
    }
}

/**
 * A class loader is an object that is responsible for loading classes. The
 * class <tt>ClassLoader</tt> is an abstract class.  Given the <a
 * href="#name">binary name</a> of a class, a class loader should attempt to
 * locate or generate data that constitutes a definition for the class.  A
 * typical strategy is to transform the name into a file name and then read a
 * "class file" of that name from a file system.
 *
 * <p> Every {@link Class <tt>Class</tt>} object contains a {@link
 * Class#getClassLoader() reference} to the <tt>ClassLoader</tt> that defined
 * it.
 */

public abstract class ClassLoader {
    // ...
    
    /* 当前 ClassLoader 的父 ClassLoader */
    private final ClassLoader parent;
    
    /**
     * 构造方法，通过 parent 参数指定该类加载器的父类加载器
     */
    protected ClassLoader(ClassLoader parent) {
        this(checkCreateClassLoader(), parent);
    }
    
    /**
     * 默认的构造方法，采用 AppClassLoader 作为父类加载器，下文会介绍 AppClassLoader
     */
    protected ClassLoader() {
        this(checkCreateClassLoader(), getSystemClassLoader());
    }
    
    /**
     * 这个方法为类加载原理的核心方法，name 参数代表要加载的类名，
     * resolve 参数代表是否需要对加载得到的类进行链接操作
     *（链接操作即为我们上面提到的类加载的 验证、准备和解析过程），
     * 链接过程是否执行是可以通过参数来控制的，但是当我们在使用一个类时，这个类一定已经完成了整个类加载的步骤。
     * 如果这个方法成功加载对应的类，则返回对应的 Class 对象，否则抛出对应异常
     */
    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            // 先确认该类是否已经被当前类加载器加载过
            Class<?> c = findLoadedClass(name);
            // 如果得到的 Class 对象为空，证明该类还未被当前类加载器加载过，开始进行委托操作
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    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
                }
                // 如果得到的 Class 对象还是为空，则证明父类加载器和启动类加载器都不能加载该类，
                // 此时需要调用 findClass(String name) 方法来自己进行加载
                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
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            // 如果需要对得到的 Class 对象进行链接，则调用 resolveClass(Class c) 方法进行类链接操作
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

    /**
     * 查找类名为 name 的类，返回对应的 Class 对象，这个方法是子类要重写的方法，
     * 在这个方法中加入自定义加载类的逻辑
     *
     * @since  1.2
     */
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }

    /**
     * 将参数 b 储存的数据的 [offset, offset + len - 1] 部分转换为一个 Class 对象,
     * 如果数据不符合规定的类数据规范，则抛出 ClassFormatError 异常，这个方法已经被
     * defineClass(String, byte[], int, int) 方法替代
     */
    @Deprecated
    protected final Class<?> defineClass(byte[] b, int off, int len)
        throws ClassFormatError
    {
        return defineClass(null, b, off, len, null);
    }
    
    /**
     * 将参数 b 储存的数据的 [offset, offset + len - 1] 部分转换为一个 Class 对象,
     * 如果数据不符合规定的类数据规范，则抛出 ClassFormatError 异常。
     * 最终会经过一系列的验证（比如 name 能以 java. 开头），如果验证不通过，抛出对应异常，
     * 最后调用 native 的方法来进行真正的类定义（创建对应的 Class 对象）
     */
    protected final Class<?> defineClass(String name, byte[] b, int off, int len)
        throws ClassFormatError
    {
        return defineClass(name, b, off, len, null);
    }
}

protected Class<?> findClass(String name) throws ClassNotFoundException {
    // ... 通过某种方式得到类的二进制数据（以 byte[] 类型储存）
    byte[] classData = getClassData(...);
    return defineClass(classData, ...);
}

public class ClassLoaderTest {

    public static void main(String[] args) {
        System.out.println(System.getProperty("sun.boot.class.path"));
        System.out.println(System.getProperty("java.ext.dirs"));
        System.out.println(System.getProperty("java.class.path"));
    }
}

public class ClassLoaderTest {

    /**
     * 自定义的 ClassLoader，加载指定路径下的类
     */
    static class CustomClassLoader extends ClassLoader {
        private static final String TO_LOAD_CLASS_NAME = "A";
        // 默认加载的类所在文件夹路径
        private static final String DEFAULT_CLASS_DIR = "D:/ProjectData/JavaProjects/IDEAProject/Test/out/production/Test/";

        private String classDir;
        
        CustomClassLoader(String classDir) {
            super();
            if (classDir == null) {
                throw new IllegalArgumentException("argument is illegal!");
            }
            this.classDir = classDir;
        }
        
        @Override
        public Class<?> loadClass(String name) throws ClassNotFoundException {
            // 如果要加载的类名为 A，则不遵循双亲委派模型，强行加载。
            if (name.equals(TO_LOAD_CLASS_NAME)) {
                return findClass(TO_LOAD_CLASS_NAME);
            }
            // 否则遵循双亲委派模型
            return super.loadClass(name);
        }

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            // 先加载类字节数据，再调用 defineClass 方法生成 Class 对象
            byte[] classData = loadClassData(name);
            if (classData != null) {
                return defineClass(name, classData, 0, classData.length);
            }
            return null;
        }

        /**
         * 读取类 class 文件的数据，以字节数组返回
         *
         * @param className
         * @return
         */
        private byte[] loadClassData(String className) {
            String classPath = classDir + className.replace('.', '/') + ".class";
            System.out.println(classPath);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(classPath);
                byte[] bs = new byte[1024];
                int readCount;
                while ((readCount = fis.read(bs)) != -1) {
                    bos.write(bs, 0, readCount);
                }
            } catch (IOException e) {
                e.printStackTrace();
                return null;
            } finally {
            	try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
            return bos.toByteArray();
        }
    }

    public static void main(String[] args) {
        CustomClassLoader classLoader1 = new CustomClassLoader(CustomClassLoader.DEFAULT_CLASS_DIR);
        CustomClassLoader classLoader2 = new CustomClassLoader(CustomClassLoader.DEFAULT_CLASS_DIR);
        try {
            Class c1 = classLoader1.loadClass(CustomClassLoader.TO_LOAD_CLASS_NAME);
            Class c2 = classLoader2.loadClass(CustomClassLoader.TO_LOAD_CLASS_NAME);
            System.out.println("c1, c2, c1 == c2: " + c1 + ", " + c2.toString() + ", " + (c1 == c2));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

public class A {
}

static void printClassLoader(Class c) {
    if (c != null) {
        ClassLoader classLoader = c.getClassLoader();
        while (classLoader != null) {
            System.out.println(classLoader);
            classLoader = classLoader.getParent();
        }
    }
}

printClassLoader(c1);

/* This class loader is used to load classes and resources from a search
 * path of URLs referring to both JAR files and directories. Any URL that
 * ends with a '/' is assumed to refer to a directory. Otherwise, the URL
 * is assumed to refer to a JAR file which will be opened as needed.
 * ...
 */
public class URLClassLoader extends SecureClassLoader implements Closeable {
    // ...

    public URLClassLoader(URL[] urls, ClassLoader parent) {
        super(parent);
        // this is to make the stack depth consistent with 1.1
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkCreateClassLoader();
        }
        ucp = new URLClassPath(urls);
        this.acc = AccessController.getContext();
    }

    public URLClassLoader(URL[] urls) {
        super();
        // this is to make the stack depth consistent with 1.1
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkCreateClassLoader();
        }
        ucp = new URLClassPath(urls);
        this.acc = AccessController.getContext();
    }

public class CustomURLClassLoader extends URLClassLoader {

        public CustomURLClassLoader(URL[] urls) {
            super(urls);
        }
    	
    	public static void main(String[] args) {
        String classPath = "file://D:/ProjectData/JavaProjects/IDEAProject/Test/out/production/Test/";
        try {
            CustomURLClassLoader customURLClassLoader = new CustomURLClassLoader(new URL[]{new URL(classPath)});
            Class c = customURLClassLoader.loadClass("A");
            System.out.println("loaded class: " + c);
        } catch (MalformedURLException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

String classPath = "https://raw.githubusercontent.com/StarkZhidian/JavaComponentProject/master/";

ClassLoader loaders = int[].class.getClassLoader();
System.out.println(loaders);
loaders = int[][].class.getClassLoader();
System.out.println(loaders);
// 使用了上面自定义的 CustomURLClassLoader 类
loaders = CustomURLClassLoader[].class.getClassLoader();
System.out.println(loaders);

public class ClassLoaderTest {
    public static void main(String[] args) {
        // 引用某个类定义的常量
        System.out.println(ParentClass.W);
        // 定义某个类的数组
        ParentClass[] parentClasses = new ParentClass[1];
    }

	static class ParentClass {
        static final int W = 2;
        static int x = 1;
         static {
            System.out.println("ParentClass: I'm be loading!");
        }
    }

    static class ChildrenClass extends ParentClass {
        static {
            System.out.println("ChildrenClass: I'm be loading!");
        }
    }
}

public static void main(String[] args) {
    // 引用某个类定义的常量
    System.out.println(ParentClass.W);
    // 定义某个类的数组
    ParentClass[] parentClasses = new ParentClass[1];
    // 通过子类访问父类的静态变量
    System.out.println(ChildrenClass.x);
}