尧图网站建设 免费方案咨询
ARTICLE DETAIL

资讯详情

深耕网站建设、视觉设计与SEO优化的一线实战洞察。

首页/资讯中心/资讯详情

IDEA 2020创建SpringBoot项目全流程：从环境配置到MyBatis-Plus集成

发布时间：2026/8/6 3:16:02 尧图网站建设
IDEA 2020创建SpringBoot项目全流程：从环境配置到MyBatis-Plus集成

1. 项目缘起：为什么从IDEA2020开始聊SpringBoot

如果你是一个刚入行的Java开发者，或者是一个从Eclipse、MyEclipse等老牌IDE迁移过来的“老鸟”，那么第一次用IntelliJ IDEA（特别是像2020这样的经典版本）来创建一个SpringBoot项目，可能会是一种既兴奋又略带困惑的体验。兴奋在于，IDEA强大的智能提示和流畅的体验，能让你摆脱过去配置环境的繁琐；困惑则在于，面对一个全新的工具和一套约定大于配置的框架，从哪里下手才能不走弯路？

我至今还记得几年前，团队统一从Eclipse切换到IDEA 2020.1版本时，大家围着如何创建一个“标准”的SpringBoot项目讨论了半天。有人直接用了Spring Initializr网站下载再导入，有人则在IDEA里找到了创建向导但被一堆选项搞懵了。最终，我们摸索出了一套在IDEA 2020环境下，从零开始搭建一个“五脏俱全”且结构清晰的SpringBoot项目的最佳实践。这套流程不仅适用于当时，其核心思想和步骤对于理解后续更高版本的IDEA以及SpringBoot本身的演进，都有着坚实的基础作用。

今天，我就以IDEA 2020.3这个长期支持版本为舞台，带你完整走一遍SpringBoot项目的搭建过程。我们不止步于“点下一步”创建出一个空壳，而是要深入每一个配置选项的背后含义，并在此基础上，集成MyBatis-Plus、配置多环境、实现热部署等企业级项目必备的要素。你会发现，用好IDEA 2020这个“老将”，搭配SpringBoot，开发效率的提升是立竿见影的。

2. 环境准备与项目初始化：避开第一个坑

工欲善其事，必先利其器。在开始点击“New Project”之前，有几项准备工作必须做到位，这能避免后续很多莫名奇妙的错误。

2.1 JDK与Maven的配置要点

首先，确保你的机器上安装了JDK 8或以上版本。SpringBoot 2.x 对JDK 8有很好的支持，这也是目前生产环境最主流的版本。在IDEA 2020中，你需要将JDK“引入”到IDE的认知体系中。

打开IDEA，不用急着创建项目，我们先检查配置：点击File->Project Structure(快捷键Ctrl+Alt+Shift+S)。在Project选项卡下，确保Project SDK已经选择为你安装的JDK（例如java version "1.8.0_301"）。下方的Project language level建议与SDK版本保持一致或选择8 - Lambdas, type annotations etc.。

接下来是Maven。IDEA 2020自带捆绑的Maven，但通常建议使用你自己在本地安装的版本，以便统一团队和构建服务器的环境。点击File->Settings(快捷键Ctrl+Alt+S)，搜索Maven。在Maven设置页面，将Maven home path指向你的本地Maven安装目录（例如D:\apache-maven-3.6.3）。同时，重点修改User settings file和Local repository。User settings file默认是Maven安装目录下的conf/settings.xml，我强烈建议你将其复制到你的用户目录（如C:\Users\你的用户名\.m2\）下进行修改，这样不会影响全局配置。在这个自定义的settings.xml里，主要做两件事：一是配置国内的镜像仓库（如阿里云镜像）以加速依赖下载，二是根据需要配置公司的私有仓库。

<!-- 在settings.xml的<mirrors>标签内添加 --> <mirror> <id>aliyunmaven</id> <mirrorOf>*</mirrorOf> <name>阿里云公共仓库</name> <url>https://maven.aliyun.com/repository/public</url> </mirror>

Local repository是本地仓库路径，默认在用户目录的.m2/repository下，如果C盘空间紧张，可以修改到其他盘符。

2.2 使用Spring Initializr创建项目骨架

