SpringBoot自定义类加载器

于 2024-08-19 17:29:57 发布
阅读量282 收藏
点赞数 1
文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzl1369248650/article/details/129558549
版权

讲解如何获取springBoot classLoader和如何往spring boot classLoader 添加包

获取spring boot classLoader

 /**
     * SpringBoot打包模式下是SpringBoot的类加载器
     * @return
     */
    public static ClassLoader genClassLoader(){
        if (!SystemInfo.INSTANCE.isStandalone()) {
            return null;
        }
        AgentLogger.info("[SF Agent] Use springboot classloader.");
        try {
            // 检测是否SpringBoot打包方式
            Class launcherClass = Class.forName(STANDALONE_CLASS);
            if (launcherClass != null) {
                String jarfilePath = ClassUtils.getClassFilePath(launcherClass);
                if (null == jarfilePath) {
                    return null;
                }

                // 获取Manifest，并且获取Main-Class，可能是JarLauncher或者是WarLauncher
                Class jarFileArchiveClass = Class.forName("org.springframework.boot.loader.archive.JarFileArchive");
                Object jarFileArchiveObj = jarFileArchiveClass.getDeclaredConstructor(File.class).newInstance(new File(jarfilePath));
                Method manifestMethod = jarFileArchiveClass.getDeclaredMethod("getManifest");
                Manifest manifest = (Manifest)manifestMethod.invoke(jarFileArchiveObj);
                String mainClass = manifest.getMainAttributes().getValue("Main-Class");

                // 反射调用Launcer，获取可以加载SpringBoot依赖的类加载器
                Class launcher = Class.forName(mainClass);
                Map<String, Method> methods = getClassLoadderMethod(launcher);
                Method classLoaderMethod = methods.get("classLoader");
                Method archivesMethod = methods.get("archive");
                if (null == classLoaderMethod || null == archivesMethod) {
                    AgentLogger.error("No class loader found.");
                    return null;
                }

                archivesMethod.setAccessible(true);
                classLoaderMethod.setAccessible(true);
                Object launcherObj = launcher.getDeclaredConstructor().newInstance();
                Object classPathArchives = archivesMethod.invoke(launcherObj);
                return (ClassLoader)classLoaderMethod.invoke(launcherObj, classPathArchives);
            }
        } catch (Exception e) {
  
        }
        return null;
    }

通过字节码增强往spring boot classLoader 添加包

public abstract class AbstractEnhanceModel {

    public abstract byte[] enhance(String className, byte[] source);

}



import enhance.AbstractEnhanceModel;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;



public class SpringBootEnhance extends AbstractEnhanceModel {

    public static final SpringBootEnhance INSTANCE = new SpringBootEnhance();
    private SpringBootEnhance(){}

    @Override
    public byte[] enhance(String className, byte[] source) {
        ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
        ClassReader classReader = new ClassReader(source);

        AgentJarEnhance agentInitEnhance = new AgentJarEnhance(classWriter);
        classReader.accept(agentInitEnhance, ClassReader.SKIP_DEBUG);
        return classWriter.toByteArray();
    }
}


import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;

import static org.objectweb.asm.Opcodes.*;


public class AgentJarEnhance extends ClassVisitor {

    private ClassVisitor cv;

    public AgentJarEnhance(ClassVisitor classVisitor) {
        super(ASM4, classVisitor);
        this.cv = classVisitor;
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        // 新版接口转换为旧版接口
        if ("isPostProcessingClassPathArchives".equals(name)) {
            return null;
        }
        if ("postProcessClassPathArchives".equals(name)) {
            return null;
        }
        if ("genArchive".equals(name)) {
            return null;
        }
        return cv.visitMethod(access, name, descriptor, signature, exceptions);
    }

    @Override
    public void visitEnd(){
        isPostProcessingClassPathArchives();
        postProcessClassPathArchives();
        cv.visitEnd();
    }

    private void isPostProcessingClassPathArchives(){
        MethodVisitor methodVisitor = cv.visitMethod(ACC_PUBLIC, "isPostProcessingClassPathArchives", "()Z", null, null);
        methodVisitor.visitCode();
        Label label0 = new Label();
        methodVisitor.visitLabel(label0);
        methodVisitor.visitLineNumber(14, label0);
        methodVisitor.visitInsn(ICONST_1);
        methodVisitor.visitInsn(IRETURN);
        Label label1 = new Label();
        methodVisitor.visitLabel(label1);
        methodVisitor.visitLocalVariable("this", "Lorg/springframework/boot/loader/JarLauncher;", null, label0, label1, 0);
        methodVisitor.visitMaxs(1, 1);
        methodVisitor.visitEnd();
    }

