SpringBoot项目jar、war包启动解析

本文涉及的产品
云解析 DNS,旗舰版 1个月
全局流量管理 GTM,标准版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
简介: war包是Java Web应用程序的一种打包方式符合Servlet标准,它是Web Archive的缩写,主要用于存储Web应用程序相关的文件,包括Java类文件、JSP、HTML、CSS、JavaScript、图片等资源文件。war包需要部署到web服务器中(Tomcat、Apache、IIS)

一、jar包和war包的区别
1.1 war包

war包是Java Web应用程序的一种打包方式符合Servlet标准,它是Web Archive的缩写,主要用于存储Web应用程序相关的文件,包括Java类文件、JSP、HTML、CSS、JavaScript、图片等资源文件。
war包需要部署到web服务器中(Tomcat、Apache、IIS)

1.2 jar包

jar包是类的归档文件,主要用于存储Java类文件和相关资源文件。它通常被用于封装Java应用程序或Java类库,方便程序的部署和发布
jar包可以被JVM直接加载和运行。

1.3 主要区别:

jar包主要用于存储Java类文件和相关资源文件,而war包主要用于存储Web应用程序相关的文件。
jar包可以被JVM直接加载和运行,而war包需要被Web服务器加载和运行。
jar包通常用于封装Java应用程序或Java类库,而war包用于封装Java Web应用程序。

二、SpringBoot使用war包启动
war包启动:需要先启动外部的Web服务器,实现Servlet3.0规范中引导应用启动类,然后将war包放入Web服务器下,Web服务器通过回调引导应用启动类方法启动应用。
2.1 Servlet3.0规范中引导应用启动的说明

在Servlet容器(Tomcat、Jetty等)启动应用时,会扫描应用jar包中 ServletContainerInitializer 的实现类。
框架必须在jar包的 META-INF/services 的文件夹中提供一个名为 javax.servlet.ServletContainerInitializer 的文件,文件内容要写明 ServletContainerInitializer 的实现类的全限定名。
这个 ServletContainerInitializer 是一个接口,实现它的类必须实现一个方法:onStartUp
可以在这个 ServletContainerInitializer 的实现类上标注 @HandlesTypes 注解,在应用启动的时候自行加载一些附加的类,这些类会以字节码的集合形式传入 onStartup 方法的第一个参数中。

public interface ServletContainerInitializer {

void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException;

}
复制代码
2.2 SpringBootServletInitializer的作用和原理
Spirng中SpringServletContainerInitializer实现了Servlet的规范

@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {

@Override
public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
        throws ServletException {
    // SpringServletContainerInitializer会加载所有的WebApplicationInitializer类型的普通实现类

    List<WebApplicationInitializer> initializers = new LinkedList<WebApplicationInitializer>();

    if (webAppInitializerClasses != null) {
        for (Class<?> waiClass : webAppInitializerClasses) {
            // 如果不是接口,不是抽象类
            if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
                    WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                try {
                    // 创建该类的实例
                    initializers.add((WebApplicationInitializer) waiClass.newInstance());
                }
                catch (Throwable ex) {
                    throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
                }
            }
        }
    }

    if (initializers.isEmpty()) {
        servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
        return;
    }

    servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
    AnnotationAwareOrderComparator.sort(initializers);
    // 启动Web应用onStartup方法
    for (WebApplicationInitializer initializer : initializers) {
        initializer.onStartup(servletContext);
    }
}

}
复制代码
@HandlesTypes使用BCEL的ClassParser在字节码层面读取了/WEB-INF/classes和jar中class文件的超类名和实现的接口名,判断是否与记录的注解类名相同,若相同再通过org.apache.catalina.util.Introspection类加载为Class对象保存起来,最后传入onStartup方法参数中
SpringServletContainerInitializer类上标注了@HandlesTypes(WebApplicationInitializer.class),所以会导入WebApplicationInitializer实现类
SpringBoot中SpringBootServletInitializer是WebApplicationInitializer的抽象类,实现了onStartup方法
@Override
public void onStartup(ServletContext servletContext) throws ServletException {

// Logger initialization is deferred in case an ordered
// LogServletContextInitializer is being used
this.logger = LogFactory.getLog(getClass());
// 创建 父IOC容器
WebApplicationContext rootAppContext = createRootApplicationContext(servletContext);
if (rootAppContext != null) {
    servletContext.addListener(new ContextLoaderListener(rootAppContext) {
        @Override
        public void contextInitialized(ServletContextEvent event) {
            // no-op because the application context is already initialized
        }
    });
}
else {
    this.logger.debug("No ContextLoaderListener registered, as " + "createRootApplicationContext() did not "
            + "return an application context");
}

}
复制代码
创建父容器
protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {

// 使用Builder机制,前面也介绍过
SpringApplicationBuilder builder = createSpringApplicationBuilder();
builder.main(getClass());
ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
if (parent != null) {
    this.logger.info("Root context already created (using as parent).");
    servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
    builder.initializers(new ParentContextApplicationContextInitializer(parent));
}
// 设置Initializer
builder.initializers(new ServletContextApplicationContextInitializer(servletContext));
// 在这里设置了容器启动类:AnnotationConfigServletWebServerApplicationContext
builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);
// 【引导】多态进入子类(自己定义)的方法中
builder = configure(builder);
builder.listeners(new WebEnvironmentPropertySourceInitializer(servletContext));
// builder.build(),创建SpringApplication
SpringApplication application = builder.build();
if (application.getAllSources().isEmpty()
        && AnnotationUtils.findAnnotation(getClass(), Configuration.class) != null) {
    application.addPrimarySources(Collections.singleton(getClass()));
}
Assert.state(!application.getAllSources().isEmpty(),
        "No SpringApplication sources have been defined. Either override the "
                + "configure method or add an @Configuration annotation");