准备工作就绪，现在开始创建项目。点击File->New->Project...。在左侧项目类型中，选择Spring Initializr。这是IDEA内置的与官方start.spring.io网站对接的功能，是创建SpringBoot项目最标准、最推荐的方式。

这里你会看到几个关键选项：

  • Service URL：保持默认的https://start.spring.io即可，除非公司有内部定制的Initializr服务。
  • Project Metadata：这是项目的“身份证信息”。
    • Group：通常填写公司或组织域名的反写，如com.example。它决定了生成的包结构。
    • Artifact：项目名称，也是最终生成jar包的名字，如demo。
    • Type：选择Maven Project。Gradle也是优秀的选择，但鉴于其学习曲线和国内Maven的普及度，我们选择Maven。
    • Language：选择Java。
    • Packaging：选择Jar。SpringBoot推荐使用可执行Jar包的方式进行部署，这得益于其内嵌的Tomcat等Servlet容器。
    • Java Version：选择8。这里的选择应与前面配置的Project SDK版本对应。
    • Version：这是你项目的初始版本号，如0.0.1-SNAPSHOT。SNAPSHOT表示这是一个处于开发中的快照版本。

填写完毕后，点击Next。

2.3 依赖选择的艺术与陷阱

接下来是最重要的一步：选择依赖。IDEA会连接Initializr服务器，拉取可用的依赖列表。这里的选择决定了项目初始化时pom.xml中会添加哪些starter。

对于初学者，我建议遵循“按需添加，宁缺毋滥”的原则。一个干净的初始项目更容易理解。但为了演示一个功能较全的项目，我们可以选择一些常用依赖：

  • Spring Web：这是构建Web应用（包括RESTful APIs）的基础。它会引入Spring MVC和内嵌的Tomcat。
  • Spring Boot DevTools：强烈建议勾选！它提供了热部署、自动重启等开发时功能，能极大提升开发效率。我们后面会详细配置它。
  • Lombok：又是一个“神器”。它通过注解自动生成Getter、Setter、构造函数等样板代码，让实体类变得非常简洁。勾选后，记得在IDEA中安装Lombok插件并启用注解处理。
  • MyBatis Framework：如果你打算使用原生的MyBatis，可以勾选。但这里有一个大坑：如果我们计划使用功能更强大的MyBatis-Plus，就不要勾选这个。因为MyBatis-Plus的依赖会包含MyBatis，两者同时引入可能导致版本冲突或配置混淆。所以，我们这里先不勾选任何SQL相关依赖，后续手动添加MyBatis-Plus。

其他如Spring Data JPA,Thymeleaf,Spring Security等，根据你的实际需求选择。选择完毕后，点击Next。

最后一步是设置项目名称和存储位置。Project name默认会沿用Artifact，Project location选择你的工作空间路径。点击Finish，IDEA就会开始创建项目并下载初始依赖。

注意：网络状况会影响依赖下载速度。如果卡在下载界面，请检查前面提到的Maven镜像配置是否正确。创建完成后，IDEA会自动打开项目，并开始索引（Indexing）和下载依赖（Maven importing），在右下角可以看到进度条，请耐心等待完成。

3. 项目结构解析与核心配置深化

项目创建完成后，我们来审视一下生成的项目结构，并对其进行一些增强配置。

3.1 标准Maven项目结构解读

IDEA生成的标准SpringBoot项目结构如下：

demo/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/ │ │ │ └── example/ │ │ │ └── demo/ │ │ │ └── DemoApplication.java // 主启动类 │ │ └── resources/ │ │ ├── static/ // 存放静态资源（CSS, JS, 图片） │ │ ├── templates/ // 存放模板文件（如Thymeleaf, Freemarker） │ │ └── application.properties // 主配置文件 │ └── test/ // 测试代码目录 └── pom.xml // Maven项目对象模型，依赖管理核心
  • DemoApplication.java：这是SpringBoot应用的入口。类上的@SpringBootApplication注解是一个组合注解，包含了@Configuration（声明为配置类）、@EnableAutoConfiguration（启用自动配置）和@ComponentScan（组件扫描）。main方法中的SpringApplication.run()启动了整个应用。
  • application.properties：SpringBoot的核心配置文件。所有框架和自定义的配置都可以写在这里。不过，我更推荐使用application.yml，因为它结构更清晰，支持层级。你可以直接删除.properties文件，新建一个application.yml。

3.2 配置文件的进阶玩法：YAML与多环境

