SpringBoot（三）之打包方式

SpringBoot（三）之打包方式

Spring Boot 提供了几种常见的打包方式，具体取决于你的项目需求和偏好：

1. JAR（可执行的JAR文件）： 这是 Spring Boot 的默认打包方式。它将项目的所有依赖打包到一个可执行的 JAR 文件中，包括 Spring Boot 应用程序以及嵌入的 Tomcat 或 Jetty 等服务器。你可以通过运行 java -jar your-application.jar 来启动应用程序。
2. WAR（Web应用程序存档）： 如果你需要将 Spring Boot 应用程序部署到外部的 Servlet 容器（如 Tomcat、Jetty 或者 Wildfly），你可以打包为 WAR 文件。在这种情况下，Spring Boot 应用程序不会包含嵌入式的服务器，而是依赖于外部容器来运行。
3. Executable WAR（可执行的WAR文件）： 从 Spring Boot 1.4 版本开始，你可以创建一个可执行的 WAR 文件。这种方式结合了 JAR 和 WAR 的优点。它允许你在外部容器中部署 Spring Boot 应用程序，并且仍然可以像运行 JAR 文件一样启动它。你只需要将 WAR 文件部署到 Servlet 容器中即可。
4. Executable JAR with Dependencies（带依赖的可执行JAR文件）： 有时你可能希望生成一个包含所有依赖的可执行 JAR 文件，而不是将依赖打包到 JAR 文件中。你可以使用 Maven 或 Gradle 插件来实现这一点，例如 Spring Boot Maven 插件或 Spring Boot Gradle 插件。这种方式生成的 JAR 文件会比较大，但可以更容易地与其他项目共享依赖。

以上是一些常见的 Spring Boot 打包方式，你可以根据项目需求选择适合你的方式。

一、jar包形式

1. 在 Maven 项目的 pom.xml 文件中，确保你有 spring-boot-starter-parent 作为父项目，并且添加了 spring-boot-maven-plugin 插件。

<project><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.6.2</version></parent><dependencies><!-- 你的其他依赖 --></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

1. 执行mvn clean package,这将在项目的 target 文件夹下生成一个可执行的 JAR 文件。

tips

:可跳过tests执行 mvn clean package -DskipTests

1. cd target 目录下,执行java -jar 生成的jar包命令运行web项目

java-jar .\spring-boot-start-0.0.1-SNAPSHOT.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.6.4)

2024-05-15 11:00:26.009  INFO 19712 --- [           main] c.a.s.SpringBootStartApplication         : Starting SpringBootStartApplication v0.0.1-SNAPSHOT using Java 1.8.0_261 on DESKTOP-SQBHU59 with PID 19712 (D:\practise\spring-all\spring-boot-start\target\spring-boot-start-0.0.1-SNAPSHOT.jar started by aoxiaojun in D:\practise\spring-all\spring-boot-start\target)
2024-05-15 11:00:26.011  INFO 19712 --- [           main] c.a.s.SpringBootStartApplication         : No active profile set, falling back to 1 default profile: "default"
2024-05-15 11:00:27.095  INFO 19712 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 1010 (http)
2024-05-15 11:00:27.106  INFO 19712 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2024-05-15 11:00:27.106  INFO 19712 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.58]
2024-05-15 11:00:27.156  INFO 19712 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2024-05-15 11:00:27.157  INFO 19712 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 1105 ms
2024-05-15 11:00:27.198  INFO 19712 --- [           main] f.a.AutowiredAnnotationBeanPostProcessor : Autowired annotation should only be used on methods with parameters: public java.lang.String cn.axj.springbootstart.controller.TestController.test()
2024-05-15 11:00:27.447  INFO 19712 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 1010 (http) with context path ''
2024-05-15 11:00:27.453  INFO 19712 --- [           main] c.a.s.SpringBootStartApplication         : Started SpringBootStartApplication in 1.761 seconds (JVM running for 2.13)

二、war包

对于那种项目需要经常更新某个文件的情况，可以将springboot项目打包成war包，便于更新某些文件，而不用打整包的形式上线。打成war后需要依赖外部的serlvet容器运行，如tomcat，jetty等。

