JVM笔记-类加载机制

public class SuperClass {
    static {
        System.out.println("SuperClass init!");
    }

    public static int value = 123;
    public static final String HELLO_WORLD = "hello, world";
}

public class SubClass extends SuperClass {
    static {
        System.out.println("SubClass init!");
    }
}

/**
 * 通过子类引用父类的静态字段，不会导致子类初始化
 */
public class NotInitialization {
    public static void main(String[] args) {
        System.out.println(SubClass.value);
    }
}

/* 类加载情况：SubClass 和 SuperClass 均被加载
 * 
 * 输出结果（父类初始化，子类未初始化）：
 * SupClass init!
 * 123
 */

/**
 * 通过数组定义来引用类，不会触发此类的初始化
 */
public class NotInitialization {
    public static void main(String[] args) {
        SuperClass[] superClasses = new SuperClass[10];
    }
}

/* 类加载情况：SuperClass 被加载
 * 输出结果为空，SuperClass 未初始化 
 */

/**
 * 常量在【编译阶段】会存入调用类（NotInitialization）的常量池中，
 * 本质上并没有直接引用到定义常量的类，因此不会触发其初始化
 */
public class NotInitialization {
    public static void main(String[] args) {
        System.out.println(SuperClass.HELLO_WORLD);
    }
}

/* 类加载情况：SubClass 和 SuperClass 均未被加载
 *
 * 输出结果：
 * hello, world
 */

-Xverify:none

// 经过「准备」阶段后，该初始值为 0
// 而把 value 赋值为 123 是在后面的「初始化」阶段
public static int value = 123;

public static final int value = 123;

public class A {
}

public class B {
  private A a;
}

public class BeanFactory {
  private BeanFactory() {
  }

  public BeanFactory getBeanFactory() {
    return BeanFactoryHolder.beanFactory;
  }

  /**
   * 使用内部嵌套类实现单例，利用 JVM 的类加载机制可保证线程安全
   */
  private static class BeanFactoryHolder {
    private static BeanFactory beanFactory = new BeanFactory();
  }
}

private final ClassLoader parent;

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // 先检查请求的类是否已加载过
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            try {
                // 若未加载过，调用父类加载器进行加载（父类加载器也会继续该过程）
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    // 使用启动类加载器加载
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父类加载器无法完成加载
            }
            
            // 父类加载器未完成加载时，使用自身的 findClass 方法尝试加载
            if (c == null) {
                c = findClass(name);
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

// JDK 1.2 提供的
protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

package java.lang;

public class Object {
  public String toString() {
    return "hello";
  }

  public static void main(String[] args) {
    System.out.println("hello");
  }
}

Error: Main method not found in class java.lang.Object, please define the main method as:
   public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

[Loaded java.lang.Object from /Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.io.Serializable from /Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Comparable from /Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/jre/lib/rt.jar]
...

package java.lang;

public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("hello");
  }
}

Error: A JNI error has occurred, please check your installation and try again
Exception in thread "main" java.lang.SecurityException: Prohibited package name: java.lang
  at java.lang.ClassLoader.preDefineClass(ClassLoader.java:662)
  at java.lang.ClassLoader.defineClass(ClassLoader.java:761)
  at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
  at java.net.URLClassLoader.defineClass(URLClassLoader.java:468)
  at java.net.URLClassLoader.access$100(URLClassLoader.java:74)
  ...

public class MyClassLoader extends ClassLoader {

  // 重写 findClass 方法
  @Override
  protected Class<?> findClass(String name) throws ClassNotFoundException {
    byte[] classData = loadClassData(name);
    if (classData == null) {
      throw new ClassNotFoundException();
    }
    return defineClass(name, classData, 0, classData.length);
  }

  // 读取 class 文件
  private byte[] loadClassData(String className) {
    String fileName = "~/Code/Java/test/target/classes" +
        File.separatorChar + className.replace('.', File.separatorChar) + ".class";
    try {
      FileInputStream inputStream = new FileInputStream(fileName);
      ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
      byte[] buffer = new byte[1024];
      int length;
      while ((length = inputStream.read(buffer)) != -1) {
        outputStream.write(buffer, 0, length);
      }
      return outputStream.toByteArray();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return null;
  }
}

package loader;

public class Person {
  static {
    // 当 Person 类初始化时，会打印该代码
    System.out.println("Person init!");
  }

  private String name;

  public String getName() {
    return name;
  }

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

private static void test1() throws Exception {
  // 创建类加载器实例
  MyClassLoader myClassLoader1 = new MyClassLoader();
  // 加载 Person 类（注意这里是 loadClass 方法）
  Class<?> aClass1 = myClassLoader1.loadClass("loader.Person");
  aClass1.newInstance(); // Person init!

  MyClassLoader myClassLoader2 = new MyClassLoader();
  Class<?> aClass2 = myClassLoader2.loadClass("loader.Person");
  aClass2.newInstance();
    
  System.out.println("--->" + aClass1.getClassLoader()); // sun.misc.Launcher$AppClassLoader@18b4aac2
  System.out.println("--->" + aClass2.getClassLoader()); // sun.misc.Launcher$AppClassLoader@18b4aac2
  System.out.println("--->" + aClass1.equals(aClass2)); // true
}

private static void test2() throws Exception {
  MyClassLoader cl1 = new MyClassLoader();
  // 加载自定义的 Person 类
  Class<?> aClass1 = cl1.findClass("loader.Person");
  // 实例化 Person 对象
  aClass1.newInstance(); // Person init!

  MyClassLoader cl2 = new MyClassLoader();
  Class<?> aClass2 = cl2.findClass("loader.Person");
  aClass2.newInstance(); // Person init!

  System.out.println("--->" + aClass1); // class loader.Person
  System.out.println("--->" + aClass2); // class loader.Person

  System.out.println("--->" + aClass1.getClassLoader()); // loader.MyClassLoader@60e53b93
  System.out.println("--->" + aClass2.getClassLoader()); // loader.MyClassLoader@1d44bcfa  
  
  System.out.println("--->" + aClass1.equals(aClass2)); // false
}

private static void test3() throws Exception {
  MyClassLoader cl1 = new MyClassLoader();
  Class<?> aClass1 = cl1.findClass("loader.Person");
  aClass1.newInstance();

  // 这里改用上面的类加载进行加载呢？
  Class<?> aClass2 = cl1.findClass("loader.Person");
  aClass2.newInstance();

  System.out.println("--->" + aClass1);
  System.out.println("--->" + aClass2);
  System.out.println("--->" + aClass1.equals(aClass2)); // true ??
}

Exception in thread "main" java.lang.LinkageError: loader (instance of  loader/MyClassLoader): attempted  duplicate class definition for name: "loader/Person"
  at java.lang.ClassLoader.defineClass1(Native Method)
  at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
  at java.lang.ClassLoader.defineClass(ClassLoader.java:642)
  at loader.MyClassLoader.findClass(MyClassLoader.java:21)
  at loader.TestClassLoader.test1(TestClassLoader.java:61)
  at loader.TestClassLoader.main(TestClassLoader.java:10)