boot - spring boot jar 启动过程

最新推荐文章于 2023-07-30 00:14:21 发布
最新推荐文章于 2023-07-30 00:14:21 发布
阅读量685 收藏 6
点赞数
分类专栏： spring boot 文章标签： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013887008/article/details/118268361
版权

boot - spring boot jar 启动过程

目录结构

一般的，一个sprign boot package jar 包之后的 如下，这里以 boot-mvc-0.0.1-SNAPSHOT.jar 为例子

.
├── BOOT-INF
│   ├── classes    # 当前生成编译生成的 class
│   └── lib        # 依赖的第三方jar包 目录
├── META-INF
│   ├── MANIFEST.MF   # 打包的一些类信息
│   └── maven
└── org.springframework.boot.loader
    ├── archive
    ├── ClassPathIndexFile.class
    ├── data
    ├── ExecutableArchiveLauncher.class
    ├── jar
    ├── JarLauncher.class           # jar 包启动类
    ├── jarmode
    ├── LaunchedURLClassLoader$DefinePackageCallType.class
    ├── LaunchedURLClassLoader$UseFastConnectionExceptionsEnumeration.class
    ├── LaunchedURLClassLoader.class
    ├── Launcher.class
    ├── MainMethodRunner.class
    ├── PropertiesLauncher$1.class
    ├── PropertiesLauncher$ArchiveEntryFilter.class
    ├── PropertiesLauncher$ClassPathArchives.class
    ├── PropertiesLauncher$PrefixMatchingArchiveFilter.class
    ├── PropertiesLauncher.class
    ├── util
    └── WarLauncher.class         # war 包启动类

在这里插入图片描述

MANIFEST.MF

这个文件主要记录和描述了 Main-Class, Start-Class等等

Manifest-Version: 1.0
Created-By: Maven Jar Plugin 3.2.0
Build-Jdk-Spec: 15
Implementation-Title: boot-mvc
Implementation-Version: 0.0.1-SNAPSHOT
Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.x.z.bootmvc.BootMvcApplication
Spring-Boot-Version: 2.4.0
Spring-Boot-Classes: BOOT-INF/classes/    # 当前工程编译生成 class 目录 
Spring-Boot-Lib: BOOT-INF/lib/            # 该jar 包依赖的第三方 jar
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Spring-Boot-Layers-Index: BOOT-INF/layers.idx

spring boot 是如何被加载启动的

当我们运行 java -jar boot-mvc-0.0.1-SNAPSHOT.jar 的时候就能启动服务，那这个过程是如何触发和加载的？

  • 启动的入口在哪里
  • 怎么加载到这些依赖的jar包

带着这些问题，我们继续看

JarLauncher.java

顾名思义，这个应该就是启动 boot-mvc.jar 的主类

public class JarLauncher extends ExecutableArchiveLauncher {
  private static final String DEFAULT_CLASSPATH_INDEX_LOCATION = "BOOT-INF/classpath.idx";
  
  static final Archive.EntryFilter NESTED_ARCHIVE_ENTRY_FILTER;
  
  static {
    NESTED_ARCHIVE_ENTRY_FILTER = (entry -> entry.isDirectory()
     ? entry.getName().equals("BOOT-INF/classes/") : entry.getName().startsWith("BOOT-INF/lib/"));
  }
  
  public JarLauncher() {}
  
  protected JarLauncher(Archive archive) {
    super(archive);
  }
  
  protected ClassPathIndexFile getClassPathIndex(Archive archive) throws IOException {
    if (archive instanceof org.springframework.boot.loader.archive.ExplodedArchive) {
      String location = getClassPathIndexFileLocation(archive);
      return ClassPathIndexFile.loadIfPossible(archive.getUrl(), location);
    } 
    return super.getClassPathIndex(archive);
  }
  
  private String getClassPathIndexFileLocation(Archive archive) throws IOException {
    Manifest manifest = archive.getManifest();
    Attributes attributes = (manifest != null) ? manifest.getMainAttributes() : null;
    String location = (attributes != null) ? attributes.getValue("Spring-Boot-Classpath-Index") : null;
    return (location != null) ? location : "BOOT-INF/classpath.idx";
  }
  
  protected boolean isPostProcessingClassPathArchives() {
    return false;
  }
  
  protected boolean isSearchCandidate(Archive.Entry entry) {
    return entry.getName().startsWith("BOOT-INF/");
  }
  
  protected boolean isNestedArchive(Archive.Entry entry) {
    return NESTED_ARCHIVE_ENTRY_FILTER.matches(entry);
  }
  
