SpringBoot为何可以使用Jar包启动详解

目录
  • 引言
  • Spring Boot 打包插件
  • SpringBoot FatJar 的组织结构
  • MAINFEST.MF 元信息
  • 启动原理
  • 源码分析
    • JarLauncher
    • Launcher
    • PropertiesLauncher
    • MainMethodRunner
  • 总结

引言

很多初学者会比较困惑,Spring Boot 是如何做到将应用代码和所有的依赖打包成一个独立的 Jar 包,因为传统的 Java 项目打包成 Jar 包之后,需要通过 -classpath 属性来指定依赖,才能够运行。我们今天就来分析讲解一下 SpringBoot 的启动原理。

Spring Boot 打包插件

Spring Boot 提供了一个名叫 spring-boot-maven-plugin 的 maven 项目打包插件,如下:

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

可以方便的将 Spring Boot 项目打成 jar 包。 这样我们就不再需要部署 Tomcat 、Jetty等之类的 Web 服务器容器啦。

我们先看一下 Spring Boot 打包后的结构是什么样的,打开 target 目录我们发现有两个jar包:

其中,springboot-0.0.1-SNAPSHOT.jar 是通过 Spring Boot 提供的打包插件采用新的格式打成 Fat Jar,包含了所有的依赖;

springboot-0.0.1-SNAPSHOT.jar.original 则是Java原生的打包方式生成的,仅仅只包含了项目本身的内容。

SpringBoot FatJar 的组织结构

我们将 Spring Boot 打的可执行 Jar 展开后的结构如下所示:

  • BOOT-INF目录:包含了我们的项目代码(classes目录),以及所需要的依赖(lib 目录);
  • META-INF目录:通过 MANIFEST.MF 文件提供 Jar包的元数据,声明了 jar 的启动类;
  • org.springframework.boot.loader :Spring Boot 的加载器代码,实现的 Jar in Jar 加载的魔法源。

我们看到,如果去掉BOOT-INF目录,这将是一个非常普通且标准的Jar包,包括元信息以及可执行的代码部分,其/META-INF/MAINFEST.MF指定了Jar包的启动元信息,org.springframework.boot.loader 执行对应的逻辑操作。

MAINFEST.MF 元信息

元信息内容如下所示:

Manifest-Version: 1.0
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Implementation-Title: springboot
Implementation-Version: 0.0.1-SNAPSHOT
Spring-Boot-Layers-Index: BOOT-INF/layers.idx
Start-Class: com.listenvision.SpringbootApplication
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.0
Main-Class: org.springframework.boot.loader.JarLauncher

它相当于一个 Properties 配置文件,每一行都是一个配置项目。重点来看看两个配置项:

  • Main-Class 配置项:Java 规定的 jar 包的启动类,这里设置为 spring-boot-loader 项目的 JarLauncher 类,进行 Spring Boot 应用的启动。
  • Start-Class 配置项:Spring Boot 规定的主启动类,这里设置为我们定义的 Application 类。
  • Spring-Boot-Classes 配置项:指定加载应用类的入口。
  • Spring-Boot-Lib 配置项: 指定加载应用依赖的库。

启动原理

Spring Boot 的启动原理如下图所示:

源码分析

JarLauncher

JarLauncher 类是针对 Spring Boot jar 包的启动类, 完整的类图如下所示:

其中的 WarLauncher 类,是针对 Spring Boot war 包的启动类。 启动类 org.springframework.boot.loader.JarLauncher 并非为项目中引入类,而是 spring-boot-maven-plugin 插件 repackage 追加进去的。

接下来我们先来看一下 JarLauncher 的源码,比较简单,如下图所示:

public class JarLauncher extends ExecutableArchiveLauncher {
    private static final String DEFAULT_CLASSPATH_INDEX_LOCATION = "BOOT-INF/classpath.idx";
    static final EntryFilter NESTED_ARCHIVE_ENTRY_FILTER = (entry) -> {
        if (entry.isDirectory()) {
            return entry.getName().equals("BOOT-INF/classes/");
        }
        return entry.getName().startsWith("BOOT-INF/lib/");
    };

    public JarLauncher() {
    }

    protected JarLauncher(Archive archive) {
        super(archive);
    }

