SpringBoot工程打包后执行Java -Jar就能启动的步骤原理

 更新时间:2023年05月15日 09:43:50   作者:softbook  
这篇文章主要介绍了SpringBoot工程打包后为何执行Java -Jar就能启动,本文结合实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下

本文主要分享SpringBoot工程项目如何打包成一个可直接通过java -jar执行的jar,并且简单分析其启动步骤原理。

1.SpringBoot如何打包成一个可执行jar?

SpringBoot打包成成一个可执行jar需要依赖一个maven打包插件spring-boot-maven-plugin,如下所示在pom文件结尾的build节点添加依赖,同时将src/main/javasrc/main/resources打入jar里面。

 	<build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

此时再执行maven package打包成jar(最后打包完成在target目录下):

此时我们直接通过cmd控制台执行命令:java -jar boot-first-1.0.0-SNAPSHOT.jar 可以看到启动成功。

相关日志已经打印出来了,此时我们再通过postman验证一下编码中的接口是否生效:

程序中的接口代码如下:

2.SpringBoot打包成的jar为何可以直接Java -jar执行?

java程序的入口是main方法 ,如果一个jar能够通过java -jar执行起来,肯定离不开main方法。那springboot通过spring-boot-maven-plugin插件打包成的jar通常称为fat jar,里面不仅仅包含了程序代码还包括其他引用的依赖的jar。那这个fat jar的main方法入口在哪儿呢?我们通过解压该jar可以看到,在META-INF下的有一个MANIFEST.MF文件:

其中MANIFEST.MF中内容如下,其中比较重要的几行信息:

Start-Class: com.xren.bootfirst.BootFirstApplication ##程序开始类
Spring-Boot-Classes: BOOT-INF/classes/        ##加载的class
Spring-Boot-Lib: BOOT-INF/lib/   ##加载的内部jar位置
Main-Class: org.springframework.boot.loader.JarLauncher  ## boot启动类

综上可知,SpringBoot项目通过引入打包插件spring-boot-maven-plugin生成特定的主清单文件MANIFEST.MF,其中包含了程序的入口类和相关启动依赖。

3.一窥SpringBoot初启动

通用的jar包如果能被java -jar执行,只需要其MANIFEST.MF文件中有 Main-Class配置项即可。而此处SpringBoot的jar中的MANIFEST.MF文件里面不仅仅包含Main-Class 还有Start-Class、Spring-Boot-Classes、Spring-Boot-Lib等相关信息,那他们是如何运行的呢?我们还是要回到该jar主类org.springframework.boot.loader.JarLauncher来一窥究竟。

查看org.springframework.boot.loader.JarLauncher类需要pom引入spring-boot-loader,如下:

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-loader</artifactId>
            <version>2.2.7.RELEASE</version>
	</dependency>

引入后其中JarLaunche类代码如下,它包含一个main方法,并且继承一个父类ExecutableArchiveLauncher。

public class JarLauncher extends ExecutableArchiveLauncher {
    static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";
    static final String BOOT_INF_LIB = "BOOT-INF/lib/";
    public JarLauncher() {
    }
    protected JarLauncher(Archive archive) {
        super(archive);
    }
    protected boolean isNestedArchive(Entry entry) {
        return entry.isDirectory() ? entry.getName().equals("BOOT-INF/classes/") : entry.getName().startsWith("BOOT-INF/lib/");
    }
    public static void main(String[] args) throws Exception {
        (new JarLauncher()).launch(args);
    }
}

从main方法进入我们需要关注一个launch方法,其中的三行

  • 注册一个jar处理类
  • 获取一个类加载器(通过路径加载lib和classs)
  • 通过获取主启动类和类加载器运行启动。
 protected void launch(String[] args) throws Exception {
        JarFile.registerUrlProtocolHandler();
        ClassLoader classLoader = this.createClassLoader(this.getClassPathArchives());
        this.launch(args, this.getMainClass(), classLoader);
    }

追寻this.getMainClass() 方法,其会指向上述的父类ExecutableArchiveLauncher中,此处就回到了我们开始说的Start-Class配置项。

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);
        } else {
            return mainClass;
        }
    }

getMainClass()方法中的this.archive.getManifest() 就是获取jar下的META-INF/MANIFEST.MF文件。此处追寻到Archive的子类ExplodedArchive中,如下代码获取清单文件:

 	private File getManifestFile(File root) {
        File metaInf = new File(root, "META-INF");
        return new File(metaInf, "MANIFEST.MF");
    }

到此时清单文件中的Start-Class、Spring-Boot-Classes、Spring-Boot-Lib都已找到,准备启动!
回到org.springframework.boot.loader.Launcher的launch方法。

  • 当前线程设置类加载器
  • 创建主方法并运行(主方法即为Start-Class指向的类)