1. 修改启动类： 需要修改 Spring Boot 应用程序的启动类，以扩展 SpringBootServletInitializer 类，并覆盖 configure 方法。这个类负责初始化 Servlet 容器，并加载 Spring 应用程序上下文。

importorg.springframework.boot.builder.SpringApplicationBuilder;importorg.springframework.boot.web.servlet.support.SpringBootServletInitializer;publicclassServletInitializerextendsSpringBootServletInitializer{@OverrideprotectedSpringApplicationBuilderconfigure(SpringApplicationBuilder application){return application.sources(YourSpringBootApplication.class);}}

1. 修改maven配置

<packaging>war</packaging><dependencies><!-- 排除内嵌的容器依赖 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId><scope>provided</scope></dependency></dependencies>

1. 执行mvn clean package
2. 部署 WAR 文件： 构建成功后，WAR 文件会生成在目标文件夹下（通常是 target 目录），你可以将生成的 WAR 文件部署到外部的 Servlet 容器中。

三、Executable WAR

可执行的war包，可以通过java -jar命令直接运行，也可以在外部容器中部署和运行

1. 在 Maven 项目的 pom.xml 文件中，确保你有 spring-boot-starter-parent 作为父项目，并且添加了 spring-boot-maven-plugin 插件。同时，将 <executable> 设置为 true。

<packaging>war</packaging><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><executable>true</executable></configuration></plugin></plugins></build>

1. 执行 mvn clean package
2. 在可以通过java -jar 命令执行war文件。

java-jar .\target\spring-boot-start-0.0.1-SNAPSHOT.war

四、Executable JAR with Dependencies(基本不用)

Spring Boot 的可执行 JAR 文件和带依赖的可执行 JAR 文件之间有一些区别：

1. 可执行 JAR 文件： Spring Boot 的可执行 JAR 文件是指将应用程序本身和其依赖的库（例如 Spring Boot 框架、第三方库等）打包到一个独立的 JAR 文件中。这个 JAR 文件包含了所有需要的类文件和资源文件，以及一个 MANIFEST.MF 文件，指定了应用程序的入口点。你可以通过运行 java -jar your-application.jar 来启动应用程序。
2. 带依赖的可执行 JAR 文件： 带依赖的可执行 JAR 文件是指将应用程序本身以及其依赖的所有库打包到一个 JAR 文件中。不同之处在于，带依赖的 JAR 文件会将所有依赖的库直接包含在 JAR 文件中，而不是像普通的可执行 JAR 文件那样仅包含应用程序本身的类和资源。这意味着生成的 JAR 文件会更大，因为它包含了所有依赖的库。这种方式使得 JAR 文件更加独立，可以更容易地与其他项目共享，并且无需依赖外部的库。

总的来说，带依赖的可执行 JAR 文件包含了应用程序本身和所有依赖的库，而普通的可执行 JAR 文件只包含了应用程序本身。选择哪种方式取决于你的项目需求和偏好，如果你希望生成一个独立的、包含所有依赖的 JAR 文件，可以选择带依赖的可执行 JAR 文件；如果你希望生成一个轻量级的 JAR 文件，并且不包含依赖的库，可以选择普通的可执行 JAR 文件。

要配置生成带有依赖的可执行 JAR 文件，你可以使用 Maven Assembly 插件或 Maven Shade 插件。以下是详细的配置步骤：

使用 Maven Assembly 插件：

1. 在 Maven 项目的 pom.xml 文件中，添加 Maven Assembly 插件，并配置以生成带有依赖的可执行 JAR 文件。

<build><plugins><plugin><artifactId>maven-assembly-plugin</artifactId><version>3.3.0</version><configuration><descriptorRefs><descriptorRef>jar-with-dependencies</descriptorRef></descriptorRefs><archive><manifest><!--                            主类全限定名称--><mainClass>com.example.MainClass</mainClass></manifest></archive></configuration><executions><execution><id>make-assembly</id><phase>package</phase><goals><goal>single</goal></goals></execution></executions></plugin></plugins></build>

1. 在 mainClass 元素中指定主类的完全限定名，这是可执行 JAR 文件的入口点。