SpringBoot（三）之打包方式

时间：2025-02-21 12:20:36

SpringBoot（三）之打包方式

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

  1. JAR（可执行的JAR文件）： 这是 Spring Boot 的默认打包方式。它将项目的所有依赖打包到一个可执行的 JAR 文件中，包括 Spring Boot 应用程序以及嵌入的 Tomcat 或 Jetty 等服务器。你可以通过运行 java -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 项目的 文件中，确保你有 spring-boot-starter-parent 作为父项目，并且添加了 spring-boot-maven-plugin 插件。
<project>
    <parent>
        <groupId></groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.2</version>
    </parent>
    <dependencies>
        <!-- 你的其他依赖 -->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId></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.

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

2024-05-15 11:00:26.009  INFO 19712 --- [           main]          : 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. started by aoxiaojun in D:\practise\spring-all\spring-boot-start\target)
2024-05-15 11:00:26.011  INFO 19712 --- [           main]          : No active profile set, falling back to 1 default profile: "default"
2024-05-15 11:00:27.095  INFO 19712 --- [           main]   : Tomcat initialized with port(s): 1010 (http)
2024-05-15 11:00:27.106  INFO 19712 --- [           main]    : Starting service [Tomcat]
2024-05-15 11:00:27.106  INFO 19712 --- [           main]   : Starting Servlet engine: [Apache Tomcat/9.0.58]
2024-05-15 11:00:27.156  INFO 19712 --- [           main] .[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2024-05-15 11:00:27.157  INFO 19712 --- [           main]  : Root WebApplicationContext: initialization completed in 1105 ms
2024-05-15 11:00:27.198  INFO 19712 --- [           main]  : Autowired annotation should only be used on methods with parameters: public  ()
2024-05-15 11:00:27.447  INFO 19712 --- [           main]   : Tomcat started on port(s): 1010 (http) with context path ''
2024-05-15 11:00:27.453  INFO 19712 --- [           main]          : 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 应用程序上下文。
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(YourSpringBootApplication.class);
    }

}
  1. 修改maven配置
<packaging>war</packaging>
<dependencies>
    <!-- 排除内嵌的容器依赖 -->
    <dependency>
        <groupId></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 项目的 文件中，确保你有 spring-boot-starter-parent 作为父项目，并且添加了 spring-boot-maven-plugin 插件。同时，将 <executable> 设置为 true。
<packaging>war</packaging>
<build>
        <plugins>
            <plugin>
                <groupId></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.

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

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

  1. 可执行 JAR 文件： Spring Boot 的可执行 JAR 文件是指将应用程序本身和其依赖的库（例如 Spring Boot 框架、第三方库等）打包到一个独立的 JAR 文件中。这个 JAR 文件包含了所有需要的类文件和资源文件，以及一个 文件，指定了应用程序的入口点。你可以通过运行 java -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 项目的 文件中，添加 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></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 文件的入口点。

相关文章