    private void postProcessClassPathArchives(){
        MethodVisitor methodVisitor = cv.visitMethod(ACC_PROTECTED, "postProcessClassPathArchives", "(Ljava/util/List;)V", "(Ljava/util/List<Lorg/springframework/boot/loader/archive/Archive;>;)V", new String[]{"java/lang/Exception"});
        methodVisitor.visitCode();
        Label label0 = new Label();
        methodVisitor.visitLabel(label0);
        methodVisitor.visitLineNumber(42, label0);
        methodVisitor.visitVarInsn(ALOAD, 1);
        methodVisitor.visitInsn(ICONST_0);
        methodVisitor.visitVarInsn(ALOAD, 0);
        methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "org/springframework/boot/loader/JarLauncher", "getArchive", "()Lorg/springframework/boot/loader/archive/Archive;", false);
        methodVisitor.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(ILjava/lang/Object;)V", true);
        Label label1 = new Label();
        methodVisitor.visitLabel(label1);
        methodVisitor.visitLineNumber(43, label1);
        // 往classLoader添加jar包
        methodVisitor.visitMethodInsn(INVOKESTATIC, "agent/config/SupportConfig", "getAll", "()Ljava/util/List;", false);
        methodVisitor.visitVarInsn(ASTORE, 2);
        Label label2 = new Label();
        methodVisitor.visitLabel(label2);
        methodVisitor.visitLineNumber(44, label2);
        methodVisitor.visitVarInsn(ALOAD, 2);
        methodVisitor.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "iterator", "()Ljava/util/Iterator;", true);
        methodVisitor.visitVarInsn(ASTORE, 3);
        Label label3 = new Label();
        methodVisitor.visitLabel(label3);
        methodVisitor.visitFrame(Opcodes.F_APPEND, 2, new Object[]{"java/util/List", "java/util/Iterator"}, 0, null);
        methodVisitor.visitVarInsn(ALOAD, 3);
        methodVisitor.visitMethodInsn(INVOKEINTERFACE, "java/util/Iterator", "hasNext", "()Z", true);
        Label label4 = new Label();
        methodVisitor.visitJumpInsn(IFEQ, label4);
        methodVisitor.visitVarInsn(ALOAD, 3);
        methodVisitor.visitMethodInsn(INVOKEINTERFACE, "java/util/Iterator", "next", "()Ljava/lang/Object;", true);
        methodVisitor.visitTypeInsn(CHECKCAST, "java/lang/String");
        methodVisitor.visitVarInsn(ASTORE, 4);
        Label label5 = new Label();
        methodVisitor.visitLabel(label5);
        methodVisitor.visitLineNumber(45, label5);
        methodVisitor.visitTypeInsn(NEW, "org/springframework/boot/loader/jar/JarFile");
        methodVisitor.visitInsn(DUP);
        methodVisitor.visitTypeInsn(NEW, "java/io/File");
        methodVisitor.visitInsn(DUP);
        methodVisitor.visitVarInsn(ALOAD, 4);
        methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/io/File", "<init>", "(Ljava/lang/String;)V", false);
        methodVisitor.visitMethodInsn(INVOKESPECIAL, "org/springframework/boot/loader/jar/JarFile", "<init>", "(Ljava/io/File;)V", false);
        methodVisitor.visitVarInsn(ASTORE, 5);
        Label label6 = new Label();
        methodVisitor.visitLabel(label6);
        methodVisitor.visitLineNumber(46, label6);
        methodVisitor.visitVarInsn(ALOAD, 1);
        methodVisitor.visitTypeInsn(NEW, "org/springframework/boot/loader/archive/JarFileArchive");
        methodVisitor.visitInsn(DUP);
        methodVisitor.visitVarInsn(ALOAD, 5);
        methodVisitor.visitMethodInsn(INVOKESPECIAL, "org/springframework/boot/loader/archive/JarFileArchive", "<init>", "(Lorg/springframework/boot/loader/jar/JarFile;)V", false);
        methodVisitor.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true);
        methodVisitor.visitInsn(POP);
        Label label7 = new Label();
        methodVisitor.visitLabel(label7);
        methodVisitor.visitLineNumber(47, label7);
        methodVisitor.visitJumpInsn(GOTO, label3);
        methodVisitor.visitLabel(label4);
        methodVisitor.visitLineNumber(48, label4);
        methodVisitor.visitFrame(Opcodes.F_CHOP, 1, null, 0, null);
        methodVisitor.visitInsn(RETURN);
        Label label8 = new Label();
        methodVisitor.visitLabel(label8);
        methodVisitor.visitLocalVariable("jarFile", "Lorg/springframework/boot/loader/jar/JarFile;", null, label6, label7, 5);
        methodVisitor.visitLocalVariable("path", "Ljava/lang/String;", null, label5, label7, 4);
        methodVisitor.visitLocalVariable("this", "Lorg/springframework/boot/loader/JarLauncher;", null, label0, label8, 0);
        methodVisitor.visitLocalVariable("archives", "Ljava/util/List;", "Ljava/util/List<Lorg/springframework/boot/loader/archive/Archive;>;", label0, label8, 1);
        methodVisitor.visitLocalVariable("paths", "Ljava/util/List;", "Ljava/util/List<Ljava/lang/String;>;", label2, label8, 2);
        methodVisitor.visitMaxs(5, 6);
        methodVisitor.visitEnd();
    }
}


