类加载器概念
一个完整的 Java 应用程序由若干个 Java Class 文件组成，当程序在运行时，会通过一个入口函数来调用系统的各个功能，这些功能都被存放在不同的 Class 文件中。
因此，系统在运行时经常会调用不同 Class 文件中被定义的方法，如果某个 Class 文件不存在，则系统会抛出 ClassNotFoundException 异常。
系统程序在启动时，不会一次性加载所有程序要使用的 Class 文件到内存中，而是根据程序需要，通过 Java 的类加载机制动态将需要使用的 Class 文件加载到内存中; 只有当某个 Class 文件被加载到内存后，该文件才能被其他 Class 文件调用。
这个 “类加载机制“ 就是 ClassLoader , 他的作用是动态加载 Java Class 文件到 JVM 的内存空间中，让 JVM 能够调用并执行 Class 文件中的字节码。
类加载流程
-
加载阶段 ：该阶段是类加载过程的第一个阶段，会通过一个类的完全限定名称来查找类的字节码文件，并利用字节码文件来创建一个 Class 对象。
-
验证阶段 ：该阶段是类加载过程的第二个阶段，其目的在于确保 Class 文件中包含的字节流信息符合当前 Java 虚拟机的要求。
-
准备阶段： 该阶段会为类变量在方法区中分配内存空间并设定初始值( 这里 “类变量” 为static修饰符修饰的字段变量 )
- 不会分配并初始化用 final 修饰符修饰的 static 变量，因为该类变量在编译时就会被分配内存空间。
- 不会分配并初始化实例变量，因为实例变量会随对象一起分配到 Java 堆中，而不是 Java 方法区。
-
解析阶段 ：该阶段会将常量池中的符号引用替换为直接引用。
-
初始化阶段 ：该阶段是类加载的最后阶段，如果当前类具有父类，则对其进行初始化，同时为类变量赋予正确的值。
vm 启动时加载 class 文件的两种方式：
- 隐式加载：JVM 自动加载需要的类到内存中
- 显式加载：通过 class.forName() 动态加载 class文件到 jvm 中
Java类加载方式分为显式和隐式,显式即我们通常使用Java反射或者ClassLoader来动态加载一个类对象，而隐式指的是类名.方法名()或new类实例。显式类加载方式也可以理解为类动态加载，我们可以自定义类加载器去加载任意的类。
Class.forName("类名")默认会初始化被加载类的静态属性和方法，如果不希望初始化类可以使用Class.forName("类名", 是否初始化类, 类加载器)和ClassLoader.loadClass默认不会初始化类方法。
类加载机制
类加载初始化和实例化的时候会执行对应的代码块
初始化：静态代码块(一次执行中静态代码块只能执行一次)
实例化：匿名代码块、构造方法
实例
先定义一个需要我们进行类加载的java文件
Person.java
public class Person {
public String name;
private int age;
public static int id;
static {
System.out.println("静态代码块");
}
public static void staticAction(){
System.out.println("静态方法");
}
{
System.out.println("构造代码块");
}
public Person() {
System.out.println("无参构造方法");
}
public Person(String name, int age) {
System.out.println("有参构造方法");
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
实例化
PersonTest.java
public class PersonTest {
public static void main(String[] args) {
new Person("Sentiment",18);
}
}
这里经过了初始化和实例化，所以会依次调用静态代码块、匿名代码块、构造方法
而如果在初始化一条new Person("Tana",18);时，就不会调用静态代码块了
public class PersonTest {
public static void main(String[] args) {
new Person("Sentiment",18);
new Person("Tana",18);
}
}
可以看到静态代码块单次运行中只会调用一次
调用静态方法
而当我们调用静态方法时，其实只是进行了初始化，并没有实例化，所以就不会执行构造代码块和构造方法
public class PersonTest {
public static void main(String[] args) {
Person.staticAction();
}
}
结果:
静态代码块
静态方法
class类加载
用class关键字时，只进行了类加载并没有进行初始化，所以不会调用任何代码块
public class PersonTest {
public static void main(String[] args) {
Class personClass = Person.class;
}
}
Class.forName
在类加载流程最后提到过，Class.forName("类名")会进行初始化，而Class.forName("类名", 是否初始化类, 类加载器)和ClassLoader.loadClass不会，所以先看下只给类名的情况
Class<?> person = Class.forName("Person");
结果输出了静态代码块，这也就证明了在只给类名的情况下是默认会被初始化的
静态代码块
而Class.forName("类名", 是否初始化类, 类加载器)，可设定是否初始化，这里第二个参数设为false就不会有任何回显
public class PersonTest {
public static void main(String[] args) throws Exception {
ClassLoader c = ClassLoader.getSystemClassLoader();
Class<?> c1 = Class.forName("Person", false, c);
}
}
跟进一下forName()，发现第二个参数就是设定是否初始化的参数，所以这里设为false后便不会再初始化，而我们不传第二个参数时，会执行forName0初始化部分默认为true
这里用到的是
getSystemClassLoader，因为ClassLoader是一个抽象方法无法实例化，所以就找到了他的静态方法getSystemClassLoader实现调用，而它的值其实也就是系统类加载器（AppClassLoader），这个在双亲委派中会提到
public static Class<?> forName(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException
{
Class<?> caller = null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
// Reflective call to get caller class is only needed if a security manager
// is present. Avoid the overhead of making this call otherwise.
caller = Reflection.getCallerClass();
if (sun.misc.VM.isSystemDomainLoader(loader)) {
ClassLoader ccl = ClassLoader.getClassLoader(caller);
if (!sun.misc.VM.isSystemDomainLoader(ccl)) {
sm.checkPermission(
SecurityConstants.GET_CLASSLOADER_PERMISSION);
}
}
}
return forName0(name, initialize, loader, caller);
}
ClassLoader.loadClass
最后就是这种形式了，默认不会初始化所以没有输出内容
public class PersonTest {
public static void main(String[] args) throws Exception {
ClassLoader c = ClassLoader.getSystemClassLoader();
Class<?> person = c.loadClass("Person");
}
}
类加载分类
- JVM 默认类加载器
主要由 “引导类加载器”、“扩展类加载器”、“系统类加载器” 三方面组成。 - 用户自定义类加载器
用户可以编写继承 java.lang.ClassLoader类的自定义类来自定义类加载器。
引导类加载器（BootstrapClassLoader）
引导类加载器(BootstrapClassLoader)，native类型方法，所以底层原生代码是C++语言编写，属于jvm一部分，不继承java.lang.ClassLoader类，也没有父加载器，主要负责加载核心java库(即JVM本身)，存储在/jre/lib/rt.jar目录当中。(同时处于安全考虑，BootstrapClassLoader只加载包名为java、javax、sun等开头的类)。
扩展类加载器（ExtensionsClassLoader）
扩展类加载器（ExtensionsClassLoader）是引导类加载器（BootstrapClassLoader）的子集，其核心目的是加载标准核心Java类的扩展，以便适配平台上运行的所有应用程序。
由sun.misc.Launcher$ExtClassLoader类实现，用来在/jre/lib/ext或者java.ext.dirs中指明的目录加载java的扩展库。Java虚拟机会提供一个扩展库目录，此加载器在目录里面查找并加载java类。
系统类加载器（AppClassLoader）
App类加载器/系统类加载器（AppClassLoader），由sun.misc.Launcher$AppClassLoader实现，一般通过通过(java.class.path或者Classpath环境变量)来加载Java类，也就是我们常说的classpath路径。通常我们是使用这个加载类来加载Java应用类，可以使用ClassLoader.getSystemClassLoader()来获取它。
自定义类加载器（UserDefineClassLoader）
用户自定义。
双亲委派机制
通常情况下，我们就可以使用JVM默认三种类加载器进行相互配合使用，且是按需加载方式，就是我们需要使用该类的时候，才会将生成的class文件加载到内存当中生成class对象进行使用，且加载过程使用的是双亲委派模式，及把需要加载的类交由父加载器进行处理。
如上图类加载器层次关系，我们可以将其称为类加载器的双亲委派模型。但注意的是，他们之间并不是"继承"体系，而是委派体系。当上述特定的类加载器接到加载类的请求时，首先会先将任务委托给父类加载器，接着请求父类加载这个类，当父类加载器无法加载时（其目录搜素范围没有找到所需要的类时），子类加载器才会进行加载使用。这样可以避免有些类被重复加载。
优点
避免重复加载使用，直接先给父加载器加载，不用子加载器再次重复加载。
保证java核心库的类型安全。比如网络上传输了一个java.lang.Object类，通过双亲模式传递到启动类当中，然后发现其Object类早已被加载过，所以就不会加载这个网络传输过来的java.lang.Object类，保证我们的java核心API库不被篡改，出现类似用户自定义java.lang.Object类的情况。
ClassLoader的核心方法
除了上述的BootstrapClassLoader，其他类加载器都是继承了CLassLoader类，我们就一起看看其类的核心方法。以下代码都是截取了其方法的源码。
- loadClass(加载指定的Java类)
- findClass(查找指定的Java类)
- findLoadedClass(查找JVM已经加载过的类)
- defineClass(定义一个Java类，将字节码解析成虚拟机识别的Class对象。往往和findClass()方法配合使用。)
- resolveClass(链接指定的Java类)
着重看下loadClass()方法
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);
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
}
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
PerfCounter.getParentDelegationTime().addTime(t1 - t0);
PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
首先是findLoadedClass()：如果这个类已经被加载了，就直接返回，不会重复加载，不然的话，继续处理。
如果存在父加载器，就c = parent.loadClass(name, false);，调用父类的加载器进行进行加载。如果不存在父加载器，就c = findBootstrapClassOrNull(name);，调用JVM默认类加载器进行加载即：BootstrapClassLoader；这也就解释了ExtClassLoader的parent为null，所以继续向上委派
若找到了对应的类，并且接收到的resolve参数的值为true,那么就会调用resolveClass(Class)方法来处理类。
如果还是找不到的话，就c = findClass(name);，调用findClass方法进行类的寻找。但是findClass方法是空的：
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
这里其实就是双亲委派的体现，若没找到，findClass为空这时就需要我们自定义类加载器。
自定义类加载器
步骤
1.编写一个类继承自ClassLoader抽象类。
2.重写它的findClass()方法。
3.在findClass ()方法中调用defineClass( ) 。
实例
TestClassLoader.java重写findClass
import java.io.*;
public class TestClassLoader extends ClassLoader
{
private String classPath;
public TestClassLoader(String classPath){
this.classPath = classPath;
}
private String getFileName(String fileName){
int index = fileName.lastIndexOf('.');
if (index == -1){
return fileName + ".class";
}else {
return fileName.substring(index + 1) + ".class";
}
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String fileName = getFileName(name);
File file = new File(classPath, fileName);
try {
FileInputStream fileInputStream = new FileInputStream(file);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
int len = 0;
try {
while ((len = fileInputStream.read()) != -1) {
byteArrayOutputStream.write(len);
}
} catch (IOException e) {
e.printStackTrace();
}
byte[] data = byteArrayOutputStream.toByteArray();
fileInputStream.close();
byteArrayOutputStream.close();
return defineClass(name, data, 0, data.length);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return super.findClass(name);
}
}
TestHelloWorld.java
public class TestHelloWorld
{
public String hello(){
return "Hello World!";
}
}
JvmLearn.java,路径为TestHelloWorld.class的存放路径
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
public class JvmLearn
{
public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, IllegalAccessException, InstantiationException, MalformedURLException {
test1();
}
public static void test1() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
TestClassLoader classLoader = new TestClassLoader("C:\\Users\\del'l'\\Desktop\\");
Class clazz = classLoader.loadClass("TestHelloWorld");
Object o = clazz.newInstance();
Method m = clazz.getMethod("hello");
System.out.println(m.invoke(o));
}
}
URLClassLoader
本地磁盘class调用
Exec.java
import java.io.IOException;
public class Exec {
public Exec() throws IOException {
Runtime.getRuntime().exec("calc");
}
}
Classloader.java，路径为Exec.class的路径
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
public class Classloader {
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
URL[] urls = {new URL("file:///C:\\Users\\del'l'\\Desktop\\")};
URLClassLoader classLoader = URLClassLoader.newInstance(urls);
Class<?> c = classLoader.loadClass("Exec");
c.newInstance();
}
}
网络传输class调用
Classloader.java，Exec.java不变
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
public class Classloader {
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
URL[] urls = {new URL("http://127.0.0.1:8000/")};
URLClassLoader classLoader = URLClassLoader.newInstance(urls);
Class<?> c = classLoader.loadClass("Exec");
c.newInstance();
}
}
需开启远程服务
总结
这部分学的有点乱，大部分都是复制师傅的，看不懂的话可以参考师傅们的原文
JAVA安全基础（一）–类加载器（ClassLoader） - 先知社区 (aliyun.com)
261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