  public static void main(String[] args) throws Exception {
    (new JarLauncher()).launch(args);
  }
}
ExecutableArchieveLauncher.java
public abstract class ExecutableArchiveLauncher extends Launcher {
  private static final String START_CLASS_ATTRIBUTE = "Start-Class";
  
  protected static final String BOOT_CLASSPATH_INDEX_ATTRIBUTE = "Spring-Boot-Classpath-Index";
  
  private final Archive archive;
  
  private final ClassPathIndexFile classPathIndex;
  
  public ExecutableArchiveLauncher() {
    try {
      this.archive = createArchive();
      this.classPathIndex = getClassPathIndex(this.archive);
    } catch (Exception ex) {
      throw new IllegalStateException(ex);
    } 
  }
  
  protected ExecutableArchiveLauncher(Archive archive) {
    try {
      this.archive = archive;
      this.classPathIndex = getClassPathIndex(this.archive);
    } catch (Exception ex) {
      throw new IllegalStateException(ex);
    } 
  }
  
  protected ClassPathIndexFile getClassPathIndex(Archive archive) throws IOException {
    return null;
  }
  
  protected String getMainClass() throws Exception {
    Manifest manifest = this.archive.getManifest();
    String mainClass = null;
    if (manifest != null)
      mainClass = manifest.getMainAttributes().getValue("Start-Class"); 
    if (mainClass == null)
      throw new IllegalStateException("No 'Start-Class' manifest entry specified in " + this); 
    return mainClass;
  }
  
  protected ClassLoader createClassLoader(Iterator<Archive> archives) throws Exception {
    List<URL> urls = new ArrayList<>(guessClassPathSize());
    while (archives.hasNext())
      urls.add(((Archive)archives.next()).getUrl()); 
    if (this.classPathIndex != null)
      urls.addAll(this.classPathIndex.getUrls()); 
    return createClassLoader(urls.<URL>toArray(new URL[0]));
  }
  
  private int guessClassPathSize() {
    if (this.classPathIndex != null)
      return this.classPathIndex.size() + 10; 
    return 50;
  }
  
  protected Iterator<Archive> getClassPathArchivesIterator() throws Exception {
    Archive.EntryFilter searchFilter = this::isSearchCandidate;
    Iterator<Archive> archives = this.archive.getNestedArchives(searchFilter, entry -> 
        (isNestedArchive(entry) && !isEntryIndexed(entry)));
    if (isPostProcessingClassPathArchives())
      archives = applyClassPathArchivePostProcessing(archives); 
    return archives;
  }
  
  private boolean isEntryIndexed(Archive.Entry entry) {
    if (this.classPathIndex != null)
      return this.classPathIndex.containsEntry(entry.getName()); 
    return false;
  }
  
  private Iterator<Archive> applyClassPathArchivePostProcessing
  					(Iterator<Archive> archives) throws Exception {
    List<Archive> list = new ArrayList<>();
    while (archives.hasNext())
      list.add(archives.next()); 
    postProcessClassPathArchives(list);
    return list.iterator();
  }
  
  protected boolean isSearchCandidate(Archive.Entry entry) {
    return true;
  }
  
  protected boolean isPostProcessingClassPathArchives() {
    return true;
  }
  
  protected void postProcessClassPathArchives(List<Archive> archives) throws Exception {}
  
  protected boolean isExploded() {
    return this.archive.isExploded();
  }
  
  protected final Archive getArchive() {
    return this.archive;
  }
  
  protected abstract boolean isNestedArchive(Archive.Entry paramEntry);
}
Lanucher.java
public abstract class Launcher {
  private static final String JAR_MODE_LAUNCHER
  				 = "org.springframework.boot.loader.jarmode.JarModeLauncher";
  
  protected void launch(String[] args) throws Exception {
    if (!isExploded())
      JarFile.registerUrlProtocolHandler(); 
    ClassLoader classLoader = createClassLoader(getClassPathArchivesIterator());
    String jarMode = System.getProperty("jarmode");
    String launchClass = (jarMode != null && !jarMode.isEmpty()) ? 
    			"org.springframework.boot.loader.jarmode.JarModeLauncher" : getMainClass();
    launch(args, launchClass, classLoader);
  }
  
  @Deprecated
  protected ClassLoader createClassLoader(List<Archive> archives) throws Exception {
    return createClassLoader(archives.iterator());
  }
  