    @Override
    protected ClassPathIndexFile getClassPathIndex(Archive archive) throws IOException {
        // Only needed for exploded archives, regular ones already have a defined order
        if (archive instanceof 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(BOOT_CLASSPATH_INDEX_ATTRIBUTE) : null;
        return (location != null) ? location : DEFAULT_CLASSPATH_INDEX_LOCATION;
    }

    @Override
    protected boolean isPostProcessingClassPathArchives() {
        return false;
    }

    @Override
    protected boolean isSearchCandidate(Archive.Entry entry) {
        return entry.getName().startsWith("BOOT-INF/");
    }

    @Override
    protected boolean isNestedArchive(Archive.Entry entry) {
        return NESTED_ARCHIVE_ENTRY_FILTER.matches(entry);
    }

    public static void main(String[] args) throws Exception {
        //调用基类 Launcher 定义的 launch 方法
        new JarLauncher().launch(args);
    }
}

主要看它的 main 方法,调用的是基类 Launcher 定义的 launch 方法,而 Launcher 是ExecutableArchiveLauncher 的父类。下面我们来看看Launcher基类源码:

Launcher

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()) ? JAR_MODE_LAUNCHER : 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(archives.next().getUrl());
        }
        return createClassLoader(urls.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() ? new ExplodedArchive(root) : new JarFileArchive(root));
    }

    protected boolean isExploded() {
        return false;
    }

    protected Archive getArchive() {
        return null;
    }
}
  • launch 方法会首先创建类加载器,而后判断是否 jar 是否在 MANIFEST.MF 文件中设置了 jarmode 属性。
  • 如果没有设置,launchClass 的值就来自 getMainClass() 返回,该方法由PropertiesLauncher子类实现,返回 MANIFEST.MF 中配置的 Start-Class 属性值。
  • 调用 createMainMethodRunner 方法,构建一个 MainMethodRunner 对象并调用其 run 方法。

PropertiesLauncher

@Override
protected String getMainClass() throws Exception {
    //加载 jar包 target目录下的  MANIFEST.MF 文件中 Start-Class配置,找到springboot的启动类
    String mainClass = getProperty(MAIN, "Start-Class");
    if (mainClass == null) {
        throw new IllegalStateException("No '" + MAIN + "' or 'Start-Class' specified");
    }
    return mainClass;
}

MainMethodRunner

目标类main方法的执行器,此时的 mainClassName 被赋值为 MANIFEST.MF 中配置的 Start-Class 属性值,也就是 com.listenvision.SpringbootApplication,之后便是通过反射执行 SpringbootApplication 的 main 方法,从而达到启动 Spring Boot 的效果。

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

总结

  • jar 包类似于 zip 压缩文件,只不过相比 zip 文件多了一个 META-INF/MANIFEST.MF 文件,该文件在构建 jar 包时自动创建。
  • Spring Boot 提供了一个插件 spring-boot-maven-plugin ,用于把程序打包成一个可执行的jar包。
  • 使用 java -jar 启动 Spring Boot 的 jar 包,首先调用的入口类是 JarLauncher,内部调用 Launcher 的 launch 后构建 MainMethodRunner 对象,最终通过反射调用 SpringbootApplication 的 main 方法实现启动效果。

