類加載和類加載器

1. 類加載過程

1.加載

1.1 何為加載

加載類的二進(jìn)制數(shù)據(jù)
類的加載指的是將類的.class文件中的二進(jìn)制數(shù)據(jù)讀到內(nèi)存中玉工，將其放在運(yùn)行時(shí)數(shù)據(jù)區(qū)的方法區(qū)內(nèi)页藻，然后在內(nèi)存中創(chuàng)建一個(gè)Class對(duì)象益楼，此Class對(duì)象用來封裝類在方法區(qū)內(nèi)的數(shù)據(jù)結(jié)構(gòu)景殷。
（jvm規(guī)范并未說明Class對(duì)象位于哪里，HosSpot將其放在方法區(qū)中）

1.2 加載的方式

從本地磁盤中加載class二進(jìn)制文件
通過網(wǎng)絡(luò)加載class二進(jìn)制文件
從zip,jar等歸檔文件中加載
從專有數(shù)據(jù)庫中提取class文件
源代碼動(dòng)態(tài)編譯為class文件

1.3 加載的注意事項(xiàng)

jvm允許類加載器在預(yù)料某個(gè)類將要被使用時(shí)就預(yù)先加載他骡湖，如果預(yù)先加載過程中遇到了class文件缺失或存在錯(cuò)誤充石，類加載器必須在程序首次主動(dòng)使用該類時(shí)才報(bào)告錯(cuò)誤莫换。
如果這個(gè)類一直沒有被程序使用，那么類加載器就不會(huì)報(bào)告錯(cuò)誤骤铃。

2.連接

1. 驗(yàn)證：確保類加載的正確性

類文件的結(jié)構(gòu)檢查
語義檢查
字節(jié)碼驗(yàn)證
二進(jìn)制兼容性驗(yàn)證

2. 準(zhǔn)備：為類的靜態(tài)變量分配內(nèi)存（也是分配默認(rèn)值的過程）

3. 解析：將類中的符號(hào)引用轉(zhuǎn)為直接引用

3.初始化

為類的靜態(tài)變量賦正確的初始值

3.1 初始化時(shí)機(jī)

所有的Java虛擬機(jī)實(shí)現(xiàn) 必須在每個(gè)類或接口被Java程序首次主動(dòng)使用時(shí) 才初始化他們

1 主動(dòng)使用

主動(dòng)使用包含七種情況

創(chuàng)建類的實(shí)例
訪問某個(gè)類或接口的靜態(tài)變量拉岁，或?qū)υ撿o態(tài)變量賦值。
調(diào)用類的靜態(tài)方法
反射
初始化一個(gè)類的子類（子類初始化父類也會(huì)初始化）
Java虛擬機(jī)啟動(dòng)時(shí)被標(biāo)明為啟動(dòng)類的類（如包含main方法）
jdk1.7開始提供的動(dòng)態(tài)語言支持

2.被動(dòng)使用

不是主動(dòng)使用的都為被動(dòng)使用

3.2初始化步驟

類沒有加載和連接惰爬，先進(jìn)行加載和連接喊暖。
類存在直接父類，并且父類沒有初始化撕瞧，那么先初始化直接父類陵叽，
類中存在初始化語句，那就依次執(zhí)行初始化語句风范。

初始化代碼示例

子父類

package jvmstu.classloader;

public class ClassLoader01 {
    public static void main(String[] args) {
        //當(dāng)打印str1時(shí)，根據(jù)主動(dòng)使用時(shí)才會(huì)初始化得沪么，Child.str1 使用的是父類的靜態(tài)變量硼婿，不會(huì)初始化子類，子類靜態(tài)代碼塊不會(huì)執(zhí)行禽车。
        //System.out.println(Child.str1);
        //當(dāng)打印str1時(shí)寇漫，根據(jù)主動(dòng)使用時(shí)才會(huì)初始化得，Child.str2 使用的是子類的靜態(tài)變量殉摔，子類初始化父類也會(huì)初始化州胳，子類和父類的靜態(tài)代碼塊都會(huì)執(zhí)行。
        System.out.println(Child.str2);
    }
}

class Papa{
    public static String str1="im Papa";
    static {
        System.out.println("Papa 初始化");
    }
}

class Child extends Papa {
    public static String str2="im Child";
    static {
        System.out.println("Child 初始化");
    }
}

常量

package jvmstu.classloader;

public class ClassLoader02 {
    public static void main(String[] args) {
        System.out.println(Papa1.str1);
    }
}

