为什么springboot的jar可以直接运行,spring boot linux jar包启动

　　00-1010介绍Spring Boot包插件SpringBoot FatJar MAINFEST的组织结构。MF元信息启动原理源代码分析JarlauncherLauncherPropertiesLauncherMethodrunner总结

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

　　BOOT-INF目录：包含我们的项目代码(classes目录)和所需的依赖项(lib目录)；META-INF目录：Jar包的元数据由MANIFEST提供。MF文件，并声明jar的启动类；org . spring framework . boot . loader:Spring Boot的加载器代码，Jar加载中Jar的神奇来源。我们可以看到，如果去掉BOOT-INF目录，将会是一个非常普通和标准的Jar包，包括元信息和可执行代码。Its /META-INF/MAINFEST。MF指定Jar包的启动元信息，org . spring framework . boot . loader执行相应的逻辑操作。

　　00-1010元人民币的信息内容如下：

　　manifest-Version : 1.0 Spring-Boot-class path-index : Boot-INF/class path . idx implementation-title : Spring Boot implementation-Version : 0 . 0 . 1-snapshot Spring-Boot-Layers-index : Boot-INF/Layers . idx start-class : com . list envision . Spring Boot applicationspring-Boot-classes 3: Boot-INF/classes/Spring-Boot-Boot-lib 3: Boot-INF让我们关注两个配置项：

　　Main-Class配置项：Java指定的jar包的启动类，这里设置为spring-boot-loader项目的JarLauncher类来启动Spring Boot应用。启动级配置项目：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

@Overrideprotected 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包启动内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

目录