在src/main/resources下新建application.yml。YAML的语法是依靠缩进来表示层级关系的。

首先，配置一些通用信息，比如服务器端口和应用名称：

server: port: 8080 # 服务器启动端口 spring: application: name: demo # 应用名称，会用于服务发现、监控等

SpringBoot一个强大的特性是Profile（多环境配置）。我们可以为开发、测试、生产等不同环境定义不同的配置。

  1. 创建环境配置文件：在resources目录下，新建application-dev.yml（开发环境）、application-test.yml（测试环境）、application-prod.yml（生产环境）。
  2. 配置环境特定属性：例如，在application-dev.yml中，我们可以配置H2内存数据库和更详细的日志级别：
    # application-dev.yml spring: datasource: url: jdbc:h2:mem:testdb driver-class-name: org.h2.Driver username: sa password: h2: console: enabled: true # 启用H2数据库控制台 path: /h2-console # 访问路径 logging: level: com.example.demo: debug # 将自己项目的日志级别设为DEBUG，方便调试
    而在application-prod.yml中，则配置真实的MySQL数据库和更简洁的日志：
    # application-prod.yml spring: datasource: url: jdbc:mysql://localhost:3306/demo_prod?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai username: root password: your_strong_password driver-class-name: com.mysql.cj.jdbc.Driver
  3. 激活环境：在主配置文件application.yml中，使用spring.profiles.active属性来指定当前激活的环境。
    # application.yml spring: profiles: active: dev # 默认激活开发环境
    在IDEA中，我们还可以通过启动配置来覆盖这个设置。点击主启动类DemoApplication.java左侧的绿色三角运行按钮，或者点击右上角的运行配置下拉框，选择Edit Configurations...。在打开的窗口中，找到你的SpringBoot应用配置，在Environment->VM options中填入-Dspring.profiles.active=test，即可在启动时指定使用测试环境配置。

3.3 集成MyBatis-Plus与代码生成器

现在我们来手动集成MyBatis-Plus，这是一个对MyBatis的增强工具，提供了通用的Mapper、分页插件、代码生成器等强大功能。

首先，在pom.xml的<dependencies>节点内，添加MyBatis-Plus的Starter依赖和MySQL驱动依赖（以生产环境为例）：

<!-- MyBatis-Plus 启动器 --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.7</version> <!-- 注意版本，需与SpringBoot版本匹配 --> </dependency> <!-- MySQL 驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <!-- 代码生成器依赖（可选，用于生成代码） --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-generator</artifactId> <version>3.5.7</version> <scope>test</scope> </dependency> <dependency> <groupId>org.apache.velocity</groupId> <artifactId>velocity-engine-core</artifactId> <version>2.3</version> <scope>test</scope> </dependency>

版本匹配提醒：MyBatis-Plus 3.5.x 版本通常与 SpringBoot 2.5.x - 2.7.x 配合良好。你可以在Maven中央仓库查看其最新版本和兼容性说明。

接着，在application-dev.yml中补充数据库配置（如果使用MySQL开发）：

spring: datasource: url: jdbc:mysql://localhost:3306/demo_dev?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver

然后，在com.example.demo包下新建一个config包，并创建MybatisPlusConfig配置类：

package com.example.demo.config; import com.baomidou.mybatisplus.annotation.DbType; import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class MybatisPlusConfig { /** * 添加MyBatis-Plus插件。 * 目前只添加了分页插件。 */ @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); // 分页插件 interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 后续还可以添加乐观锁插件等 return interceptor; } }

最后，在DemoApplication主启动类上添加@MapperScan注解，指定Mapper接口所在的包路径，这样Spring Boot才能扫描到它们并将其注册为Bean。

@SpringBootApplication @MapperScan("com.example.demo.mapper") // 添加这行 public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }

4. 开发效率倍增器：热部署与Lombok实战

项目骨架和核心依赖搭好了，接下来我们配置两个能极大提升开发体验的工具：Spring Boot DevTools（热部署）和Lombok。

4.1 深度配置Spring Boot DevTools

我们在创建项目时已经勾选了Spring Boot DevTools依赖，它默认已经生效。但为了达到最佳的热部署效果，还需要进行一些配置。