class Papa1{
    //常量在 編譯階段 會(huì)存入 調(diào)用這個(gè)常量的方法所在的類的常量池中逸月。
    //運(yùn)行時(shí)栓撞，Papa1.str1 并沒有引用到Papa1類，因此Papa1沒有初始化。
    //甚至可以將編譯好的Child1的class文件刪除瓤湘，也不會(huì)影響程序運(yùn)行瓢颅。
    public static final String str1="im Papa";
    static {
        System.out.println("Papa 初始化");
    }
}

編譯期常量和運(yùn)行期常量

package jvmstu.classloader;

import java.util.UUID;

public class ClassLoader03 {
    public static void main(String[] args) {
        System.out.println(Papa2.str1);
    }
}

class Papa2{
    //UUID.randomUUID().toString() 運(yùn)行時(shí)才會(huì)知道是什么，不是編譯器常量弛说。
    //運(yùn)行時(shí)常量在運(yùn)行時(shí)會(huì)使用類的靜態(tài)常量挽懦。
    //運(yùn)行時(shí)，Papa2.str1 引用到Papa2類木人，因此Papa2初始化信柿。
    public static final String str1= UUID.randomUUID().toString();
    static {
        System.out.println("Papa 初始化");
    }
}

創(chuàng)建類的實(shí)例 new對(duì)象

package jvmstu.classloader;

import java.util.UUID;

public class ClassLoader04 {
    public static void main(String[] args) {
        //創(chuàng)建類的實(shí)例,會(huì)首次主動(dòng)使用類。
        Papa3 papa=new Papa3();
        System.out.println("====");
        Papa3 papa2=new Papa3();
    }
}

class Papa3{
    
    public static final String str1= UUID.randomUUID().toString();
    static {
        System.out.println("Papa 初始化");
    }
}

接口的初始化

package jvmstu.classloader;


import java.util.UUID;

public class ClassLoader05 {
    public static void main(String[] args) {
        //此處刪掉編譯好的class(不管是Papa5還是Child5)并不會(huì)出錯(cuò)
        //接口在初始化時(shí)醒第，不一定要求父接口全部完成初始化
        //當(dāng)真正使用父接口時(shí)渔嚷，父接口才會(huì)初始化。
        System.out.println(Child5.str2);
    }
}

interface Papa5{
    public static  final String str1= UUID.randomUUID().toString();
}
interface Child5 extends Papa5{
    public static  String str2= "papa5 初始化";
}

初始化前準(zhǔn)備階段

package jvmstu.classloader;

public class ClassLoader06 {
    public static void main(String[] args) {
        //當(dāng)調(diào)用getInstance（靜態(tài)方法）會(huì)進(jìn)行類的初始化
        //初始化前準(zhǔn)備階段會(huì)為靜態(tài)變量分配內(nèi)存淘讥，同時(shí)賦予默認(rèn)值圃伶。
        //初始化階段，會(huì)從上到下執(zhí)行初始化賦值蒲列。
        //new 對(duì)象會(huì)調(diào)用構(gòu)造方法窒朋。
        Singleton singleton = Singleton.getInstance();
        System.out.println("con1: "+Singleton.con1);
        System.out.println("con2: "+Singleton.con2);
    }
}


class Singleton{
    public static int con1;

    //public static int con2=0;
    private static Singleton singleton=new Singleton();

    public static int con2=0;

    private Singleton(){
        con1++;
        con2++;
        System.out.println(con1);
        System.out.println(con2);
    }
    public static Singleton getInstance(){
        return singleton;
    }
}

加載方式

package jvmstu.classloader;

/**
 * classLoader.loadClass 不會(huì)初始化類
 * Class.forName 會(huì)初始化化類
 */
public class ClassLoader08 {
    public static void main(String[] args) throws ClassNotFoundException {
        ClassLoader classLoader=ClassLoader.getSystemClassLoader();
        Class<?> loadClass = classLoader.loadClass("jvmstu.classloader.Papa8");
        System.out.println(loadClass);
        System.out.println("==================");
        Class<?> aClass = Class.forName("jvmstu.classloader.Papa8");
        System.out.println(aClass);

    }
}


class Papa8{
    static int a=2;
    static {
        System.out.println("papa load init");
    }
}

2.類加載器

類加載器有三種
在虛擬機(jī)提供了3種類加載器，引導(dǎo)（Bootstrap）類加載器蝗岖、擴(kuò)展（Extension）類加載器侥猩、系統(tǒng)（System）類加載器（也稱應(yīng)用類加載器）

1.加載器類型

1.1 根加載器

