符号引用 vs 直接引用#

• 符号引用使用一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关，引用的目标不一定已经加载到了内存中。

• 直接引用是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。直接引用是与虚拟机实现的内存布局相关的。

类加载分几步？#

苏宁、国美、蚂蚁金服、百度、美团、京东

都谁需要加载？

在Java中数据类型分为基本数据类型和引用数据类型。基本数据类型由虚拟机预先定义，引用数据类型需要进行类的加载。

public class InitializationTest1 {
    // 对于非静态的字段，不管是否显式赋值，都不会生成<clinit>()
    public int num = 1;
    // 静态字段，但没有显式赋值，不会生成<clinit>()
    public static int num1;
    // final以后就不是“变”量了，不会生成<clinit>()
    public static final int num2 = 1;
}

public class InitializationTest2 {
	public static int a = 1; // 在初始化阶段赋值 有<clinit>
	public static final int INT_CONSTANT = 10;	//在链接阶段的Prepare环节赋值

	public static Integer INTEGER_CONSTANT1 = Integer.valueof(100);// 在初始化阶段赋值 有<clinit>
	public static final Integer INTEGER_CONSTANT2 =Integer.valueOf(1000);// 在初始化阶段赋值 有<clinit>
	
    public static final String s0 = "helloworld0"; // 在链接阶段的准备阶段赋值
	public static final String s1 = new String("helloworld1");// 在初始化阶段赋值
    
	public static String s2 = "helloworld2"; // 在初始化阶段赋值
	public static final int NUM1 = new Random().nextInt(bound:10); // 在初始化阶段赋值
    
    static a = 9;
    static final b = a;		// 要先有a才行，b一开始先赋值默认值
}

作用#

类加载器是 JVM 执行类加载机制的前提。

ClassLoader作用：ClassLoader是Java的核心组件，所有的Class都是由ClassLoader进行加载的，ClassLoader负责通过各种方式将Class信息的二进制数据流读入JVM内部，转换为一个与目标类对应的java.lang.Class对象实例。然后交给Java虚拟机进行链接、初始化等操作。

显式加载 vs 隐式加载#

• 显式加载：主动加载，在代码中调用ClassLoader加载class对象，如直接使用Class.forName(name)或this.getClass().getClassLoader().loadClass()加载class对象。

• 隐式加载：不直接在代码中调用ClassLoader加载class对象，如在加载某个class文件时，该类的class文件中引用了另外一个类的对象，此时额外引用的类通过JVM自动加载到内存中。
  

  例如：System.out.println()会自动将流加载到内存中

类加载机制的必要性#

• 避免开发中遇到 java.lang.ClassNotFoundException 异常或 java.lang.NoClassDefFoundError 异常时手足无措，只有了解类加载机制才能在出现异常时快速定位问题。
• 需要支持类的动态加载或需要对编译后的字节码文件进行加解密操作时，就需要和类加载器打交道了。
• 开发人员可以编写自定义类加载器来重新定义类的加载规则，以便实现一些自定义处理逻辑。

类的唯一性#

对于任意一个类，都需要由加载它的类加载器和这个类本身一同确认其在Java中的唯一性。每一个类加载器，都拥有一个独立的类名称空间；比较两个类是否相等，只有在这两个类是由同一个类加载器加载的前提下才有意义。否则，即时这两个类源自同一个Class文件，被同一个虚拟机加载，只要加载他们的类加载器不同，那这两个类就必定不相等。

基本特征#

• 双亲委派模型
• 可见性：子类加载器可以访问父类加载器加载的类型，反之不可。
• 单一性：父类加载器加载过的类型，子类不会重复加载。类加载器”邻居“之间，同一类型仍可以被加载多次，因为互相并不可见。

1. 分类#

分成两类

• 引导类加载器（Bootstrap ClassLoader）（C编写）
• 自定义类加载器（User-Defined ClassLoader）（Java编写）

最上面的是引导类加载器，下面四个是自定义类加载器。在整个图中，下面的加载器可以调用上面的，上面不可调用下面的。

2. 子父类加载器的关系#

看似是继承关系，实际上是包含关系！

class ClassLoader {
    ClassLoader parent;	// 父类加载器
    public ClassLoader(ClassLoader parent) {
        this.parent = parent;
    }
}

3. 具体类的加载器介绍#

4. 用户自定义类加载器#

