概述
持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第5天，点击查看活动详情
前面通过类加载器系列(二)——从源码角度理解双亲委派模型讲解了类加载器的双亲委派模型，提到了自定义类加载器，那么我们现在讲解下如何自定义类加载器。
自定义类加载器场景
java内置的类加载器不满足于我们加载类的需求，这种情况下需要我们自定义一个类加载器，通常有一下几种情况：
- 扩展类加载源
通常情况下我们写的java类文件存放在classpath下，由应用类加载器AppClassLoader加载。我们可以自定义类加载器从数据库、网络等其他地方加载我们我们的类。
- 隔离类
比如tomcat这种web容器中，会部署多个应用程序，比如应用程序A依赖了一个三方jar的1.0.0版本， 应用程序B依赖了同一个三方jar的版本1.1.0, 他们使用了同一个类User.class, 这个类在两个版本jar中有内容上的差别，如果不做隔离处理的话，程序A加载了1.0.0版本中的User.class, 此时程序B也去加载时，发现已经有了User.class, 它实际就不会去加载1.1.0版本中的User.class,最终导致严重的后果。所以隔离类在这种情况还是很有必要的。
为了实现隔离性，优先加载 Web 应用自己定义的类，所以没有遵照双亲委派的约定，每一个应用自己的类加载器——WebAppClassLoader负责加载本身的目录下的class文件，加载不到时再交给CommonClassLoader加载，这和双亲委派刚好相反。
- 防止源码泄露
某些情况下，我们的源码是商业机密，不能外泄，这种情况下会进行编译加密。那么在类加载的时候，需要进行解密还原，这种情况下就要自定义类加载器了。
实现方式
Java提供了抽象类java.lang.ClassLoader，所有用户自定义的类加载器都应该继承ClassLoader类。
在自定义ClassLoader的子类时候，我们常见的会有两种做法:
● 重写loadClass()方法
● 重写findClass()方法
loadClass() 和 findClass()
查看源码，我们发现loadClass()最终调用的还是findClass()方法。
那我们该用那种方法呢？
主要根据实际需求来，
- 如果想打破双亲委派模型，那么就重写整个loadClass方法
loadClass()中封装了双亲委派模型的核心逻辑，如果我们确实有需求，需要打破这样的机制，那么就需要重写loadClass()方法。
- 如果不想打破双亲委派模型，那么只需要重写findClass方法即可
但是大部分情况下，我们建议的做法还是重写findClass()自定义类的加载方法，根据指定的类名，返回对应的Class对象的引用。因为任意打破双亲委派模型可能容易带来问题，我们重写findClass()是在双亲委派模型的框架下进行小范围的改动。
自定义一个类加载器
需求： 加载本地磁盘D盘目录下的class文件。
分析： 该需求只是从其他一个额外路径下加载class文件，不需要打破双亲委派模型，可以直接定义loadClass()方法。
public class FileReadClassLoader extends ClassLoader {
private String dir;
public FileReadClassLoader(String dir) {
this.dir = dir;
}
public FileReadClassLoader(String dir, ClassLoader parent) {
super(parent);
this.dir = dir;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
// 读取class
byte[] bytes = getClassBytes(name);
// 将二进制class转换为class对象
Class<?> c = this.defineClass(null, bytes, 0, bytes.length);
return c;
} catch (Exception e) {
e.printStackTrace();
}
return super.findClass(name);
}
private byte[] getClassBytes(String name) throws Exception {
// 这里要读入.class的字节，因此要使用字节流
FileInputStream fis = new FileInputStream(new File(this.dir + File.separator + name + ".class"));
FileChannel fc = fis.getChannel();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
WritableByteChannel wbc = Channels.newChannel(baos);
ByteBuffer by = ByteBuffer.allocate(1024);
while (true) {
int i = fc.read(by);
if (i == 0 || i == -1)
break;
by.flip();
wbc.write(by);
by.clear();
}
fis.close();
return baos.toByteArray();
}
}
复制代码测试：
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
// 创建自定义的类加载器
FileReadClassLoader fileReadClassLoader = new FileReadClassLoader("D:\classes");
// 加载类
Class<?> account = fileReadClassLoader.loadClass("Account");
Object o = account.newInstance();
ClassLoader classLoader = o.getClass().getClassLoader();
System.out.println("加载当前类的类加载器为：" + classLoader);
System.out.println("父类加载器为：" + classLoader.getParent());
}
复制代码SpringBoot自定义ClassLoader
springboot想必大家都使用过，它也用到了自定义的类加载器。springboot最终打成一个fat jar，通过java -jar xxx.jar,就可以快速方便的启动应用。
fat jar目录结构：
├───BOOT-INF
│ ├───classes
│ │ │ application.properties
│ │ │
│ │ └───com
│ │ └───alvin
│ │ │ Application.class
│ │
│ └───lib
│ .......（省略）
│ spring-aop-5.1.2.RELEASE.jar
│ spring-beans-5.1.2.RELEASE.jar
│ spring-boot-2.1.0.RELEASE.jar
│ spring-boot-actuator-2.1.0.RELEASE.jar
│
├───META-INF
│ │ MANIFEST.MF
│ │
│ └───maven
│ └───com.gpcoding
│ └───spring-boot-exception
│ pom.properties
│ pom.xml
│
└───org
└───springframework
└───boot
└───loader
│ ExecutableArchiveLauncher.class
│ JarLauncher.class
│ LaunchedURLClassLoader$UseFastConnectionExceptionsEnumeration.class
│ LaunchedURLClassLoader.class
│ Launcher.class
│ MainMethodRunner.class
│ PropertiesLauncher$1.class
│ PropertiesLauncher$ArchiveEntryFilter.class
│ PropertiesLauncher$PrefixMatchingArchiveFilter.class
│ PropertiesLauncher.class
│ WarLauncher.class
│
├───archive
│ Archive$Entry.class
│ 。。。（省略）
│
├───data
│ RandomAccessData.class
│ 。。。（省略）
├───jar
│ AsciiBytes.class
│ 。。。（省略）
└───util
SystemPropertyUtils.class
复制代码从目录结构我们看出：
|--BOOT-INF
|--BOOT-INF\classes 该文件下的文件是我们最后需要执行的代码
|--BOOT-INF\lib 该文件下的文件是我们最后需要执行的代码的依赖
|--META-INF
|--MANIFEST.MF 该文件指定了版本以及Start-Class，Main-Class
|--org 该文件下的文件是一个spring loader文件，应用类加载器首先会加载执行该目录下的代码
复制代码显然，这样的目录结构，需要我们通过自定义类加载器，去加载其中的类。
查看目录结构中的MANIFEST.MF文件，如下：
Manifest-Version: 1.0
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Implementation-Title: springboot-01-helloworld
Implementation-Version: 1.0-SNAPSHOT
Spring-Boot-Layers-Index: BOOT-INF/layers.idx
Start-Class: com.alvinlkk.HelloWorldApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Build-Jdk-Spec: 1.8
Spring-Boot-Version: 2.5.6
Created-By: Maven JAR Plugin 3.2.2
Main-Class: org.springframework.boot.loader.JarLauncher
复制代码可以看到，实际的启动的入口类为org.springframework.boot.loader.JarLauncher，在解压的目录中可见。
为了方便查看源码，我们需要在工程中引入下面的依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-loader</artifactId>
<version>2.7.0</version>
</dependency>
复制代码执行逻辑如下：
Lanuncher#launch()方法中创建了LaunchedURLClassLoader类加载器，设置到线程上下文类加载器中。- 通过反射获取带有
SpringBootApplication注解的启动类，执行main方法。
LaunchedURLClassLoader解析
org.springframework.boot.loader.LaunchedURLClassLoader 是 spring-boot-loader 中自定义的类加载器，实现对 jar 包中 BOOT-INF/classes 目录下的类和 BOOT-INF/lib 下第三方 jar 包中的类的加载。
LaunchedURLClassLoader重写了loadClass方法，打破了双亲委派模型。
/**
* 重写类加载器中加载 Class 类对象方法
*/
@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
// 如果名称是以org.springframework.boot.loader.jarmode开头的直接加载类
if (name.startsWith("org.springframework.boot.loader.jarmode.")) {
try {
Class<?> result = loadClassInLaunchedClassLoader(name);
if (resolve) {
resolveClass(result);
}
return result;
}
catch (ClassNotFoundException ex) {
}
}
if (this.exploded) {
return super.loadClass(name, resolve);
}
Handler.setUseFastConnectionExceptions(true);
try {
try {
// 判断这个类是否有对应的package包
// 没有的话会从所有 URL（包括内部引入的所有 jar 包）中找到对应的 Package 包并进行设置
definePackageIfNecessary(name);
}
catch (IllegalArgumentException ex) {
// Tolerate race condition due to being parallel capable
if (getPackage(name) == null) {
// This should never happen as the IllegalArgumentException indicates
// that the package has already been defined and, therefore,
// getPackage(name) should not return null.
throw new AssertionError("Package " + name + " has already been defined but it could not be found");
}
}
// 调用父类的加载器
return super.loadClass(name, resolve);
}
finally {
Handler.setUseFastConnectionExceptions(false);
}
}
/**
* Define a package before a {@code findClass} call is made. This is necessary to
* ensure that the appropriate manifest for nested JARs is associated with the
* package.
* @param className the class name being found
*/
private void definePackageIfNecessary(String className) {
int lastDot = className.lastIndexOf('.');
if (lastDot >= 0) {
// 获取包名
String packageName = className.substring(0, lastDot);
// 没有找到对应的包名，则进行解析
if (getPackage(packageName) == null) {
try {
// 遍历所有的 URL，从所有的 jar 包中找到这个类对应的 Package 包并进行设置
definePackage(className, packageName);
}
catch (IllegalArgumentException ex) {
// Tolerate race condition due to being parallel capable
if (getPackage(packageName) == null) {
// This should never happen as the IllegalArgumentException
// indicates that the package has already been defined and,
// therefore, getPackage(name) should not have returned null.
throw new AssertionError(
"Package " + packageName + " has already been defined but it could not be found");
}
}
}
}
}
private void definePackage(String className, String packageName) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
// 把类路径解析成类名并加上 .class 后缀
String packageEntryName = packageName.replace('.', '/') + "/";
String classEntryName = className.replace('.', '/') + ".class";
// 遍历所有的 URL（包括应用内部引入的所有 jar 包）
for (URL url : getURLs()) {
try {
URLConnection connection = url.openConnection();
if (connection instanceof JarURLConnection) {
JarFile jarFile = ((JarURLConnection) connection).getJarFile();
// 如果这个 jar 中存在这个类名，且有对应的 Manifest
if (jarFile.getEntry(classEntryName) != null && jarFile.getEntry(packageEntryName) != null
&& jarFile.getManifest() != null) {
// 定义这个类对应的 Package 包
definePackage(packageName, jarFile.getManifest(), url);
return null;
}
}
}
catch (IOException ex) {
// Ignore
}
}
return null;
}, AccessController.getContext());
}
catch (java.security.PrivilegedActionException ex) {
// Ignore
}
}
复制代码总结
本文阐述如何创建自定义类加载器，以及在什么场景下创建自定义类加载器，同时通过springboot启动拆创建的类加载器加深我们的理解。