啟動(dòng)（Bootstrap）類加載器
啟動(dòng)類加載器主要加載的是JVM自身需要的類，這個(gè)類加載使用C++語言實(shí)現(xiàn)的抵赢，是虛擬機(jī)自身的一部分欺劳，它負(fù)責(zé)將 <JAVA_HOME>/lib路徑下的核心類庫或-Xbootclasspath參數(shù)指定的路徑下的jar包加載到內(nèi)存中，注意必由于虛擬機(jī)是按照文件名識(shí)別加載jar包的铅鲤，如rt.jar划提，如果文件名不被虛擬機(jī)識(shí)別，即使把jar包丟到lib目錄下也是沒有作用的(出于安全考慮邢享，Bootstrap啟動(dòng)類加載器只加載包名為java鹏往、javax、sun等開頭的類)骇塘。

1.2 擴(kuò)展（Extension）類加載器

擴(kuò)展類加載器是指Sun公司(已被Oracle收購)實(shí)現(xiàn)的sun.misc.Launcher$ExtClassLoader類伊履，由Java語言實(shí)現(xiàn)的，是Launcher的靜態(tài)內(nèi)部類款违，它負(fù)責(zé)加載<JAVA_HOME>/lib/ext目錄下或者由系統(tǒng)變量-Djava.ext.dir指定位路徑中的類庫唐瀑，開發(fā)者可以直接使用標(biāo)準(zhǔn)擴(kuò)展類加載器。

1.3 系統(tǒng)（System）類加載器

也稱應(yīng)用程序加載器是指 Sun公司實(shí)現(xiàn)的sun.misc.Launcher$AppClassLoader插爹。它負(fù)責(zé)加載系統(tǒng)類路徑j(luò)ava -classpath或-D java.class.path 指定路徑下的類庫哄辣，也就是我們經(jīng)常用到的classpath路徑请梢，開發(fā)者可以直接使用系統(tǒng)類加載器，一般情況下該類加載是程序中默認(rèn)的類加載器柔滔，通過ClassLoader#getSystemClassLoader()方法可以獲取到該類加載器溢陪。

2.加載器工作模式

雙親委派模式
雙親委派模式是在Java 1.2后引入的，其工作原理的是睛廊，如果一個(gè)類加載器收到了類加載請(qǐng)求形真，它并不會(huì)自己先去加載，而是把這個(gè)請(qǐng)求委托給父類的加載器去執(zhí)行超全，如果父類加載器還存在其父類加載器咆霜，則進(jìn)一步向上委托，依次遞歸嘶朱，請(qǐng)求最終將到達(dá)頂層的啟動(dòng)類加載器蛾坯，如果父類加載器可以完成類加載任務(wù)，就成功返回疏遏，倘若父類加載器無法完成此加載任務(wù)脉课，子加載器才會(huì)嘗試自己去加載，這就是雙親委派模式财异。
雙親委派模式的好處

可以避免類的重復(fù)加載倘零，當(dāng)父親已經(jīng)加載了該類時(shí)，就沒有必要子ClassLoader再加載一次戳寸。
其次是考慮到安全因素呈驶，java核心api中定義類型不會(huì)被隨意替換，假設(shè)通過網(wǎng)絡(luò)傳遞一個(gè)名為java.lang.Integer的類疫鹊，通過雙親委托模式傳遞到啟動(dòng)類加載器袖瞻，而啟動(dòng)類加載器在核心Java API發(fā)現(xiàn)這個(gè)名字的類，發(fā)現(xiàn)該類已被加載拆吆，并不會(huì)重新加載網(wǎng)絡(luò)傳遞的過來的java.lang.Integer聋迎，而直接返回已加載過的Integer.class，這樣便可以防止核心API庫被隨意篡改枣耀。

3 自定義加載器

用戶可以編寫自定義加載器霉晕，用于個(gè)性化的加載。

3.1 如何編寫一個(gè)自定義加載器

繼承ClassLoader類
重寫findClass方法和loadClassData方法
1. findClass 調(diào)用 loadClassData 返回class
2. loadClassData奕枢，加載二進(jìn)制文件娄昆，是自定義的io操作佩微，可以在網(wǎng)絡(luò)或者各種介質(zhì)中加載缝彬。實(shí)際上如何將二進(jìn)制文件轉(zhuǎn)換為類，是由native方法哺眯，也即jvm完成的谷浅。

自定義加載器代碼示例
注意
因?yàn)轭惖碾p親委托機(jī)制，在classpath下的類都會(huì)被父加載器加載，因此還是不會(huì)調(diào)用自定義的加載器加載一疯。
將classpath下的ClassLoader01.class移動(dòng)到自定義的path下撼玄，此時(shí)父加載器不能加載ClassLoader01，自定義加載器會(huì)開始加載墩邀。

