<think>我们正在处理一个关于
Spring Boot
项目启动方式转换的问题。用户希望将原本使用
Tomcat插件
启动的
Spring项目（可能是通过Maven的
tomcat7:run等插件）改为通过main方法直接
启动。
根据引用内容，我们知道
Spring Boot应用程序通常有一个主类（
启动类），这个类包含main方法并调用`
SpringApplication.run()`。因此，我们需要确保
项目具有这样的主类，并且配置正确。
步骤：
1. 确保
项目是一个
Spring Boot
项目，并且已经正确配置了
Spring Boot的依赖（如
spring-boot-starter-web）。
2. 创建一个主类（如果还没有的话），该类使用`@
SpringBootApplication`注解，并包含main方法，在main方法中调用`
SpringApplication.run`。
3. 如果之前是通过Maven的
Tomcat插件（如
tomcat7-maven-plugin）
启动的，那么需要移除该插件，因为我们将使用内嵌的
Tomcat（由
Spring Boot管理）来
启动。
4. 修改
项目的打包方式（如果需要的话）。如果之前是war包部署到外部
Tomcat，现在要改为直接
运行main方法，则可能需要将打包方式改为jar（因为内嵌服务器通常使用jar包
运行）。但注意，我们这里只是改变
启动方式，并不一定需要改变打包方式，因为即使打包成war，也可以包含内嵌服务器并通过main方法
启动（
Spring Boot支持）。不过，对于简单的直接
启动，我们通常使用jar。
但是，根据用户描述，他们之前可能是通过Maven的
Tomcat插件（如
tomcat7:run）来
启动的，这通常用于非
Spring Boot的传统的
Spring MVC
项目。因此，我们需要将
项目转换为
Spring Boot
项目。
具体步骤：
1. 添加
Spring Boot依赖：
在pom.xml中添加
Spring Boot父
项目（或者使用dependencyManagement）和starter-web依赖。
例如：
```xml
<parent>
<groupId>org.
springframework.boot</groupId>
<artifactId>
spring-boot-starter-parent</artifactId>
<version>2.7.0</version> <!-- 使用合适的版本 -->
</parent>
<dependencies>
<dependency>
<groupId>org.
springframework.boot</groupId>
<artifactId>
spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
```
2. 创建主类：
在源代码的根包下（或其他包，但通常推荐根包）创建一个主类，例如：
```java
import org.
springframework.boot.
SpringApplication;
import org.
springframework.boot.autoconfigure.
SpringBootApplication;
@
SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
```
3. 移除外部的
Tomcat插件：
在pom.xml中，移除之前用于
启动的
Tomcat插件，例如：
```xml
<plugin>
<groupId>org.apache.
tomcat.maven</groupId>
<artifactId>
tomcat7-maven-plugin</artifactId>
<version>2.2</version>
</plugin>
```
4. 如果之前
项目是打包成war并部署到外部
Tomcat，那么现在要改为内嵌
Tomcat启动，需要：
- 确保打包方式为jar（或者war，但由
Spring Boot内嵌
Tomcat运行，此时不需要外部
Tomcat）。如果只是本地
运行，打包方式可以不用改，因为
运行main方法不依赖于打包。
- 移除对
spring-boot-starter-
tomcat的provided scope（如果有的话），因为内嵌
运行需要包含它。
通常，如果只是为了通过main方法
运行，我们不需要改变打包方式，可以直接
运行主类。
5.
运行：现在可以直接
运行主类的main方法，
启动内嵌的
Tomcat。
注意：如果
项目之前是传统的
Spring MVC
项目（非
Spring Boot），那么可能还需要进行一些配置的调整，比如将web.xml中的配置转换为
Spring Boot的配置方式（使用@Configuration类）。
引用[1]中提到：如果代码中有
两个类都调用了`
SpringApplication.run()`，那么应用程序可能会
启动两次。因此，确保只有一个主类（只有一个main方法调用`
SpringApplication.run`）。
引用[2]和[3]提到了如何将
Spring Boot
项目部署到外部
Tomcat（即打包成war并部署），但我们现在要做的是相反的事情：从外部
Tomcat部署改为内嵌服务器
启动。因此，我们不需要按照那些步骤，而是需要确保内嵌服务器被包含并正确
启动。
引用[4]提到使用外置
Tomcat启动，但用户希望的是直接通过main方法
启动（使用内嵌服务器），所以我们不需要外置
Tomcat。
总结：核心是添加
Spring Boot依赖，创建主类，移除外部
Tomcat插件，然后
运行主类。
如果
项目已经是
Spring Boot
项目，只是之前一直使用插件
启动，那么只需要移除插件，然后直接
运行主类即可。
但是，如果用户的
项目原本不是
Spring Boot
项目，那么转换过程可能涉及更多配置的调整，比如将XML配置改为Java配置等。由于问题中没有说明
项目原本的结构，我们假设它是一个可以转换为
Spring Boot的
项目。
因此，我们给出上述步骤。</think>### 如何将
Spring 项目从
Tomcat 插件
启动改为 Main 方法
启动
要将原本使用
Tomcat Maven 插件
启动的
Spring 项目改为通过 `main` 方法直接
启动，需遵循以下步骤：
#### 1. **添加
Spring Boot 依赖**
在 `pom.xml` 中引入
Spring Boot
启动器和内嵌
Tomcat 依赖：
```xml
<dependency>
<groupId>org.
springframework.boot</groupId>
<artifactId>
spring-boot-starter-web</artifactId>
<version>3.1.0</version> <!-- 按需调整版本 -->
</dependency>
```
#### 2. **创建
Spring Boot 主类**
在
项目根包下创建主类，继承 `
SpringBootServletInitializer` 并实现 `main` 方法：
```java
import org.
springframework.boot.
SpringApplication;
import org.
springframework.boot.autoconfigure.
SpringBootApplication;
import org.
springframework.boot.builder.
SpringApplicationBuilder;
import org.
springframework.boot.web.servlet.support.
SpringBootServletInitializer;
@
SpringBootApplication
public class Application extends
SpringBootServletInitializer {
@Override
protected
SpringApplicationBuilder configure(
SpringApplicationBuilder builder) {
return builder.sources(Application.class);
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args); // 直接
启动内嵌
Tomcat
}
}
```
- `@
SpringBootApplication` 注解启用自动配置
- `main` 方法通过 `
SpringApplication.run()`
启动内嵌服务器[^1]
#### 3. **移除外部
Tomcat 插件**
删除 `pom.xml` 中的
Tomcat Maven 插件配置（如 `
tomcat7-maven-plugin`）：
```xml
<!-- 删除此插件配置 -->
<plugin>
<groupId>org.apache.
tomcat.maven</groupId>
<artifactId>
tomcat7-maven-plugin</artifactId>
<version>2.2</version>
</plugin>
```
#### 4. **修改打包方式（可选）**
如果
项目需打包为可执行 JAR，将打包方式改为 `jar`：
```xml
<packaging>jar</packaging>
```
若需保留 WAR 包但通过 `main` 方法
启动，保持 `war` 打包但确保内嵌
Tomcat 在类路径中[^3]。
#### 5. **验证
启动**
运行主类的 `main` 方法，控制台将输出
Spring Boot
启动日志：
```
Tomcat initialized with port(s): 8080 (http)
Starting embedded
Tomcat server
Initializing
Spring embedded WebApplicationContext
```
### 关键修改说明
| **原配置** | **修改后配置** | 作用 |
|--------------------------|-----------------------------|----------------------------------------------------------------------|
|
Tomcat Maven 插件 | 移除插件 | 避免外部
Tomcat 启动 |
| 无主类 | 添加 `@
SpringBootApplication` 主类 | 提供
Spring Boot 入口点[^1] |
| 外部服务器依赖 | `
spring-boot-starter-web` | 引入内嵌
Tomcat 和
Spring MVC 支持 |
| `mvn
tomcat7:run` 命令 | 直接
运行主类的 `main` 方法 | 通过内嵌服务器
启动应用 |
> **注意**：若
项目中有多个 `
SpringApplication.run()` 调用，需确保只有一个主类，否则会导致重复
启动[^1]。
### 常见问题解决
- **端口冲突**：在 `application.properties` 中配置 `server.port=新端口`
- **依赖冲突**：检查是否遗留 `provided` 作用域的
Tomcat 依赖（应移除或改为 `compile`）
- **静态资源
加载**：将资源文件移至 `src/main/resources/static`
通过以上步骤，
项目即可从插件
启动转为标准的
Spring Boot
启动方式，简化开发部署流程[^4]。
---
### 相关问题
1.
Spring Boot 内嵌
Tomcat 与外部
Tomcat 在性能上有何差异？
2. 如何为
Spring Boot 应用配置 HTTPS 支持？
3. 在微服务架构中，直接
启动与容器化部署该如何选择？
4. 如何监控
Spring Boot 内嵌
Tomcat 的
运行指标？
[^1]: 主类通过 `
SpringApplication.run()` 初始化应用上下文并
启动内嵌服务器
[^2]:
Spring Boot 自动配置机制会根据类路径依赖
加载内嵌容器
[^3]: WAR 包需包含 `
SpringBootServletInitializer` 以支持外部容器部署
[^4]: 使用内嵌服务器可保持开发/生产环境一致性
本文介绍了一种解决Tomcat服务器重复加载Spring框架的问题。通过使用特定命令重新编译Tomcat，成功解决了因之前项目残留导致的问题。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