  protected ClassLoader createClassLoader(Iterator<Archive> archives) throws Exception {
    List<URL> urls = new ArrayList<>(50);
    while (archives.hasNext())
      urls.add(((Archive)archives.next()).getUrl()); 
    return createClassLoader(urls.<URL>toArray(new URL[0]));
  }
  
  protected ClassLoader createClassLoader(URL[] urls) throws Exception {
    return new LaunchedURLClassLoader(isExploded(), getArchive(), urls, getClass().getClassLoader());
  }
  
  protected void launch(String[] args, String launchClass,
  							 ClassLoader classLoader) throws Exception {
    Thread.currentThread().setContextClassLoader(classLoader);
    createMainMethodRunner(launchClass, args, classLoader).run();
  }
  
  protected MainMethodRunner createMainMethodRunner(String mainClass,
  								 String[] args, ClassLoader classLoader) {
    return new MainMethodRunner(mainClass, args);
  }
  
  protected abstract String getMainClass() throws Exception;
  
  protected Iterator<Archive> getClassPathArchivesIterator() throws Exception {
    return getClassPathArchives().iterator();
  }
  
  @Deprecated
  protected List<Archive> getClassPathArchives() throws Exception {
    throw new IllegalStateException("Unexpected call to getClassPathArchives()");
  }
  
  protected final Archive createArchive() throws Exception {
    ProtectionDomain protectionDomain = getClass().getProtectionDomain();
    CodeSource codeSource = protectionDomain.getCodeSource();
    URI location = (codeSource != null) ? codeSource.getLocation().toURI() : null;
    String path = (location != null) ? location.getSchemeSpecificPart() : null;
    if (path == null)
      throw new IllegalStateException("Unable to determine code source archive"); 
    File root = new File(path);
    if (!root.exists())
      throw new IllegalStateException("Unable to determine code source archive from " + root); 
    return root.isDirectory() ? 
    		(Archive)new ExplodedArchive(root) : (Archive)new JarFileArchive(root);
  }
  
  protected boolean isExploded() {
    return false;
  }
  
  protected Archive getArchive() {
    return null;
  }
}
MainMethodRunner

public class MainMethodRunner {
  private final String mainClassName;
  
  private final String[] args;
  
  public MainMethodRunner(String mainClass, String[] args) {
    this.mainClassName = mainClass;
    this.args = (args != null) ? (String[])args.clone() : null;
  }
  
  public void run() throws Exception {
    Class<?> mainClass = Class.forName(this.mainClassName, false, 
    							Thread.currentThread().getContextClassLoader());
    Method mainMethod = mainClass.getDeclaredMethod("main", new Class[] { String[].class });
    mainMethod.setAccessible(true);
    mainMethod.invoke(null, new Object[] { this.args });
  }
}
启动流程

  • 根据 MANIFEST.MF 文件找到 /BOOT-INF/classes 和 /BOOT-INF/lib 目录，并加载

  • 创建 ClassLoader，此时为 LaunchedURLClassLoader

  • 根据 MANIFEST.MF 文件找到 Start-Class 属性的 主类，这里是 com.x.z.bootmvc.BootMvcApplication

  • 设置当前线程上下文加载器为 ClassLoader

  • 从当前线程获取ClassLoader,即 LaunchedURLClassLoader， 加载 mainClass(即 start-class)

  • 利用反射执行 mainClass 中的 main 方法， 即执行 om.x.z.bootmvc.BootMvcApplication 中的 main 方法

WarLauncher


public class WarLauncher extends ExecutableArchiveLauncher {
  public WarLauncher() {}
  
  protected WarLauncher(Archive archive) {
    super(archive);
  }
  
  protected boolean isPostProcessingClassPathArchives() {
    return false;
  }
  
  protected boolean isSearchCandidate(Archive.Entry entry) {
    return entry.getName().startsWith("WEB-INF/");
  }
  
  public boolean isNestedArchive(Archive.Entry entry) {
    if (entry.isDirectory())
      return entry.getName().equals("WEB-INF/classes/"); 
    return (entry.getName().startsWith("WEB-INF/lib/") ||
    			 entry.getName().startsWith("WEB-INF/lib-provided/"));
  }
  
  public static void main(String[] args) throws Exception {
    (new WarLauncher()).launch(args);
  }
}

加载 war 包的过程大同小异，只是把加载目录换成 WEB-INF/classes 和 WEB-INF/lib/ 目录