package jvmstu.classloader;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;

/**
 * 自定義加載器
 */
public class ClassLoader09 extends ClassLoader{
    private String classLoaderName;
    private String path;
    private final String fileExtension=".class";

    //構(gòu)造方法
    //系統(tǒng)類加載器作為父構(gòu)造器
    public ClassLoader09(String classLoaderName){
        super();
        this.classLoaderName=classLoaderName;
    }
    //指定父構(gòu)造器
    public ClassLoader09(ClassLoader parent,String classLoaderName){
        super(parent);
        this.classLoaderName=classLoaderName;
    }

    public void setPath(String path) {
        this.path = path;
    }

    @Override
    public String toString() {
        return "ClassLoader09{" +
                "classLoaderName='" + classLoaderName + '\'' +
                ", fileExtension='" + fileExtension + '\'' +
                '}';
    }
    //重寫findClass 方法
    protected Class<?> findClass(String className){
        byte [] data=loadClassData(className);

        return this.defineClass(className,data,0,data.length);
    }
    //實(shí)現(xiàn)loadClassData 讀取二進(jìn)制文件掌猛。
    private byte [] loadClassData(String name){
        byte [] data=null;
        InputStream inputStream=null;
        ByteArrayOutputStream baos=null;

        try{
            String replace = name.replace(".", "/");
            System.out.println(replace);
            inputStream=new FileInputStream(path+replace+this.fileExtension);

            baos=new ByteArrayOutputStream();

            int ch=0;
            while(-1!=(ch=inputStream.read())){
                baos.write(ch);
            }
            data=baos.toByteArray();

        }catch (Exception ex){
            ex.printStackTrace();
        }finally {
            try{
                inputStream.close();
                baos.close();
            }catch (Exception ex){
                ex.printStackTrace();
            }
        }
        return data;
    }

    public static void main(String[] args) throws Exception {
        ClassLoader09 loader = new ClassLoader09("loader");
        loader.setPath("C:/Users/13166/Desktop/test/");
        Class<?> aClass = loader.loadClass("jvmstu.classloader.ClassLoader01");
        Object o = aClass.newInstance();
        System.out.println(o.getClass().getClassLoader());
    }
}

4.自定義系統(tǒng)類加載器

jvm允許將自定義的類加載器定義為系統(tǒng)（System）類加載器，只需添加jvm參數(shù)眉睹。（查看源碼可見邏輯）

5.線程上下文類加載器

雙親委托模型下荔茬，類數(shù)據(jù)是由下到上加載的，對(duì)于spi(服務(wù)提供接口)竹海，java的核心庫是由啟動(dòng)類加載器加載的慕蔚，而這些接口的實(shí)現(xiàn)是由廠商實(shí)現(xiàn)的，由系統(tǒng)加載器加載斋配。這樣雙親加載模型就無法滿足spi要求孔飒。
因此線程上下文類加載器就是解決這個(gè)問題的。父加載器加載的類艰争，可以訪問當(dāng)前線程上下文類加載器加載的類坏瞄，解決了父加載器加載的類不能訪問子加載器加載的類的問題。

6.類加載器的命名空間

6.1 何為命名空間

每個(gè)類加載器都有自己的命名空間园细，命名空間由該加載器和該加載器的父加載器所加載的類組成
同一命名空間中惦积，不會(huì)出現(xiàn)類的完整名字相同的兩個(gè)類。
不同命名空間中猛频，可以出現(xiàn)類的完整名字相同的兩個(gè)類狮崩。

注意事項(xiàng)

子加載器所加載的類可以通過“引用”加載訪問父加載器加載的類。（雙親委托）
父加載器所加載的類不可以通過“引用”加載本該由子加載器加載的類
沒有關(guān)系加載器所加載的類是互相不可見的

6.2 類加載器和命名空間的關(guān)系

在雙親委托模型下

同一個(gè)命名空間的類是相互可見的
子加載器的命名空間包含所有父加載器的命名空間鹿寻，因此子加載器加載的類是可以看見父加載器加載的類睦柴，父加載器加載的類則不可看見子加載器加載的類。
如果兩個(gè)加載器之間沒有直接或間接的關(guān)系毡熏，則他們各自加載的類相互不可見坦敌。

3.類的使用和卸載

使用加載連接和初始化的過程
卸載內(nèi)存中銷毀類
一個(gè)類在何時(shí)結(jié)束生命周期，取決于類的class文件何時(shí)被銷毀
java自帶的類加載器會(huì)始終引用他們加載的類痢法，因此不會(huì)卸載狱窘。自定義的加載器加載的類可以被卸載。