import java.util.ArrayList;
import java.util.List;

public class SupportConfig {

    private static final String KEY = "Governance.SupportConfig";
    private static final String SPLIT = ";";

    public static void add(String support) {
        String value = System.getProperty(KEY);
        if (null == value || value.length() < 1) {
            value = support;
        }else {
            value = value + SPLIT + support;
        }
        System.setProperty(KEY, value);
    }

    public static List<String> getAll(){
        String value = System.getProperty(KEY);
        if (null == value || value.length() < 1) {
            return new ArrayList<>();
        }
        List<String> list = new ArrayList<>();
        String[] values = value.split(SPLIT);
        for(String row : values) {
            list.add(row);
        }
        return list;
    }
}
草丛里的码农
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
我真不信，这年头还有人能懂SpringBoot的ClassLoader加载机制
m0_63213529的博客
10-24 996
SpringBoot的ClassLoader加载机制 在Spring Boot的嵌入式Web容器原理一节中，我们已经介绍了Spring Boot对Tomcat容器的加载过程，本节我们进一步讲解SpringBoot的ClassLoader加载机制。 熟悉Tomcat工作原理的人应该知道，Tomcat内部实现了自定义的类加载器，打破了Java的双亲委派机制，下面我们先看看什么是双亲委派机制。 双亲委派机制 双亲委派机制是指Java的类加载器收到一个类加载请求时，该类加载器首先会把请求委派给父类加
springboot自定义ClassLoader实现同一个jar支持多版本的使用场景【附源码】
新方之玉的IT专栏
11-22 3892
springboot自定义ClassLoader实现同一个jar支持多版本加载使用的方案，demo 源码验证在同一个系统既要支持hive3.1.0版本同时又要支持hive2.1.1版本的数据源功能;
springboot的类加载器（org.springframework.boot.loader）
EasyChillの博客
11-05 6570
类加载器的分类。 试验：使用maven打包 <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> &l
SpringBoot: 启动流程和类装载
最新发布
你若盛开，清风自来
06-09 1446
前面我们学过Spring定制了自己的可执行jar，将真正执行时需要的类和依赖放到BOOT-INF/classes、BOOT-INF/lib来，为了能够识别这些为止的源文件，Spring定制了自己类加载器，本节我们来讲解这个类加载器。
Spring Boot 自定义类加载器 重启项目
qq_35284533的博客
05-03 4328
URLClassLoader classLoader = (URLClassLoader) ClassLoader.getSystemClassLoader(); URLClassLoader urlClassLoader = new URLClassLoader(classLoader.getURLs(), null); //TODO 一定要设置线程上下文类加载器,因为Spring Boo...
【SpringBoot 基础系列】实现一个自定义配置加载器（应用篇）
程序员高级码农的博客
01-06 1034
【SpringBoot 基础系列】实现一个自定义配置加载器（应用篇）Spring 中提供了@Value注解，用来绑定配置，可以实现从配置文件中，读取对应的配置并赋值给成员变量；某些时候，我们的配置可能并不是在配置文件中，如存在 db/redis/其他文件/第三方配置服务，本文将手把手教你实现一个自定义的配置加载器，并支持@Value的使用姿势。
SpringBoot如何在普通类加载Spring容器
08-19
主要介绍了SpringBoot如何在普通类加载Spring容器,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
5.Spring Boot 启动类加载器
aa348699531的博客
06-21 589
1. CommandLineRunner 使用方式实现CommandLineRunner接口，重写run方法。 如果有多个那么可以使用@Order进行排序 @Component @Order(1) public class FirstCommandLineRunner implements Comm...
springboot使用自定义类加载器加载想要的bean
qq_43151016的博客
11-22 2616
spring注入外部feign接口，自定义类加载器加载类
spring自己的类加载器
远行的博客
09-13 2783
直接继承ClassLoader的有： JustAddTransformerClassLoader（用于测试），CandidateComponentsTestClassLoader（用于测试环境，控制被加载的资源），这是环境中用的是 DecoratingClassLoader 用于修饰类加载器，如重写类加载器和隐藏类加载器，提供对排除的包和类的通用处理。 子类OverridingClassLoade...
mapperlocations加载不到xml_聊聊Spring的IOC以及JVM的类加载
weixin_39612110的博客
12-18 1892
面试官看着应聘者，轻轻地说出了这句话 “小伙子，看你简历不错，那么，你是否能聊一下Spring的IOC”应聘者，看了下面试官，“嗯，IOC，称为控制反转，又叫DI 依赖注入”面试官追问，“详细聊聊吧”应聘者，焦虑的磕磕巴巴的说了不着四六的话，面试题简单的背了下名字，但是解释清楚就做不到了。写在前面一个面试场景开端，描述了一个尴尬的面试。其实，概念就是概念，无非是抽象出来的理论，我们要知其...
SpringBoot自定义starter实例代码
08-26
要自定义 Starter，我们需要参照 SpringBoot 的自动配置类，例如@WebMvcAutoConfiguration。自动配置类主要通过 @Configuration、@ConditionalOnXXX、@AutoConfigureOrder、@Bean 等注解来实现自动配置。我们可以...
springboot自定义类加载器
09-21
对于类加载器的使用，Spring Boot提供了默认的类加载器机制，但也可以通过自定义类加载器来实现一些特殊的需求。 自定义类加载器可以通过继承ClassLoader类来实现。在自定义类加载器中，我们可以重写findClass方法...
SpringBoot配置加载原理（自定义加载配置）
2401_84048416的博客
04-10 558
小编利用空余时间整理了一份《MySQL性能调优手册》，初衷也很简单，就是希望能够帮助到大家，减轻大家的负担和节省时间。关于这个，给大家看一份学习大纲（PDF）文件，每一个分支里面会有详细的介绍。这里都是以图片形式展示介绍，如要下载原文件以及更多的性能调优笔记（MySQL+Tomcat+JVM）！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！+JVM）！**《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》
springBoot自定义启动器
boy_10的博客
02-17 3849
一、starter的概念 starter 的理念： starter 会把所有用到的依赖都给包含进来，避免了开发者自己去引入依赖所带来的麻烦。 需要注意的是 不同的 starter 是为了解决不同的依赖，所以它们内部的实现可能会有很大的差异， 例如 jpa 的 starter 和 Redis 的 starter 可能实现就不一样，这是因为 starter 的本质在 synthesize ， 这是一层在逻辑层面的抽象，也许这种理念有点类似于Docker ，因为它们都是在做一个 “ 包装 ” 的操作。 sta
SpringBoot自定义启动器
weixin_58670730的博客
02-12 260
1.starter的作用 1.1 starter的理念 starter会把所有用到的依赖都给包含进来，避免了开发者自己去引入依赖所带来的麻烦。 需要注意的是 不同的starter是为了解决不同的依赖，所以它们内部的实现可能会有很大的差异， 例如jpa的starter和Redis的starter可能实现就不一样，这是因为starter的本质在于synthesize， 这是一 层在逻辑层面的抽象，也许这种理念有点类似于Docker，因为它们都是在做一个“包装”的操作。 1.2 starter的实现 虽然
java自定义类加载器，Springboot热部署，aop拦截，文件监听
hello_qaz123的博客
09-24 1023
java自定义类加载器，Springboot热部署
Spring 源码解析之 通过类加载器获取资源集合
Java持续实践
03-06 551
文章目录提取标记对象编写获取某个包下的类的集合工具类 提取标记对象 实现思路: 指定对象范围, 获取范围内的所有类 遍历所有类, 获取被注解标记的类并加载进容器里. 编写获取某个包下的类的集合工具类 获取某个包下的类集合 : 1. 获取到类加载器: 目的: 获取项目发布的实际路径 . 不同的系统表示路径的方法不同. 如果是war或jar包就找不到jar包. 类加载器: ClassLoader ClassLoader从字节码文件中读取字节码, 并转换为java.lang.Class一个类实例, 并存储
Spring IOC之资源加载器
BushRo
08-11 1184
ResourceLoader 中最核心的方法为 getResource(),它根据提供的 location 返回相应的 Resource，而 DefaultResourceLoader 对该方法提供了核心实现(它的其它子类都没有提供覆盖该方法，所以可以断定ResourceLoader 的资源加载策略就封装 DefaultResourceLoader中)返回 ClassLoader 实例，对于想要获取 ResourceLoader 使用的 ClassLoader 用户来说，可以直接调用该方法来获取。.....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值