重生之我是一名程序员
关注
专栏目录
开源推荐：Java服务管理、诊断平台——Jarboot
baidu_36206948的博客
11-17 2820
Jarboot服务管理主界面
springboot jar是如何启动的
最新发布
不知跬步无至千里
08-20 563
我们先来看一个项目的打完包后的当jar的方式启动时，走的是。
SpringBoot启动过程原理一
热门推荐
RainSun
06-06 5万+
1.1 Springboot启动： @SpringBootApplication public class ServerApplication { public static void main(String[] args) { SpringApplication.run(ServerApplication.class,args); } } 从上面代码看，调用了...
springboot-jar包启动流程分析
OLDNOOP-JAVA学习
08-14 191
springboot打成可执行的FAT Jar, 执行的流程如下代码示例所示 按照springboot的源代码调用流程，使用了springboot的一套java类，完整展示 springboot的jar包启动过程 另有 SpringApplication启动流程，再在新的篇章中描述 ...
jarboot
02-12
jarboot
bootjar与jar区别
LMY18238816299的博客
09-10 1022
bootjar与jar区别
druid-spring-boot-starter-1.2.8.jar
04-04
druid-spring-boot-starter-1.2.8.jar
jasypt-spring-boot-starter-2.1.1.jar
02-25
java运行依赖jar包
mybatis-spring-boot-starter-3.0.1.jar
04-19
MyBatis Spring Boot Starter.jar 各个版本，免费下载。 MyBatis Spring Boot Starter.jar 起步依赖和自动配置。
jasypt-spring-boot-starter 3.0.5依赖的pom及jar
05-19
这样，Spring Boot在启动时会自动识别并处理这些加密的配置。 总的来说，jasypt-spring-boot-starter 3.0.5为Java开发者提供了一个高效且安全的方式来管理和使用加密数据，简化了Spring Boot应用中的安全实践。通过...
Spring-boot jar Spring-boot所需jar包
03-28
Spring-boot所需jar包 Spring-boot所需jar包 附带 springmvc.jar附带 springmvc.jar附带 springmvc.jar
普通spring boot jar包部署为windows service
03-03
普通spring boot jar包部署为windows service,其中只要执行spring-boot-daemon-sample.exe install/uninstall
springboot 多项目打包 jar包教程,包含源代码
11-14
springboot 多项目打包 jar包,包含源代码
spring-boot-starter-web-2.7.13.jar
04-21
spring-boot-starter-web-1.0.0.RELEASE.jar 各个版本，免费下载 spring-boot-starter-web.RELEASE.jar 各个版本，免费下载 spring-boot-starter-web.jar 各个版本，免费下载 如果不能免费下载，关注我，评论区联系...
Java 进程启停及诊断 Jarboot大改版、焕然一新
baidu_36206948的博客
11-23 1314
焕然一新的分组界面
SpringBoot使用PropertiesLauncher加载外部jar包
Brucelwl的博客
07-30 2734
使用SpringBoot的PropertiesLauncher可以优先加载外部的jar文件, 这样可以在程序运行前替换jar包, 官方文档: Launching Executable Jars 在启用应用程序时通过指定外部jar的目录, 再启动, 访问接口返回2.0.0版本, 说明包替换成功 指定PropertiesLauncher启动类执行 可以正常只加载2.0.0版本中的实现类, 这个符合预期 访问资源文件, 会发现本应只从2.0.0版本中加载文件, 结果1.0.0版本中的也被加载了
springboot package 生成的jar包 中文乱码
sword_happy的博客
03-21 1815
springboot package 生成的jar包 中文乱码 背景:使用idea生成的jar包在本地cmd窗口执行的时候出现了中文乱码; 需要注意几点: IDEA 设置的编码方式 使用maven打包(spring-boot-maven-plugin)插件配置 打包完成生成的jar包,使用增加-Dfile.encoding=UTF-8参数 java -Dfile.encoding...
Android 创建 System Bootjar
airuan1992的专栏
07-26 1314
1.引入 本文主要讲解，针对Android源码开发，如何将自己的java library添加到Android系统的boot jar中 本文在编写的时候，针对的Android平台为Android Q （Android 10） 2.创建jar library仓库 该仓库主要包括以下两个动作： 将src中的java代码编译成jar包 编写permission文件，并且复制到system/etc下 2.1 编写BP文件 在过去的Android平台中，Bootjar是可以通过mk文件编写的，但是在And
spring-ai-redis-spring-boot-starter jar
06-19
Spring-AI-Redis-Spring-Boot-Starter是一个Spring Boot的启动器库，专为使用人工智能和机器学习功能与Redis数据库集成而设计。它简化了在Spring Boot应用中集成Redis的过程，并可能提供了对高级数据结构、缓存、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值