首先，理解DevTools的工作原理：它使用两个类加载器。一个base类加载器加载那些不会改变的库（如第三方Jar包），另一个restart类加载器加载你正在开发的代码。当检测到classpath下的文件发生变化时，restart类加载器会快速重启，而base类加载器保持不变，从而实现了较快的应用重启。

为了让IDEA在代码修改后自动触发编译，进而被DevTools检测到，我们需要做两件事：

  1. 开启IDEA的自动编译：点击File->Settings->Build, Execution, Deployment->Compiler，勾选Build project automatically。
  2. 允许运行时自动编译：同时按下Ctrl+Shift+Alt+/，选择Registry...，在弹出的窗口中查找并勾选compiler.automake.allow.when.app.running。

接下来，在application.yml中可以对DevTools进行一些微调：

# application.yml spring: devtools: restart: enabled: true # 启用重启，默认就是true exclude: static/**,public/** # 静态资源目录下的变化不触发重启 additional-paths: src/main/java # 监听的路径，默认就是项目路径 livereload: enabled: true # 启用LiveReload，用于静态资源热加载（需浏览器插件配合）

exclude配置很重要，它告诉DevTools，static和public目录下的静态资源（如.css,.js, 图片）变化时，不要重启整个应用，而是触发livereload。这需要浏览器安装LiveReload插件。

实测心得：DevTools的热重启（Restart）通常需要2-5秒，对于中小型项目来说速度可以接受。但它并非真正的“热替换”（Hot Swap），比如你修改了一个方法的内部实现可以生效，但如果你新增或删除一个方法、修改类签名等结构性变化，仍然需要完整的重启。对于实体类、控制器、服务层的常规修改，它的效果非常好。

4.2 Lombok的应用与IDEA适配

Lombok通过注解在编译时生成代码，所以我们需要确保IDEA能识别它。

  1. 安装插件：在IDEA中，点击File->Settings->Plugins，在Marketplace中搜索Lombok，安装并重启IDEA。
  2. 启用注解处理：点击File->Settings->Build, Execution, Deployment->Compiler->Annotation Processors，勾选Enable annotation processing。

现在，我们就可以在代码中愉快地使用Lombok了。例如，创建一个用户实体类User：

package com.example.demo.entity; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import lombok.Data; import lombok.experimental.Accessors; import java.time.LocalDateTime; @Data // 自动生成getter, setter, toString, equals, hashCode方法 @Accessors(chain = true) // 开启链式调用，如：user.setName("Tom").setAge(20) @TableName("sys_user") // MyBatis-Plus注解，指定对应数据库表名 public class User { @TableId(type = IdType.AUTO) // 主键，自增 private Long id; private String username; private String password; private String email; private LocalDateTime createTime; private LocalDateTime updateTime; }

使用@Data注解后，你就不需要手动编写那些冗长的Getter和Setter方法了。@Accessors(chain = true)使得setter方法返回对象本身，可以实现链式调用，让代码更简洁。

避坑提示：Lombok虽然方便，但在团队协作中需要确保所有成员都安装了插件并开启了注解处理，否则代码在别人的IDEA上会报错。另外，过度使用Lombok（如在所有类上无脑加@Data）可能会掩盖一些设计问题，比如暴露了不该暴露的setter。对于简单的数据传输对象（DTO）或持久化实体（Entity），它是绝佳选择。

5. 编写第一个API与数据库交互

环境配置妥当，是时候写点真正的业务代码了。我们将遵循经典的三层架构：Controller（控制层）、Service（服务层）、Mapper（数据访问层），来实现一个简单的用户查询API。

5.1 创建Mapper、Service与Controller

首先，创建Mapper接口。在com.example.demo包下新建mapper包，然后创建UserMapper接口：

package com.example.demo.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.example.demo.entity.User; import org.apache.ibatis.annotations.Mapper; @Mapper // 这个注解也可以不加，因为主类上有@MapperScan public interface UserMapper extends BaseMapper<User> { // 无需编写任何方法，BaseMapper已经提供了基本的CRUD方法 // 如：selectById, selectList, insert, updateById, deleteById等 }

继承BaseMapper<User>并指定泛型为你的实体类，是MyBatis-Plus的核心魔法。这样，UserMapper就自动拥有了单表通用的CRUD方法。

接着，创建Service层。新建service包和UserService接口及其实现类：

