反射机制Reflection _ 3.类的加载和类加载器

JVM相关

Java内存分析

方法区是堆的一个逻辑部分，内存上属于堆但为了区分又叫非堆。

类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤对该类进行初始化。

类的加载与ClassLoader的理解

• 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。

• 链接:将ava类的二进制代码合并到JVM的运行状态之中的过程。

  • 验证:确保加载的类信息符合JVM规范没有安全方面的问题
  • 准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段,这些内存都将在方法区中进行分配。
  • 解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。

• 初始化：执行类构造器< clinit>()方法的过程。

  • 类构造器< clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的,不是构造该类对象的构造器)
  • 当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化。
  • 虚拟机会保证一个类的方法在多线程环境中被正确加锁和同步

package com.company.reflection;

public class test06 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);

        /*
        1. 加载到内存，产生一个类对应的class对象
        2. 链接，链接结束后m=0
        3. 初始化
            <clint>() {
                System.out.println("A类的静态代码块初始化");
                m = 300;
                m = 100;
            }
         */
    }
}

class A {
    static {
        System.out.println("A类的静态代码块初始化");
        m = 300;
    }

    static int m = 100;

    public A() {
        System.out.println("A类的无参构造初始化");
    }
}

什么时候会发生类初始化？

• 类的主动引用(一定会发生类的初始化)

  • 当虚拟机启动,先初始 main方法所在的类
  • 调用类的静态成员(除了final常量)和静态方法
  • 使用java.lang.reflect包的方法对应类进行反射调用
  • 当初始化一个类,如果其父类没有被初始化,则先会初始化它的父类

• 类的被动引用(不会发生类的初始化)

  • 当访问一个静态域时,只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量,不会导致子类初始化
  • 通过数组定义类引用,不会触发此类的初始化
  • 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)

package com.company.reflection;

//测试类什么时候会初始化
public class test07 {

    static {
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //主动引用
        Son son = new Son();

        //反射也会产生主动引用
        Class.forName("com.company.reflection.Son");
        
        //不会产生类的引用的方法
        System.out.println(Son.b);
        
        Son[] array = new Son[5];
        
        System.out.println(Son.M);
    }
}

class Father {

    static int b = 2;

    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father {

    static {
        System.out.println("子类被加载");
        m = 300;
    }

    static int m = 100;
    static final int M = 1;
}

类加载器的作用

• 类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中数据的访问入口。

• 类缓存：标准的Java SE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，他将维持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

类加载器

Java 中的类加载器大致可以分成两类，一类是系统提供的，另外一类则是由 Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：

• 引导类加载器(bootstrap class loader)：它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自 java.lang.ClassLoader 。
• 扩展类加载器(extensions class loader)：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。
• 系统类加载器(system class loader)：它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader() 来获取它。

除了系统提供的类加载器以外，开发人员可以通过继承 java.lang.ClassLoader 类的方式实现自己的类加载器，以满足一些特殊的需求。

双亲委派机制

当一个Hello.class这样的文件要被加载时。不考虑我们自定义类加载器，首先会在AppClassLoader(即system class loader)中检查是否加载过，如果有那就无需再加载了。如果没有，那么会拿到父加载器，然后调用父加载器的loadClass方法。父类中同理会先检查自己是否已经加载过，如果没有再往上。注意这个过程，知道到达Bootstrap classLoader之前，都是没有哪个加载器自己选择加载的。如果父加载器无法加载，会下沉到子加载器去加载，一直到最底层，如果没有任何加载器能加载，就会抛出ClassNotFoundException。

• 为什么要设计这种机制?
  这种设计有个好处是，如果有人想替换系统级别的类：String.java。篡改它的实现，但是在这种机制下这些系统的类已经被Bootstrap classLoader加载过了，所以并不会再去加载，从一定程度上防止了危险代码的植入。

package com.company.reflection;

public class test08 {
    public static void main(String[] args) throws ClassNotFoundException {

        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器--->拓展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取拓展类加载器的父类加载器--->根加载器(C/C++)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("com.company.reflection.test08").getClassLoader();
        System.out.println(classLoader);

        //测试JDK内置的类是谁加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);

        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
        /*
        D:\Java\jdk_1.8\jre\lib\charsets.jar;
        D:\Java\jdk_1.8\jre\lib\deploy.jar;
        D:\Java\jdk_1.8\jre\lib\ext\access-bridge-64.jar;
        D:\Java\jdk_1.8\jre\lib\ext\cldrdata.jar;
        D:\Java\jdk_1.8\jre\lib\ext\dnsns.jar;
        D:\Java\jdk_1.8\jre\lib\ext\jaccess.jar;
        D:\Java\jdk_1.8\jre\lib\ext\jfxrt.jar;
        D:\Java\jdk_1.8\jre\lib\ext\localedata.jar;
        D:\Java\jdk_1.8\jre\lib\ext\nashorn.jar;
        D:\Java\jdk_1.8\jre\lib\ext\sunec.jar;
        D:\Java\jdk_1.8\jre\lib\ext\sunjce_provider.jar;
        D:\Java\jdk_1.8\jre\lib\ext\sunmscapi.jar;
        D:\Java\jdk_1.8\jre\lib\ext\sunpkcs11.jar;
        D:\Java\jdk_1.8\jre\lib\ext\zipfs.jar;
        D:\Java\jdk_1.8\jre\lib\javaws.jar;
        D:\Java\jdk_1.8\jre\lib\jce.jar;
        D:\Java\jdk_1.8\jre\lib\jfr.jar;
        D:\Java\jdk_1.8\jre\lib\jfxswt.jar;
        D:\Java\jdk_1.8\jre\lib\jsse.jar;
        D:\Java\jdk_1.8\jre\lib\management-agent.jar;
        D:\Java\jdk_1.8\jre\lib\plugin.jar;
        D:\Java\jdk_1.8\jre\lib\resources.jar;
        D:\Java\jdk_1.8\jre\lib\rt.jar;
        F:\IDEA_workspace\test\out\production\test;
        D:\IntelliJ IDEA 2020.3.1\lib\idea_rt.jar
         */

    }
}