由于工作需要,近来需要自定义类加载器进行类文件的自定义加载,完成对自定义注解的相关解析并处理,相信大家已经对类加载的结构有所了解了,所以就直奔主题了
jvm的双亲委派模型
相信大家对这个图,已经不能熟悉得再熟悉了,不过还是要说明几点
- 当jvm进行类加载的时候(没有自定义类加载器的情况下),默认会先从appClassLoader查找,如果有,那么会直接返回,如果没有,那么就会找其父级开始加载,如果父级也没有,那么就会一直找到bootStrapClassloader,当bootStrapClassloader也没有,那么就会让appClassLoader开始加载文件,如果appClassloader也没有,那么就会抛出异常,
其处理逻辑如下:
由此,我们可以得出:
如果我们想要不破坏双亲模型的情况下,自定义加载类,那么我们只需要重写findClass这个方法即可, 如果我们想要破坏双亲委派模型,那么我们就需要重写loadClass方法
-
这几个类加载的关系并不是继承关系,只是父子关系,我们可以看看appClassLoader和extClassLoader的关系
由上图可以看出,这两个类都是继承了URLClassLoader,并不是appClassLoader继承了extClassLoader,他们的关系都是继承自urlClassLoadder
至于在哪里指定extClassLoader为appClassLoader的父加载器,见如下代码:
可以看到执行了如下代码
this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);,那么进入可以看到其实到这里,我们发现,这个就是设置extClassLoader为appClassLoader的父加载器
-
为什么我们需要双亲委派模型? 假如现在我们的应用程序里面也有一个
java.lang.String这个类,试想一下会怎么样,这样就破坏了jvm里面的核心代码了是不是,再者就是程序里面这么多相同的类,如果每个类加载器都自己加载的话,那么就会出现很多了String类了,就会导致程序混乱,如果本加载器加载了,父加载器不加载,那么应该以哪个加载的为准也不好确认,增加复杂度, 这里其实还有一个,就是jvm提供了沙箱机制,防止了恶意代码的注入,如果自定义加载的类被加载了,而加入了恶意代码,那么所有用到的String类都会执行这个恶意代码,想想还是蛮可怕,所以后来也有了String这个类为final类,禁止对其内部方法进行重写,如果有双亲委派模型,那么我们自定义的String类就不会加载(其实会报错的) -
只有被同一个类加载器实例加载并且文件名相同的class文件才被认为是同一个class
自定义类加载器
当我们对上面的逻辑了解清晰后,那么对自定义类加载的结构已经了相当够的了解,此时,我们只需要对类加载的findclass方法进行重写即可
public class FileUrlClassLoader extends ClassLoader implements Closeable {
/**
* META-INF.MF定义的链码基础扫描路径
*/
private static final String CHAINCODE_BASE_PACKAGE = "Chaincode-Base-Package";
/**
* 解压的临时包名
*/
private static final String JAR_TMP_PACKAGE = "chaincode";
private static final int BUFFER_SIZE = 1024;
private static Map<String, byte[]> map;
/**
* 如果用户不配置,那么默认扫描com.xxx包下面的注解包
*/
private List<String> packageScanList = Arrays.asList("com.xxx");
private List<String> classNameList = new ArrayList<>(256);
/**
* 由顶级加载器和扩展加载器的列表信息
*/
private List<String> bootAndExtLoaderList = Arrays.asList("sun", "java", "javax", "jdk", "javassist");
public FileUrlClassLoader(String jarPath) throws FileNotFoundException {
/**
* 设置当前类加载器的父类为当前线程的类加载器,因为默认是使用的是appclassloader,
* 但是springboot项目的classloader是springboot自定义的classloader(具体可看打包好后的jar文件的META-INF.MF文件,指定的启动类为springboot的loader),
* 这就会导致加载对应文件不直接属于classloader,相关校验就会失败
*/
super(Thread.currentThread().getContextClassLoader());
if (!jarPath.endsWith(".jar")) {
throw new AppException("jarFile is not a jar" + jarPath);
}
dealChaincodeScanList(jarPath);
this.map = new HashMap<>(64);
unzipJarAndRead(jarPath);
dealLibJar(jarPath);
}
/**
* 获取jar名称路径,以及对应的需要扫描的类路径信息
*
* @param jarPath
* 包含jar名称的文件
* @return
* @throws FileNotFoundException
*/
private void dealChaincodeScanList(String jarPath) throws FileNotFoundException {
try {
JarFile jarFile = new JarFile(jarPath);
Manifest manifest = jarFile.getManifest();
Attributes mainAttributes = manifest.getMainAttributes();
//得到需要进行扫描的类信息
String mainPackage = mainAttributes.getValue(CHAINCODE_BASE_PACKAGE);
if (null != mainPackage) {
this.packageScanList = Arrays.asList(mainPackage.split(","));
}
} catch (IOException e) {
throw new FileNotFoundException("jar:" + jarPath + " not exist");
}
}
/**
* 解压jar文件,并且进行读取加载,
* 如果读取到类信息了,那么则进行读取,
* 如果读取到的是jar内容,那么则进行解压,然后进行文件处理,并读取相应的类文件进行然后进行加载
* @param jarPath
*/
private void unzipJarAndRead(String jarPath) {
//直接解压jar文件,然后递归查询class文件,以及对应的.jar文件,并加载jar文件进行读取
try {
/**
* 直接在对应的jarPath路径下进行解压即可,因为本来路径就是唯一的,而且清理的时候也比较方便
*/
File tmpFolder = new File(jarPath);
String folderParent = tmpFolder.getParent();
File folder = new File(folderParent, JAR_TMP_PACKAGE);
if(!folder.exists()){
folder.mkdir();
}
// 设置jvm关闭的时候自动删除
folder.deleteOnExit();
JarFile jarFile = new JarFile(jarPath);
Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry jarEntry = entries.nextElement();
String name = jarEntry.getName();
if (name.endsWith(".jar")) {
dealJarFile(name, folder, jarFile, jarEntry);
} else if (name.endsWith(".class")) {
dealClass(name, jarFile, jarEntry);
}
//其他类型的暂时不关心,忽略即可
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 对文件是jar的类进行处理
*
* @param name
* @param libJarPath
* 依赖的jar包解压路径
*/
private static void dealJarFile(String name, File libJarPath, JarFile jarFile, JarEntry jarEntry) {
System.out.println("unzip jar file:" + name);
//对jar文件进行解压
String[] split = name.split("/");
if (split.length > 1) {
File file = new File(libJarPath, split[split.length-1]);
try {
if(!file.exists()){
boolean success = file.createNewFile();
if(!success){
throw new RuntimeException("create file:"+file.getPath()+" exception");
}
}
unpack(jarFile, jarEntry, file);
file.deleteOnExit();
} catch (IOException e) {
System.out.println("unzip jar exception:" + e.getMessage());
}
}
}
/**
* 对jar包进行解压
*
* @param jarFile
* @param entry
* @param file
* @throws IOException
*/
private static void unpack(JarFile jarFile, JarEntry entry, File file) throws IOException {
try (InputStream inputStream = jarFile.getInputStream(entry)) {
try (OutputStream outputStream = new FileOutputStream(file)) {
byte[] buffer = new byte[BUFFER_SIZE];
int bytesRead;
while ((bytesRead = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, bytesRead);
}
outputStream.flush();
}
}
}
/**
* 处理加载类信息的逻辑
* 如果在map中已经存在了,那么则直接不进行处理,
* 如果不存在,那么则进行读取类文件,然后放入map中,并将扫描包列表信息进行判断,是否是设置的开头参数,如果有才放入类列表中
* @param name
* @param jarFile
* @param jarEntry
*/
private void dealClass(String name, JarFile jarFile, JarEntry jarEntry) {
String className = name.replace(".class", "").replaceAll("/", ".");
if (!map.containsKey(className)) {
byte[] b = getClassByte(jarFile, jarEntry);
if (null != b) {
map.put(className, b);
//需要判断是否是需要进行扫描的包路径,然后进行添加
packageScanList.stream().forEach(v -> {
if (className.startsWith(v)) {
classNameList.add(className);
}
});
}
}
}
/**
* 对有依赖的jar包进行处理,加载到内存中
*/
private void dealLibJar(String jarPath) {
File tmpFolder = new File(jarPath);
String folderParent = tmpFolder.getParent();
File folder = new File(folderParent, JAR_TMP_PACKAGE);
if (!folder.exists()) {
System.out.println("no lib jar exist,will be return");
return;
}
File[] files = folder.listFiles();
if(files.length == 0){
System.out.println("jar list is empty,will be return");
return;
}
for (File file:files) {
JarFile jarFile = null;
try {
jarFile = new JarFile(file);
Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry jarEntry = entries.nextElement();
String name = jarEntry.getName();
/**
* 针对lib里面的jar包,只会解析.class文件,对其他不关心
*/
if (name.endsWith(".class")) {
dealClass(name, jarFile, jarEntry);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public List<String> getClassNameList() {
return classNameList;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] b;
if (map.containsKey(name)) {
b = map.get(name);
} else {
throw new ClassNotFoundException(name);
}
return defineClass(name, b, 0, b.length);
}
/**
* 获取某个jar里面的信息
*
* @param jarFile
* @param jarEntry
* @return
*/
private byte[] getClassByte(JarFile jarFile, JarEntry jarEntry) {
try (InputStream input = jarFile.getInputStream(jarEntry)) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int bufferSize = 4096;
byte[] buffer = new byte[bufferSize];
int bytesNumRead = 0;
while ((bytesNumRead = input.read(buffer)) != -1) {
baos.write(buffer, 0, bytesNumRead);
}
return baos.toByteArray();
} catch (FileNotFoundException e) {
} catch (IOException e) {
}
return null;
}
@Override
public void close() throws IOException {
if (!map.isEmpty()) {
map.clear();
}
if (!classNameList.isEmpty()) {
classNameList.clear();
}
}
}
此处进行说明几点
- 为什么要使用当前线程类加载器作为其父加载器,不是应该使用默认的appClassLoader吗? 这里会涉及一个问题,当我们使用springboot的项目的时候,springboot打包的时候,会使用自定义的类加载器,导致启动的时候,我们的父加载器不再是appClassLoader,所以此时需要将我们的类加载器的父类设置为springboot的类加载器,完成类的加载,否则会出现,自定义注解读取不了的情况
- 由于我们的jar包里面没有出现jar包中内嵌jar,所以暂时没有对jar文件的进行处理,但是思路是当读到jar文件的时候,对其进行解压,并放入一个列表中,然后按照读取jar一样的来进行读取即可(已提供)
- 由于每次加载都需要去解开文件等等时间太过麻烦,这里我使用map来进行默认的读取和加载类信息,当需要进行查找的时候,就会将其直接命中,当查找不到的时候,就返回异常