// UserService.java (接口) package com.example.demo.service; import com.baomidou.mybatisplus.extension.service.IService; import com.example.demo.entity.User; public interface UserService extends IService<User> { // 可以在这里定义一些复杂的业务方法，不局限于单表CRUD User getUserWithDetail(Long id); }
// UserServiceImpl.java (实现类) package com.example.demo.service.impl; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.example.demo.entity.User; import com.example.demo.mapper.UserMapper; import com.example.demo.service.UserService; import org.springframework.stereotype.Service; @Service // 声明为Spring的Service组件 public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService { @Override public User getUserWithDetail(Long id) { // 这里可以组合多个Mapper调用，实现复杂业务逻辑 // 例如，先查用户，再查他的订单等 User user = this.getById(id); if (user != null) { // 模拟一些其他操作 // user.setOrders(orderService.listByUserId(id)); } return user; } }

ServiceImpl是MyBatis-Plus提供的服务层通用实现，它已经注入了对应的Mapper，并实现了IService接口中的通用方法。

最后，创建Controller。新建controller包和UserController类：

package com.example.demo.controller; import com.example.demo.entity.User; import com.example.demo.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController // 组合了@Controller和@ResponseBody，直接返回JSON @RequestMapping("/api/user") public class UserController { @Autowired private UserService userService; @GetMapping("/{id}") public User getUserById(@PathVariable Long id) { return userService.getById(id); } @GetMapping("/list") public List<User> getUserList() { // 使用MyBatis-Plus提供的Wrapper可以构建查询条件 // 这里简单查询所有 return userService.list(); } @PostMapping public Boolean saveUser(@RequestBody User user) { // @RequestBody 接收JSON格式的请求体 return userService.save(user); } @PutMapping public Boolean updateUser(@RequestBody User user) { return userService.updateById(user); } @DeleteMapping("/{id}") public Boolean deleteUser(@PathVariable Long id) { return userService.removeById(id); } }

一个具备RESTful风格增删改查的API控制器就完成了。@Autowired用于依赖注入，将UserService的实现类注入进来。

5.2 使用MyBatis-Plus的分页与条件查询

MyBatis-Plus的分页功能非常方便。我们已经在配置类中配置了分页插件，现在来使用它。

修改UserController，增加一个带分页的查询接口：