protected void launch(String[] args, String mainClass, ClassLoader classLoader) throws Exception {
        Thread.currentThread().setContextClassLoader(classLoader);
        this.createMainMethodRunner(mainClass, args, classLoader).run();
    }

以上两行代码具体实现在org.springframework.boot.loader.MainMethodRunner类中,run方法即为最后的启动逻辑

  • 通过当前线程类加载器载入清单文件Start-Class配置的主类。
  • 加载后获取主类中的main方法(XXXApplication中的main方法)。
  • 反射执行该XXXApplication中的main方法。
public MainMethodRunner(String mainClass, String[] args) {
        this.mainClassName = mainClass;
        this.args = args != null ? (String[])args.clone() : null;
    }
    public void run() throws Exception {
        Class<?> mainClass = Thread.currentThread().getContextClassLoader().loadClass(this.mainClassName);
        Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
        mainMethod.invoke((Object)null, this.args);
    }

至此,从执行java -jar命令,SpringBoot打包的jar启动到程序中XXXApplication中的main方法这一阶段我们就初步分析完了!

总结:SpringBoot通过引入打包插件spring-boot-maven-plugin将其相关信息写入到java-jar的META-INF/MANIFEST.MF文件中,而后通过清单文件中的主入口Main-Class配置的org.springframework.boot.loader.JarLauncher类加载相关class、lib和应用程序主类Start-Class配置的XXXApplication类,再反射获取XXXApplication类中我们业务定义的main方法启动运行。

到此这篇关于SpringBoot工程打包后为何执行Java -Jar就能启动?的文章就介绍到这了,更多相关springboot打包执行ava -Jar启动内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • java中判断String类型为空和null的几种方法

    java中判断String类型为空和null的几种方法

    判断一个字符串是否为空或者为null是一个常见的操作,本文主要介绍了java中判断String类型为空和null的几种方法,具有一定的参考价值,感兴趣的可以了解一下
    2024-06-06
  • springboot prototype设置多例不起作用的解决操作

    springboot prototype设置多例不起作用的解决操作

    这篇文章主要介绍了springboot prototype设置多例不起作用的解决操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-09-09
  • 深入讲解Java的对象头与对象组成

    深入讲解Java的对象头与对象组成

    由于Java面向对象的思想,在JVM中需要大量存储对象,存储时为了实现一些额外的功能,需要在对象中添加一些标记字段用于增强对象功能,这些标记字段组成了对象头,下面这篇文章主要给大家介绍了关于Java对象头与对象组成的相关资料,需要的朋友可以参考下
    2022-02-02
  • java大数乘法的简单实现 浮点数乘法运算

    java大数乘法的简单实现 浮点数乘法运算

    大数乘法可以进行任意大小和精度的整数和浮点数的乘法运算, 精确度很高, 可以用作经融等领域的计算,这个是我看了一些资料, 然后自己整理实现的,简单测试了一下
    2014-01-01
  • Lombok使用@Tolerate实现冲突兼容问题

    Lombok使用@Tolerate实现冲突兼容问题

    这篇文章主要介绍了Lombok使用@Tolerate实现冲突兼容问题,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2022-08-08
  • SpringMVC获取请求参数的方法详解

    SpringMVC获取请求参数的方法详解

    这篇文章主要为大家详细介绍了SpringMVC中获取请求参数的方法,例如通过ServletAPI获取和通过控制器方法的形参获取请求参数等,需要的可以参考下
    2023-07-07
  • Java和C语言分别实现水仙花数及拓展代码

    Java和C语言分别实现水仙花数及拓展代码

    这篇文章主要介绍了分别用Java和C语言实现水仙花数,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2021-11-11
  • Java中的StringBuilder()常见方法详解

    Java中的StringBuilder()常见方法详解

    StringBuilder是一个可变的字符序列,此类提供一个与 StringBuffer 兼容的 API,但不保证同步,这篇文章主要介绍了StringBuilder()常见方法,需要的朋友可以参考下
    2023-09-09
  • Java线程中synchronized和volatile关键字的区别详解

    Java线程中synchronized和volatile关键字的区别详解

    这篇文章主要介绍了Java线程中synchronized和volatile关键字的区别详解,synchronzied既能够保障可见性,又能保证原子性,而volatile只能保证可见性,无法保证原子性,volatile不需要加锁,比synchronized更轻量级,不会阻塞线程,需要的朋友可以参考下
    2024-01-01
  • MyBatis入门之增删改查+数据库字段和实体字段不一致问题处理方法

    MyBatis入门之增删改查+数据库字段和实体字段不一致问题处理方法

    这篇文章主要介绍了MyBatis入门之增删改查+数据库字段和实体字段不一致问题处理方法,需要的朋友可以参考下
    2017-05-05

最新评论