• 在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的。在必要时，我们还可以自定义类加载器，来定制类的加载方式。
• 体现Java语言强大生命力和巨大魅力的关键因素之一便是，Java开发者可以自定义类加载器来实现类库的动态加载，加载源可以是本地的JAR包，也可以是网络上的远程资源。
• 通过类加载器可以实现非常绝妙的插件机制，这方面的实际应用案例举不胜举。例如，著名的OSGI组件框架，再如Ec1ipse的插件机制。类加载器为应用程序提供了一种动态增加新功能的机制，这种机制无须重新打包发布应用程序就能实现。
• 同时，自定义加载器能够实现应用隔离，例如Tomcat，Spring等中间件和组件框架都在内部实现了自定义的加载器，并通过自定义加载器隔离不同的组件模块。这种机制比C/C++程序要好太多，想不修改C/C++程序就能为其新增功能，几乎是不可能的，仅仅一个兼容性便能阻挡住所有美好的设想。
• 所有用户自定义类加载器通常需要继承于抽象类java.lang.ClassLoader。

public class ClassLoaderTest {
    public static void main(String[l args) {
        // 获取系统该类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        // 获取扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent();
        System.out.println(extClassLoader);
        // 试图获取引导类加载器：失败
        // 引导类加载器是C语言编写的 所以获取不到
        ClassLoader bootstrapclassLoader = extClassLoader.getParent();
        System.out.println(bootstrapclassLoader);
    }
}

5. ClassLoader源码解析#

public abstract class ClassLoader {
		private final ClassLoader parent;	// 看似是继承关系，实际上应该是包含关系
  	public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
  	// 双亲委派机制
  	protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 看看是否已经加载过了
            Class<?> c = findLoadedClass(name);
            if (c == null) {
              	// 没加载过
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {	// 先去看父类加载器
                        c = parent.loadClass(name, false);
                    } else {							// parent是null，说明父类加载器是引导类加载器
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // 所有父类加载器都不能加载这个类，只能自己加载
                    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
          	// 看看是否需要解析，默认不解析只Loading
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
}

为什么要自定义类加载器？#

• 隔离加载类

在某些框架内进行中间件与应用的模块隔离，把类加载到不同的环境。比如：阿里内某容器框架通过自定义类加载器确保应用中依赖的jar包不会影响到中间件运行时使用的jar包。再比如：Tomcat这类Web应用服务器，内部自定义了好几种类加载器，用于隔离同一个Web应用服务器上的不同应用程序。

（类的仲裁—>类冲突）

• 修改类加载的方式

类的加载模型并非强制，除Bootstrap外，其他的加载并非一定要引入，或者根据实际情况在某个时间点进行按需进行动态加载

• 扩展加载源

比如从数据库、网络、甚至是电视机机项盒进行加载

• 防止源码泄漏

Java代码容易被编译和篡改，可以进行编译加密。那么类加载也需要自定义，还原加密的字节码。

实现方式（两种）#

面试题：手写一个类加载器Demo（百度）

已知有类User

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

编译成.class文件后放在某个目录下

package cn.lettle.classloader;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;

// 自定义类加载器
public class UserDefineClassLoader extends ClassLoader {
    private String rootPath;

    public UserDefineClassLoader(String _rootpath){
        rootPath = _rootpath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 转换为以文件路径表示的文件
        String filepath = classToFilePath(name);
        // 获取指定路径的class文件对应的二进制流数据
        byte[] data = getBytesFromPath(filepath);
        // 自定义 ClassLoader 内部调用 defineClass()
        return defineClass(name, data, 0, data.length);
    }

    private byte[] getBytesFromPath(String filepath) {
        FileInputStream fis = null;
        ByteArrayOutputStream baos = null;
        try {
            fis = new FileInputStream(filepath);
            baos = new ByteArrayOutputStream();

            byte[] buffer = new byte[1024];
            int len;

            while ((len = fis.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null)
                    baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private String classToFilePath (String name) {
        return rootPath + "/" + name.replace('.', '/') + ".class";
    }

    // 希望可以加载 com.lettle.test.classloader.User
    public static void main(String[] args) {
        try {
            UserDefineClassLoader loader1 = new UserDefineClassLoader("/Users/lettle/Documents/Java/JavaTests/src");
            Class userClass1 = loader1.findClass("cn.lettle.classloader.User");
            System.out.println(userClass1);

            UserDefineClassLoader loader2 = new UserDefineClassLoader("/Users/lettle/Documents/Java/JavaTests/src");
            Class userClass2 = loader2.findClass("cn.lettle.classloader.User");
            System.out.println(userClass2);


            // 两个类不是一个类加载器来加载的，故 false
            // 这样就实现类的隔离了
            System.out.println(userClass1 == userClass2);

            System.out.println(userClass1.getClassLoader());
            System.out.println(userClass1.getClassLoader().getParent());


        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

输出：

class cn.lettle.classloader.User
class cn.lettle.classloader.User
false
cn.lettle.classloader.UserDefineClassLoader@735f7ae5
jdk.internal.loader.ClassLoaders$AppClassLoader@34340fab

双亲委派机制#

什么是tomcat类加载机制？#

Tomcat的类加载机制是违背了双亲委派机制的

沙箱安全机制#