@GetMapping("/page") public Page<User> getUserPage(@RequestParam(defaultValue = "1") Integer current, @RequestParam(defaultValue = "10") Integer size) { // 创建分页对象 Page<User> page = new Page<>(current, size); // 执行分页查询，page对象会被填充结果 return userService.page(page); }

访问/api/user/page?current=2&size=5就能获取第二页，每页5条数据。返回的Page对象包含了数据列表records、总条数total、当前页current等信息。

条件查询则可以使用QueryWrapper或LambdaQueryWrapper（推荐，类型安全）。在Service中新增一个方法：

// 在UserService接口中声明 List<User> listUsersByCondition(String username, String email); // 在UserServiceImpl中实现 @Override public List<User> listUsersByCondition(String username, String email) { LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>(); if (StringUtils.hasText(username)) { wrapper.like(User::getUsername, username); // 模糊查询username } if (StringUtils.hasText(email)) { wrapper.eq(User::getEmail, email); // 等值查询email } wrapper.orderByDesc(User::getCreateTime); // 按创建时间倒序 return this.list(wrapper); }

然后在Controller中暴露对应的API即可。LambdaQueryWrapper使用实体类的getter方法引用（如User::getUsername）来构建条件，避免了硬编码字段名带来的风险。

5.3 运行测试与API调试

代码写完了，让我们启动项目并测试。找到DemoApplication类，点击其左侧的绿色三角运行。在IDEA下方的Run或Services工具窗口，你会看到SpringBoot的启动日志。当看到类似Started DemoApplication in 5.123 seconds (JVM running for 6.456)的日志时，说明启动成功。

打开浏览器或使用Postman、curl等工具测试API：

  • GET http://localhost:8080/api/user/list：获取用户列表。
  • POST http://localhost:8080/api/user：创建用户。请求体为JSON：{"username": "test", "email": "test@example.com"}。
  • GET http://localhost:8080/api/user/page?current=1&size=5：分页查询。

如果数据库是空的，可以先通过POST接口插入几条数据。你可以使用src/main/resources目录下的import.sql文件（如果存在）在启动时自动执行SQL，或者通过数据库客户端手动插入。

调试技巧：在IDEA中，你可以直接在想要调试的代码行左侧点击设置断点（红色圆点），然后以Debug模式（绿色虫子图标）启动应用。当API请求执行到断点处时，程序会暂停，你可以在Debug工具窗口查看所有变量的值，单步执行代码，这对于排查复杂业务逻辑问题非常有用。

6. 常见问题排查与进阶配置

在实际开发中，你肯定会遇到各种各样的问题。这里我总结几个在IDEA 2020中搭建SpringBoot项目时的高频问题及其解决方案。

6.1 启动类无法扫描到组件

问题描述：启动时报错Field xxxService in xxxController required a bean of type 'xxxService' that could not be found.或者Consider defining a bean of type 'xxxMapper' in your configuration.

排查思路：

  1. 检查注解：确保你的Service实现类上有@Service，Controller上有@RestController或@Controller，Mapper接口上有@Mapper或者在启动类上使用了@MapperScan指定了正确包路径。
  2. 检查包路径：SpringBoot默认会扫描主启动类所在包及其子包下的所有组件。请确保你的Controller、Service、Mapper等类都在com.example.demo包或其子包下。如果放在平行的其他包（如com.example.web），则需要使用@ComponentScan注解手动指定扫描路径。
    @SpringBootApplication @ComponentScan(basePackages = {"com.example.demo", "com.example.web"}) @MapperScan({"com.example.demo.mapper", "com.example.web.mapper"}) public class DemoApplication { ... }
  3. 检查依赖：确认pom.xml中相关依赖（如spring-boot-starter-web,mybatis-plus-boot-starter）已正确引入，并且没有版本冲突。可以尝试执行mvn clean compile看是否有编译错误。

6.2 热部署不生效

问题描述：修改了Java代码后，应用没有自动重启。

排查步骤：

  1. 检查依赖：确认pom.xml中包含了spring-boot-devtools依赖，并且其scope是runtime（默认就是）。
  2. 检查IDEA设置：确保按照4.1节所述，开启了Build project automatically和compiler.automake.allow.when.app.running。
  3. 检查文件类型：DevTools默认只监控classpath下的文件变化。确保你修改的是src/main/java,src/main/resources等目录下的文件。修改pom.xml需要手动重启。
  4. 手动触发：如果自动重启不生效，可以尝试在项目运行时，使用快捷键Ctrl+F9（Windows/Linux）或Cmd+F9（Mac）手动触发项目构建，这通常能引起DevTools的重启。
  5. 查看日志：在启动日志中搜索restartedMain关键字。如果DevTools正常工作，在重启后你会看到日志开头是[restartedMain]而不是[main]。

6.3 端口被占用或启动缓慢

问题描述：启动时报错Web server failed to start. Port 8080 was already in use.或者启动时间异常漫长。

解决方案：

  • 端口占用：
    1. 在application.yml中修改server.port，例如改为8081。
    2. 查找并关闭占用8080端口的进程。在命令行中执行：
      • Windows:netstat -ano | findstr :8080找到PID，然后taskkill /PID <PID> /F
      • Linux/Mac:lsof -i:8080找到PID，然后kill -9 <PID>
  • 启动缓慢：SpringBoot应用首次启动或添加新依赖后启动较慢是正常的，因为需要加载类和初始化上下文。如果每次启动都很慢，可以：
    1. 检查Maven镜像配置，确保使用的是国内镜像。
    2. 关闭一些不必要的启动时检查，例如在application.yml中添加spring.main.lazy-initialization=true开启懒加载（但需注意其副作用，某些Bean过早初始化可能导致问题）。
    3. 使用-Dspring.profiles.active=dev确保启动的是开发环境配置，避免加载生产环境的重型组件。

6.4 集成其他常用组件提示

根据热搜词，很多同学关心如何集成其他组件。这里给出一些快速指引：

  • 整合MyBatis（非Plus）：如果使用原生MyBatis，需要在application.yml中配置mybatis.mapper-locations（XML文件位置）和mybatis.type-aliases-package（实体类别名包）。并在每个Mapper接口上使用@Mapper注解。
  • 配置HTTPS：需要生成或获取SSL证书（.jks或.p12文件），然后在application.yml中配置server.ssl相关属性。
  • 集成Redis：添加spring-boot-starter-data-redis依赖，在application.yml中配置spring.redis.host,port,password等。Spring Boot会自动配置RedisTemplate和StringRedisTemplateBean。
  • 集成WebSocket：添加spring-boot-starter-websocket依赖，然后创建一个配置类使用@EnableWebSocketMessageBroker来启用代理式WebSocket支持。
  • 多线程/异步任务：使用@Async注解，并配合@EnableAsync在主类上启用异步支持。注意需要自定义ThreadPoolTaskExecutorBean来配置线程池。
  • 文件上传：Spring Boot默认集成了文件上传功能。在application.yml中配置spring.servlet.multipart.max-file-size和max-request-size来处理大文件。在Controller中使用@RequestParam("file") MultipartFile file接收文件。

这些集成通常遵循“添加依赖 -> 添加配置 -> 使用注解或模板类”的模式。遇到具体问题时，查阅对应组件的官方文档或Spring Boot官方文档是最可靠的途径。

7. 项目打包与部署简析

开发完成后，我们需要将项目打包部署。Spring Boot的打包方式非常简单。

7.1 使用Maven打包

在IDEA右侧的Maven工具窗口中（如果没看到，点击View->Tool Windows->Maven），找到你的项目，展开Lifecycle，双击package。Maven会执行编译、测试、打包等一系列操作。

打包完成后，在项目的target目录下，你会找到生成的jar包，名称格式为{artifactId}-{version}.jar（例如demo-0.0.1-SNAPSHOT.jar）。这个jar包是可执行的，因为它内嵌了Tomcat服务器和所有依赖。

7.2 运行与部署

本地运行：打开命令行，进入target目录，执行java -jar demo-0.0.1-SNAPSHOT.jar。你可以通过--spring.profiles.active=prod参数指定运行环境：java -jar demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod。

生产环境部署：通常有几种方式：

  1. 直接运行Jar包：最简单的方式，如上面所示。配合nohup（Linux）或服务包装（如 systemd, Windows Service）使其在后台运行。
  2. Docker容器化：编写Dockerfile，将jar包复制到镜像中运行。这是目前最主流、最推荐的方式，能保证环境一致性。
    FROM openjdk:8-jre-alpine COPY target/demo-0.0.1-SNAPSHOT.jar app.jar ENTRYPOINT ["java", "-jar", "/app.jar"]
    然后构建镜像并运行：docker build -t demo-app .和docker run -p 8080:8080 demo-app。
  3. 传统WAR包部署到外部Tomcat：虽然Spring Boot推荐内嵌容器，但你也可以修改pom.xml中的<packaging>为war，并让主启动类继承SpringBootServletInitializer，然后像传统Web项目一样部署到独立的Tomcat、Jetty等服务器。

关于部署的热搜词补充：jekins 部署 springboot 几种方式指的是使用Jenkins进行持续集成/持续部署(CI/CD)。基本流程是：Jenkins从Git仓库拉取代码 -> 执行Maven构建命令（mvn clean package） -> 通过SSH或Docker插件将jar包或镜像部署到目标服务器。这涉及到Jenkins的Pipeline脚本编写、服务器权限配置等，是一个更高级的话题。

从IDEA 2020创建一个SpringBoot项目开始，到完成一个具备基础CRUD、分页查询、多环境配置和热部署的Web应用，整个过程看似步骤不少，但每一步都有其明确的目的。关键在于理解每个配置和注解背后的意图，而不是机械地复制粘贴。IDEA 2020作为一个成熟的IDE，为这个过程提供了极大的便利，从智能的代码提示到集成的Spring Initializr，再到强大的调试和重构工具。

在实际工作中，这个基础骨架会随着业务复杂度的增加而不断演进。你可能会引入Spring Cloud进行微服务治理，集成Redis做缓存，使用Elasticsearch做搜索，或者用Spring Security做权限控制。但无论如何，在IDEA中熟练创建、配置、运行和调试一个SpringBoot项目，是你Java开发生涯中一项扎实的基本功。当你下次再看到“IDEA创建SpringBoot项目”这个标题时，希望你的脑海里浮现的不再是简单的点击操作，而是对项目结构、依赖管理、配置体系和工具链的全局理解。

网站建设 视觉设计 SEO优化
返回列表