到此这篇关于SpringBoot为何可以使用Jar包启动的文章就介绍到这了,更多相关SpringBoot用Jar包启动内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • SpringBoot工程搭建打包、启动jar包和war包的教程图文详解

    工程搭建 1.File->new->project: 2.选择"Spring Initializr",点击next:(jdk1.8默认即可) 3.完善项目信息,组名可不做修改,项目名可做修改:最终建的项目名为:test,src->main->java下包名会是:com->example->test:点击next: 4.Web下勾选Spring Web Start,(网上创建springboot项目多是勾选Web选项,而较高版本的Springboot没

  • 解决spring-boot 打成jar包后 启动时指定参数无效的问题

    spring-boot打成jar启动时指定参数无效 今天后台项目进行修改,使用spring.profiles来指定启动时使用的配置文件. 在项目中添加好配置文件后使用java -jar .\base-exec.jar --spring.profiles.active=dev --server.port=9121启动时参数注入不进去. 检查配置文件书写的规则,这里把规则说一下 我们在开发Spring Boot应用时,通常同一套程序会被应用和安装到几个不同的环境,比如:开发.测试.生产等.其中每个环

  • SpringBoot项目运行jar包启动的步骤流程解析

    SpringBoot项目在开发中,方便快捷,有一点原因就是SpringBoot项目可以打jar包运行:把jar包直接扔服务器上,然后运行jar包就能访问项目接口了.下面介绍SpringBoot项目打jar包运行的步骤流程: 一.我们所熟悉的是在开发环境下,直接用开发工具来运行那个启动类,然后就能启动这个项目: 开发环境下启动项目 二. SpringBoot项目打jar包方法: [1]在cmd界面中,进入项目的本地存储地址 cmd命令下进入项目地址 [2]运行maven的打包命令,mvn clea

  • Spring Boot项目中jar包在服务器上启动的正确姿势

    关于 一般上来说,我们在服务器上启动一个jar,最简单的方式就是java -jar xx.jar,虽然这种方式简单但有时候我们的场景需要更多,例如常驻后台运行,在命令行窗口关闭的时候不中断项目,指定端口,并且输出日志到文件中等.所以这个时候我们通常会采用脚本启动和关闭项目,方便项目的统一管理. 脚本启动和关闭的案例 1.启动脚本 nohup java -jar ../webapp/xxx.jar --server.port=9002 >> ../logs/xxx.log & tail

  • SpringBoot为何可以使用Jar包启动详解

    目录 引言 Spring Boot 打包插件 SpringBoot FatJar 的组织结构 MAINFEST.MF 元信息 启动原理 源码分析 JarLauncher Launcher PropertiesLauncher MainMethodRunner 总结 引言 很多初学者会比较困惑,Spring Boot 是如何做到将应用代码和所有的依赖打包成一个独立的 Jar 包,因为传统的 Java 项目打包成 Jar 包之后,需要通过 -classpath 属性来指定依赖,才能够运行.我们今天就

  • JMeter导入自定义的Jar包的详解教程

    1.简介 原计划这一篇是介绍前置处理器的基础知识的,结果由于许多小伙伴或者童鞋们在微信和博客园的短消息中留言问如何引入自己定义的Jar包呢???我一一回复告诉他们和引入插件的Jar包一样的道理,一通百通.但是感觉他们还是很迷糊很迷惘,因此在这里穿插一篇导入自定义的Jar包.还有另外一个原因就是前置处理器会用到这个自定义的Jar包. 2.环境准备 (1)Eclipse 我们要引入自定义的Jar包,所以你需要一个可以编写脚本生成Jar的工具,当然了你可以选择其他的开发工具,宏哥这里选择Eclipse

  • Lombok插件安装(IDEA)及配置jar包使用详解

    点击进入Lombok官网下载Lombok jar包 使用Lombok可能需要注意的地方 (1).当你的IDE是Idea时,要注意你的Idea是支持Lombok的,如果不支持请更换高版本尝试(这里采用2018 3.3). (2).在使用Lombok时,你的编辑器可能会报错,这时请在你的IDE中安装Lombok插件(如果使用的Idea则直接搜索Lombok插件,选择星级最高的,直接安装就是,其他Ide类同). (3).参数的处理往往都是根据项目需求来进行,请妥善处理参数. (4).如果你无法访问Lo

  • Android Studio导入jar包过程详解

    使用开源框架是,可以直接复制源代码到自己的项目(本人在Android Studio中操作报R程序包不存在),也可以使用jar包,下面记录一下今天使用SmartImageView.jar的过程,不记录SmartImageView的用法. 我新建了项目,用来完成今天的笔记,SmartImageView.jar可以在http://loopj.com/android-smart-image-view/下载 将下载的jar包拷贝至libs目录下 然后右键,add as library...会弹出这么个界面

  • 使用jenkins+maven+git发布jar包过程详解

    1.新建maven项目 2.配置git仓库 3.在远程机器上执行脚本,这一步需要先配置能ssh远程机器 a.安装publish over ssh 插件 b.jenkins----配置----config system,配置远程连接主机账号密码 高级那边配置密码 c.配置Send files or execute commands over SSH after the build runs 4.构建jar包 5.前面Send files or execute commands over SSH a

  • SpringBoot应用jar包启动原理详解

    目录 1.maven打包 2.Jar包目录结构 3.可执行Jar(JarLauncher) 4.WarLauncher 5.总结 1.maven打包 Spring Boot项目的pom.xml文件中默认使用spring-boot-maven-plugin插件进行打包: <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>s

  • 详解docker部署SpringBoot及替换jar包的方法

    关于docker的安装和使用,可以看看之前这两篇文章.docker kubernetes dashboard安装部署详细介绍和Docker如何使用link建立容器之间的连接.这篇文章主要介绍如何在docker上部署springboot项目.关于如何创建springboot项目可以看看这篇文章IDEA上面搭建一个SpringBoot的web-mvc项目遇到的问题 本文主要介绍docker部署springboot的三种方式,分别是:入门方式.jar包替换部署的方式和脚本部署方式,一步步来手把手教程.

  • 详解springboot中的jar包部署步骤

    eclipse中: 1.单击整个项目 run as - maven clean - maven install 2.找到项目所在的路径 找到所有的jar包 3.把jar包放到linux对应的文件夹 linux中部署项目: 1.查看jar是否在运行中 ps -ef | grep SpliderWeb-0.0.1-SNAPSHOT.jar 2.有运行的jar包 杀死对应的进程 kill 进程号 3.无运行的jar包 部署项目 java -jar SpliderWeb-0.0.1-SNAPSHOT.j

  • SpringBoot项目如何打war包问题详解

    1.pom.xml配置修改 <packaging>jar</packaging> //修改为 <packaging>war</packaging> 2.pom文件添加如些依赖 <!--添加servlet-api的依赖,用来打war包 --> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</

随机推荐