// Ensure error pages are registered
if (this.registerErrorPageFilter) {
    application.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
}
// 启动SpringBoot应用
return run(application);

}
复制代码
所以我们只需要自定义类继承SpringBootServletInitializer并实现configure方法告诉启动类所在的位置就可以实现SpringBoot自启动了
例如:
public class MyInitializer extends SpringBootServletInitializer {

@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {

  //MySpringBootApplication为SpingBoot启动类
  return application.sources(MySpringBootApplication.class);

}
}
复制代码
三、SpringBoot使用jar包启动
按照java官方文档规定,java -jar命令引导的具体启动类必须配置在MANIFEST.MF中的Main-class属性中,该值代表应用程序执行入口类也就是包含main方法的类。
从MANIFEST.MF文件内容可以看到,Main-Class这个属性定义了org.springframework.boot.loader.JarLauncher,JarLauncher就是对应Jar文件的启动器。而我们项目的启动类SpringBootDemoApplication定义在Start-Class属性中,
JarLauncher会将BOOT-INF/classes下的类文件和BOOT-INF/lib下依赖的jar加入到classpath下,然后调用META-INF/MANIFEST.MF文件Start-Class属性完成应用程序的启动。

关于 jar 官方标准说明请移步

JAR File Specification
JAR (file format)

SpringBoot的jar包,会有3个文件夹:

BOOT-INF:存放自己编写并编译好的 .class 文件和静态资源文件、配置文件等
META-INF:有一个 MANIFEST.MF 的文件
org:spring-boot-loader 的一些 .class 文件

META-INF 下面的 MANIFEST.MF 文件,里面的内容如下:
Manifest-Version: 1.0
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Implementation-Title: my-small-test
Implementation-Version: 1.0-SNAPSHOT
Spring-Boot-Layers-Index: BOOT-INF/layers.idx
Start-Class: com.small.test.SpringBootDemoApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Build-Jdk-Spec: 1.8
Spring-Boot-Version: 2.4.0
Created-By: Maven Jar Plugin 3.2.0
Main-Class: org.springframework.boot.loader.JarLauncher
复制代码

在 Start-Class 中注明了 SpringBoot 的主启动类
在 Main-Class 中注明了一个类: JarLauncher

package org.springframework.boot.loader;

import java.io.IOException;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import org.springframework.boot.loader.archive.Archive;

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);

}
}
复制代码
父类Launcher#launch
protected void launch(String[] args) throws Exception {

if (!isExploded())
//3.1 注册URL协议并清除应用缓存
JarFile.registerUrlProtocolHandler(); 
//3.2 设置类加载路径
ClassLoader classLoader = createClassLoader(getClassPathArchivesIterator());
String jarMode = System.getProperty("jarmode");
String launchClass = (jarMode != null && !jarMode.isEmpty()) ? "org.springframework.boot.loader.jarmode.JarModeLauncher" : getMainClass();
//3.3 执行main方法
launch(args, launchClass, classLoader);

}
复制代码
3.1 registerUrlProtocolHandler:注册URL协议并清除应用缓存
先设置当前系统的一个变量 java.protocol.handler.pkgs,而这个变量的作用,是设置 URLStreamHandler 实现类的包路径。
之后要重置缓存,目的是清除之前启动的残留。
private static final String MANIFEST_NAME = "META-INF/MANIFEST.MF";

private static final String PROTOCOL_HANDLER = "java.protocol.handler.pkgs";

private static final String HANDLERS_PACKAGE = "org.springframework.boot.loader";

public static void registerUrlProtocolHandler() {
    String handlers = System.getProperty(PROTOCOL_HANDLER, "");
    System.setProperty(PROTOCOL_HANDLER,
            ("".equals(handlers) ? HANDLERS_PACKAGE : handlers + "|" + HANDLERS_PACKAGE));
    resetCachedUrlHandlers();
}

// 重置任何缓存的处理程序,以防万一已经使用了jar协议。

// 我们通过尝试设置null URLStreamHandlerFactory来重置处理程序,除了清除处理程序缓存之外,它应该没有任何效果。

private static void resetCachedUrlHandlers() {
    try {
        URL.setURLStreamHandlerFactory(null);
    }
    catch (Error ex) {
        // Ignore
    }
}

复制代码
3.2createClassLoader:设置类加载路径
protected ClassLoader createClassLoader(Iterator 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());

}
复制代码
3.3 执行main方法
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);

}
复制代码
package org.springframework.boot.loader;

import java.lang.reflect.Method;

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());
//获取主启动类的main方法
Method mainMethod = mainClass.getDeclaredMethod("main", new Class[] { String[].class });
mainMethod.setAccessible(true);
//执行main方法
mainMethod.invoke((Object)null, new Object[] { this.args });

}
}
复制代码
所以 SpringBoot 应用在开发期间只需要写 main 方法,引导启动即可。

相关文章
|
5月前
|
并行计算 Java 数据处理
SpringBoot高级并发实践:自定义线程池与@Async异步调用深度解析
SpringBoot高级并发实践:自定义线程池与@Async异步调用深度解析
385 0
|
2月前
|
XML Java 应用服务中间件
SpringBoot项目打war包流程
本文介绍了将Spring Boot项目改造为WAR包并部署到外部Tomcat服务器的步骤。主要内容包括:1) 修改pom.xml中的打包方式为WAR;2) 排除Spring Boot内置的Tomcat依赖;3) 添加Servlet API依赖;4) 改造启动类以支持WAR部署;5) 打包和部署。通过这些步骤,可以轻松地将Spring Boot应用转换为适合外部Tomcat服务器的WAR包。
174 64
SpringBoot项目打war包流程
|
19天前
|
Java 数据库 开发者
详细介绍SpringBoot启动流程及配置类解析原理
通过对 Spring Boot 启动流程及配置类解析原理的深入分析,我们可以看到 Spring Boot 在启动时的灵活性和可扩展性。理解这些机制不仅有助于开发者更好地使用 Spring Boot 进行应用开发,还能够在面对问题时,迅速定位和解决问题。希望本文能为您在 Spring Boot 开发过程中提供有效的指导和帮助。
69 12
|
1月前
|
Java Maven 开发者
编写SpringBoot的自定义starter包
通过本文的介绍,我们详细讲解了如何创建一个Spring Boot自定义Starter包,包括自动配置类、配置属性类、`spring.factories`文件的创建和配置。通过自定义Starter,可以有效地复用公共配置和组件,提高开发效率。希望本文能帮助您更好地理解和应用Spring Boot自定义Starter,在实际项目中灵活使用这一强大的功能。
49 17
|
22天前
|
Java 应用服务中间件 Maven
SpringBoot项目打包成war包
通过上述步骤,我们成功地将一个Spring Boot应用打包成WAR文件,并部署到外部的Tomcat服务器中。这种方式适用于需要与传统Servlet容器集成的场景。
41 8
|
5月前
|
人工智能 自然语言处理 前端开发
SpringBoot + 通义千问 + 自定义React组件:支持EventStream数据解析的技术实践
【10月更文挑战第7天】在现代Web开发中,集成多种技术栈以实现复杂的功能需求已成为常态。本文将详细介绍如何使用SpringBoot作为后端框架,结合阿里巴巴的通义千问(一个强大的自然语言处理服务),并通过自定义React组件来支持服务器发送事件(SSE, Server-Sent Events)的EventStream数据解析。这一组合不仅能够实现高效的实时通信,还能利用AI技术提升用户体验。
437 2
|
7月前
|
Java 应用服务中间件 Spring
为什么SpringBoot的 jar 可以直接运行?
SpringBoot的 jar 可以直接运行的原因
527 2
|
4月前
|
前端开发 Java Maven
深入解析:如何用 Spring Boot 实现分页和排序
深入解析:如何用 Spring Boot 实现分页和排序
209 2
|
4月前
|
Java 应用服务中间件 Maven
Maven的三种项目打包方式——pom,jar,war的区别
Maven 提供了多种打包方式,分别适用于不同类型的项目。pom 用于父项目或聚合项目,便于项目的结构和依赖管理;jar 用于Java类库或可执行的Java应用程序;war 则专用于Java Web应用程序的部署。理解这些打包方式的用途和特点,可以帮助开发者更好地配置和管理Maven项目,确保构建和部署过程的顺利进行。无论是单模块项目还是多模块项目,选择合适的打包方式对于项目的成功至关重要。
478 3
|
6月前
|
设计模式 Java 关系型数据库
【Java笔记+踩坑汇总】Java基础+JavaWeb+SSM+SpringBoot+SpringCloud+瑞吉外卖/谷粒商城/学成在线+设计模式+面试题汇总+性能调优/架构设计+源码解析
本文是“Java学习路线”专栏的导航文章,目标是为Java初学者和初中高级工程师提供一套完整的Java学习路线。
566 37

推荐镜像

更多