Spring Boot项目搭建全指南：从JDK环境到自动装配原理

上个月带一个刚转行的新人，他问我的第一句话是：“哥，Spring Boot项目怎么搭啊？我照着网上的教程配了一天都没跑起来。”我过去一看，好家伙，电脑装的是JDK 8，却跟着JDK 17加Spring Boot 3的教程在敲，代码里还全是javax开头的包，项目根本编译不过。

这种画面我太熟了。每年都有新人卡在“搭建”这一步，不是不会写Java，而是被环境、版本、项目结构、配置概念这些围墙挡住了。这篇文章就是把我这些年带新人的经验压成一份能照着做的清单：从装JDK开始，把第一个Spring Boot项目跑起来，再顺手搞懂它背后的自动装配到底是怎么回事。看完你至少能明白，为什么同样的代码在别人电脑上能跑，到你这就报一堆红叉。

1. 为什么Spring Boot是新手入门的首选框架

1.1 Spring时代的新手噩梦：光配置就能劝退一批人

在Spring Boot出现之前，做Java Web开发是另一番景象。你写一个简单的增删改查，得先搭SSM（Spring + SpringMVC + MyBatis）或者SSH（Spring + Struts + Hibernate）框架。搭框架意味着什么？你得手动去配置一堆XML文件，什么web.xml、spring-mvc.xml、spring-mybatis.xml，每个文件里几十行标签，配错一个namespace就启动失败。

更折磨人的是jar包依赖。老项目里没有Maven的自动依赖管理，你要自己去搜各种版本的jar包，再一个一个丢进lib目录。Spring、MyBatis、数据库驱动、连接池、日志库，任何两个库版本不兼容，启动时直接抛NoSuchMethodError或者ClassNotFoundException。新手光排这个版本冲突就能排一个下午，一天下来Hello World都没见着。

1.2 两大杀手锏：起步依赖和自动配置

Spring Boot之所以能让新手快速上手，核心就两个东西：起步依赖（Starter）和自动配置（Auto Configuration）。

起步依赖很好理解。以前你要用Web开发，得自己找Spring MVC、Jackson、Tomcat等一堆依赖；现在只要在pom.xml里加一个spring-boot-starter-web，框架会把这一套相关的库全部打包引进来，而且版本已经替你对齐好了。你不需要关心Tomcat该配哪个版本、Jackson要不要升级，Starter内部已经帮你把兼容性处理完了。

自动配置更厉害。你想想，为什么加一个starter-web依赖，项目启动完就能直接接收HTTP请求？按老Spring的玩法，得配置DispatcherServlet、视图解析器、静态资源映射……Spring Boot的做法，是扫描classpath里的类，发现这个项目里有Spring MVC的类，它就自动把DispatcherServlet、默认的JSON转换器、静态资源映射全都给你配好。你写一个@RestController加上一个@RequestMapping，接口就能跑了。

这两件事合起来，用一个生活化的类比就是：以前你攒台式机，要自己去研究CPU配什么主板、电源多少瓦、内存条兼容不兼容；Spring Boot是直接给你一台品牌机，插上电就能用，你只需要考虑装什么软件。

1.3 新手正确的学习姿势：先跑通，再深挖

所以我给新人的建议一直是：别一上来就啃《Spring Boot实战》或者源码解析，先花半天时间把项目搭起来、让一个接口返回数据，建立“原来如此”的正反馈。等跑通了，再回头问为什么。这篇文章的章节顺序也是按这个思路排的，先把环境选好，把项目建起来，最后再拆解自动配置的原理。

2. 开工前把JDK、Maven、IDE选对，后面少踩一半坑

2.1 JDK版本别乱选：为什么“Spring Boot版本太高”会编译失败

先说版本搭配，这是新手最容易踩的坑，也是网上一搜一大片“Spring Boot版本太高”报错求助的根本原因。

Spring Boot 2.x系列（目前最常用的是2.7.18，这是2.x的最后一版）要求JDK 8及以上。注意是JDK 8，不是JDK 11。Spring Boot 3.x系列要求JDK 17及以上。也就是说，如果你电脑装的是JDK 8，项目用的Spring Boot 3.2，那编译必然失败，因为3.x的字节码跑在JDK 8上直接报“UnsupportedClassVersionError”。

这不是Spring Boot的问题，是JDK版本跨度太大连基础类库都换了。Spring Boot 3.x全面使用Jakarta EE 9命名空间，以前代码里写的javax.servlet包名全部变成了jakarta.servlet。网上大量老教程、老项目代码还是javax开头，你哪怕只复制一个HttpServletRequest进来就会标红。

我给新手的版本组合建议就两条：

方案	JDK版本	Spring Boot版本	适用场景
保守稳妥	JDK 8	2.7.18	跟着多数老教程学、维护公司老项目
常规推荐	JDK 17	3.2.x或3.3.x	新项目起步、长期更新维护

纯新手我直接推荐JDK 17加Spring Boot 3.2.x。JDK 17是长期支持版本，网上新出的教程和开源项目已经大量切到这套组合，跟着学不吃亏。JDK 8组合唯一的优势是兼容老教程，但它已经在走下坡路，没必要逆着趋势走。

2.2 Maven装好只算一半，镜像配置才是亲妈

Maven的作用，简单说就是“依赖管家”。你告诉它项目需要哪些库，它从中央仓库下载并管理版本。对新手来说，装Maven之后第一件事不是高兴，而是配国内镜像源，否则从Maven Central下载依赖堪比早年拨号上网，一个Spring Boot项目光依赖jar包就要下载上百兆，等半小时是常事。

打开Maven安装目录下的conf/settings.xml，或者用户目录~/.m2/settings.xml，在<mirrors>节点里加一段：

<mirror> <id>aliyunmaven</id> <mirrorOf>central</mirrorOf> <name>阿里云公共仓库</name> <url>https://maven.aliyun.com/repository/public</url> </mirror>

然后要确认IDEA用的就是这份settings.xml。打开IDEA的Settings（Windows下按Ctrl+Alt+S），搜“Maven”，看User settings file路径对不对，对完再点一下“Override”。很多新人配置了镜像但IDEA没指向这个配置，照样慢。

验证环境是否装好，命令行敲两条命令：

java -version mvn -v

两条都能正常输出版本信息，环境就算通了。注意java -version显示的如果是1.8，那你就老老实实用Spring Boot 2.7.18，别硬上3.x。

2.3 IDEA安装与几个值得装的小插件

开发工具直接用IntelliJ IDEA，社区版免费版就足够学习用了。新版社区版的New Project向导也内置了Spring Initializr，不用额外装插件。如果觉得向导不顺溜，也没关系，后面第三章我会给出网页版生成方案。

插件方面，基础三件套推荐装上：Lombok（社区版需要手动装，Ultimate版内置）、Rainbow Brackets（彩色括号，嵌套看得清）、MyBatisX（以后整合MyBatis用）。插件装完重启，环境准备工作就结束了。

3. 两种方式生成项目骨架：网页版和IDEA向导

3.1 网页版开局：start.spring.io上每一步怎么填

项目骨架生成，最稳的方式是用Spring官方提供的初始化服务。浏览器打开start.spring.io，页面上所有字段的含义我逐个说明白。

Project选“Maven”，Language选“Java”，Spring Boot版本按你JDK版本选对应的（JDK 17就选3.2.x或3.3.x）。Group是组织的域名反写，一般填com.example就行，Artifact是项目名，填demo。依赖面板里搜“Spring Web”，加进去。这个依赖提供Web开发所需的全套环境，包括内嵌Tomcat和Spring MVC，是最核心的起步依赖。顺手还可以加一个“Spring Boot DevTools”，这个工具能实现改完代码自动重启，省得每次手动起服务。

填完之后点GENERATE，浏览器会下载一个zip压缩包。解压后不要直接双击pom.xml，要用IDEA的Open功能打开：选到解压后的目录，IDEA识别到里面有pom.xml，就会以Maven项目方式导入。

国内网络如果访问start.spring.io不稳定，也可以把初始化服务的地址换成阿里云的构建地址start.aliyun.com，方法和官方站完全一样，就是界面和可选的依赖版本会稍有差异，版本可能比官方旧一些。

3.2 IDEA自带向导：填同样的信息，少一次解压

如果你已经在IDEA里了，更快的办法是直接用内置向导。File → New → Project，左侧选“Spring Boot”（旧版叫Spring Initializr），右侧填写的信息和网页版几乎一一对应。

这里有个小差异要提醒：IDEA向导里的Server URL默认是官方地址，如果你前面给IDEA配置了HTTP代理或者网络不好，可以在向导页面最底部的“Server URL”把它改成https://start.aliyun.com，效果是一样的。

依赖勾选方式在IDEA里更直观，左边分组、右边搜索，勾完点Create，IDEA会直接帮你把项目创建好并开始下载依赖。第一条建议还是和上面一样：Spring Web必加，DevTools建议加。

3.3 导入项目的常见误区与首次依赖下载等待

第一次用IDEA打开Spring Boot项目，底部会有一个进度条在走，那是Maven在下载依赖。这个阶段最忌手贱去点“尝试把标红的依赖手动改成别的版本”。我第一次带新人时，他就看着spring-boot-starter-web标红，去改了版本号，结果整个项目的依赖树全乱了。

正确的做法是等进度条走完，如果某个依赖还是红色，在IDEA右侧Maven窗口点一下刷新（Reimport）按钮，或者清理一下本地仓库缓存：

mvn clean install -U

第一次下载会比较久，耐心等。网络正常的国内环境配合阿里云镜像，一般三到五分钟能搞定。下载完在项目里能找到spring-boot-starter-web-3.2.x.jar文件，说明依赖到位了。

4. 建好的项目一堆文件夹，每个到底干什么用的

4.1 从上到下一张图看懂目录树

项目创建成功之后，点开左侧的Project窗口，你会看到这样一棵目录树：

demo ├── src │ ├── main │ │ ├── java │ │ │ └── com/example/demo │ │ │ ├── DemoApplication.java │ │ │ ├── controller/ │ │ │ ├── service/ │ │ │ ├── dao/ │ │ │ └── entity/ │ │ └── resources │ │ ├── static/ │ │ ├── templates/ │ │ └── application.properties │ └── test │ └── java/com/example/demo │ └── DemoApplicationTests.java ├── pom.xml └── mvnw / mvnw.cmd

一眼看去东西不多，但每个位置都有讲究。src/main/java是你写Java代码的地方；src/main/resources放配置文件和静态资源；src/test/java放单元测试代码；pom.xml是Maven的“项目配置清单”。

4.2 启动类：你写的main方法到底干了什么

DemoApplication.java是整个项目的启动入口，代码长这样：

package com.example.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }

新手最容易忽略的是@SpringBootApplication这个注解。它不是一个普通注解，而是三个注解的组合体：@SpringBootConfiguration（表示这是一个配置类）、@EnableAutoConfiguration（开启自动配置，这个后面第七章细讲）、@ComponentScan（开启组件扫描）。组件扫描的意思是Spring会自动去找当前包和子包下面所有的@Component、@Controller、@Service、@Repository注解的类，注册成Bean。所以启动类必须放在所有包的最顶层，比如com.example.demo，让它能扫到com.example.demo.controller等子包。

4.3 为什么大家都把代码写成controller/service/dao

项目创建出来时，controller、service、dao这些目录是不存在的，需要你自己建。这是Java Web开发里约定俗成的分层方式，不是Spring Boot强制的，但强烈建议新手从一开始就遵守。

• controller：接收HTTP请求，把参数交给Service层处理，再把结果返回给前端
• service：写业务逻辑，比如下单、计算价格、校验库存
• dao：数据访问层，操作数据库
• entity：实体类，数据库表映射成的Java对象

这么分层的好处是：改前端接口，不用动数据库代码；换数据库，也不用动Controller代码。等你项目写到几百个类的时候，才会体会到这个约定多省心。当然，有基础后你还会接触Maven多模块（Modules）拆分，把公共模块、业务模块、接口模块单独拆成子工程。新手阶段先别折腾多模块，一个模块里分好包就够了。

5. 亲手写第一个接口，把项目跑起来

5.1 第一个接口代码：每个注解都拆开讲

在com.example.demo.controller包下新建一个类，名叫HelloController，代码如下：

package com.example.demo.controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.time.LocalDateTime; import java.util.HashMap; import java.util.Map; @RestController @RequestMapping("/api") public class HelloController { @GetMapping("/hello") public String hello() { return "Hello, Spring Boot!"; } @GetMapping("/time") public Map<String, Object> time() { Map<String, Object> result = new HashMap<>(); result.put("time", LocalDateTime.now().toString()); return result; } }

这里面的注解挨个说清楚。

@RestController是@Controller和@ResponseBody的组合，意思是这个类的每个方法返回值都会直接写入HTTP响应体，而不会走视图解析器。换句话说，你返回字符串“Hello, Spring Boot!”，浏览器就原样收到这段文字；返回一个Map，Spring Boot会自动帮你转成JSON格式。

@RequestMapping("/api")标在类上，表示这个类下所有接口的URL前缀都是/api。@GetMapping("/hello")标在方法上，表示当浏览器通过GET请求访问/api/hello时，调用这个方法。

这里有一个新手常见的困惑：为什么写个普通Java方法，浏览器就能直接访问到？因为spring-boot-starter-web里内嵌了Tomcat，Spring MVC又在后台自动完成了一套请求映射机制，把/api/hello这个URL和hello()方法关联起来了。这不需要你配置任何路由文件，也是Spring Boot的“约定优于配置”思想的体现。

5.2 从启动到浏览器出结果的全过程

写好Controller后，运行DemoApplication的main方法。注意控制台输出的日志，重点找这一行：

Tomcat started on port 8080 (http) with context path ''

出现这行说明Web服务已经在8080端口跑起来了。然后打开浏览器访问http://localhost:8080/api/hello，页面上会显示“Hello, Spring Boot!”。再访问http://localhost:8080/api/time，就能看到类似这样的JSON：

{"time":"2025-03-14T10:23:45.123"}

从零到接口通，前后不超过十分钟。这就是Spring Boot的价值：你只管写业务方法，服务端的启动、请求路由、JSON序列化这些脏活，框架全包了。

5.3 想换端口？两个地方任你改

Tomcat默认跑在8080端口，如果这个端口被占用了，启动会报错。改端口的方式是在src/main/resources/application.properties（或者以后用application.yml）里加一行：

server.port=8081

改完重新启动，访问地址变成http://localhost:8081/api/hello。配置文件的作用就是你不用改代码也能调整运行行为，这是后续项目开发的日常操作。

6. 配置文件的正确用法：从properties到yml多环境

6.1 yml和properties怎么选：我建议新手直接用yml

Spring Boot支持两种配置文件格式：application.properties和application.yml。两者功能完全一样，区别只在写法。

properties是键值对形式，写起来平铺直叙：

server.port=8080 spring.application.name=demo logging.level.com.example.demo=debug

yml是用缩进表示层级结构，看起来清爽很多：

server: port: 8080 spring: application: name: demo logging: level: com.example.demo: debug

我推荐新手直接用yml。理由很简单：配置多的时候yml的层级关系一目了然，不用反复看前缀有没有写错。唯一要注意的是yml对缩进极其敏感，同一个层级的配置必须对齐，用了Tab键容易出问题。IDEA通常会自动把Tab转成空格，问题不大。

6.2 自定义配置项：@Value还是@ConfigurationProperties

框架配置可以写在yml里，你自己的业务配置也可以。假设你想配置一个文件上传的保存路径，在yml里写：

app: upload-dir: /data/files max-size: 10485760

读取方式有两种。

第一种，用@Value注解直接注入单个值：

@Value("${app.upload-dir}") private String uploadDir;

第二种，用@ConfigurationProperties绑定一组配置，适合多个配置项需要集中管理的情况：

@Component @ConfigurationProperties(prefix = "app") public class AppConfig { private String uploadDir; private Long maxSize; // 注意必须提供getter和setter }

第二种写法的好处是IDE可以自动提示属性名，配置错了编译期就能发现。两种方式看个人习惯，我的建议是配置项超过两个就用@ConfigurationProperties，一个两个直接用@Value省事。

6.3 多套环境切换：dev、test、prod怎么管理

项目开发到一定阶段，你会有多套运行环境：本地的dev环境、测试服务器环境、生产环境。每套环境的数据库地址、日志级别、上传路径都不一样。

Spring Boot的解决方案是按环境拆配置文件，命名规则是application-环境名.yml。比如：

• application-dev.yml：本地开发，数据库连本机
• application-test.yml：测试环境
• application-prod.yml：生产环境，日志级别设为error

然后主配置文件application.yml里指定激活哪套：

spring: profiles: active: dev

启动时还可以用命令行参数强制覆盖：

java -jar demo.jar --spring.profiles.active=prod

这样同一份代码，在不同环境只需要切换一个参数就行。新手可能暂时用不到多环境，但这是以后入职必会的技能，提前建好习惯不吃亏。

7. 自动装配原理通俗版：没有XML，Bean是怎么冒出来的

7.1 点开@SpringBootApplication的三层皮

新手跑通项目之后，多半会好奇：我明明没有配置任何Bean，Tomcat哪来的？Controller怎么被发现的？回答这些问题，就要看@SpringBootApplication这个注解的底层。

按住Ctrl点进注解源码，你会看到它上面标记了三个注解：

• @SpringBootConfiguration：本质就是@Configuration，告诉Spring这是一个配置类
• @EnableAutoConfiguration：自动配置的总开关
• @ComponentScan：组件扫描的启动器

其中最关键的是@EnableAutoConfiguration。点进它的源码，能看到它用@Import导入了一个叫AutoConfigurationImportSelector的类。这个类做的事情，用一句话概括：去classpath下一个特定的配置清单文件里，把里面写的所有自动配置类全部读出来，然后一个一个判断当前项目是否需要。

7.2 自动配置的执行链路

在Spring Boot 3.x里，这份自动配置的清单存放在每个自动配置jar包内的META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件里（2.x是在META-INF/spring.factories里）。

打开类似spring-boot-autoconfigure这个jar包里的imports文件，你会发现里面有几百个类的全限定名，什么RedisAutoConfiguration、DataSourceAutoConfiguration、WebMvcAutoConfiguration、HttpMessageConvertersAutoConfiguration等等，全部列在那里。

Spring Boot启动时，AutoConfigurationImportSelector把这些类名全部读取出来，再按顺序执行每个类。但执行不是无条件执行，每个自动配置类上面都有一堆条件注解把关。

7.3 @Conditional条件注解：看不见的配置控制器

Spring Boot有一整套@Conditional开头的注解，专门用来做“有条件的装配”：

• @ConditionalOnClass：classpath里有这个类才装配
• @ConditionalOnMissingBean：容器里没有这个Bean才配置
• @ConditionalOnProperty：配置项满足指定值才生效
• @ConditionalOnWebApplication：是Web应用才装配

举个例子，RedisAutoConfiguration上就标注了类似@ConditionalOnClass(RedisOperations.class)，意思是：只有你的项目引用了Redis相关的jar包（classpath里存在RedisOperations类），这个自动配置类才会生效，才会帮你创建RedisTemplate、StringRedisTemplate这些Bean。

这就能解释一个让新手觉得“神奇”的现象：你在pom里加了spring-boot-starter-data-redis依赖，然后直接在Service里注入StringRedisTemplate就能用。根本不用写任何配置类，因为框架一看你项目里有Redis的jar包，自动把该配的Bean全部配好了。这个“看菜下饭”的逻辑，就是自动装配的精髓。

7.4 明白原理之后，你能少踩哪些坑

理解自动装配不是纸上谈兵，它能直接帮你排查两类常见问题。

第一类：明明加了依赖，Bean却注入不进来。这时候去翻自动配置类的条件注解，看是哪个条件没满足。比如@ConditionalOnProperty要求配置文件里必须有某个配置项，你没写，自动配置就不生效。

第二类：想自定义Bean但框架的默认配置和你冲突。比如你想自己定义RestTemplate，容器里已经有了一个默认的，你就要搞清楚@ConditionalOnMissingBean的语义，想办法让你的Bean覆盖它。

这类面试也爱考（“Spring Boot自动装配原理”是高频题），能把AutoConfigurationImportSelector读取imports文件、条件注解把关这一整套链路讲明白，基本就过了。

8. 新手高频踩坑记录：从版本混搭到404排查思路

8.1 版本混搭：JDK 8配Spring Boot 3.x的连环报错

现象：项目编译报错，控制台一堆java: 无法访问org.springframework.boot.SpringApplication或者UnsupportedClassVersionError，IDE里也明显标红。

原因：Spring Boot 3.x编译出的class文件要求JDK 17才能运行，而你装的是JDK 8。加上javax.servlet改成jakarta.servlet，老代码在新项目里直接找不到类。

排查链路：先看java -version确认JDK版本，再看pom.xml里spring-boot-starter-parent的版本号。如果JDK是1.8而Spring Boot是3.x开头，要么把JDK升级到17，要么把Spring Boot降到2.7.18。两个选一个，不要试图改代码适配版本，新人生涯的容错率经不起这么折腾。

8.2 端口冲突：启动页闪现然后退出

现象：启动日志里出现Web server failed to start. Port 8080 was already in use.，然后进程退出。

原因很简单：8080端口已经被其他程序占用。排查方法分系统给：

• Windows：命令行执行netstat -ano | findstr 8080，找到占用8080的PID，然后taskkill /PID 进程号 /F
• macOS/Linux：执行lsof -i:8080，拿到PID后kill -9 进程号

处理完重新启动，或者干脆按第五章说的把端口改成8081。这里有个小经验：本地开发时一个项目经常起多个实例调试，直接把默认端口改掉，比每次去杀进程省事。

8.3 访问404：包扫描范围问题最隐蔽

现象：项目正常启动，浏览器访问接口却返回404，或者Spring Boot自带的Whitelabel Error Page。

原因有几种，按概率排序：

1. 请求路径写错。@RequestMapping("/api")加@GetMapping("/hello")，访问的URL必须是/api/hello，少个/api就404。
2. Controller类没有加@RestController或者@Controller注解，Spring根本不知道这是个处理请求的类。
3. 启动类的位置放错了。如果DemoApplication放在com.example.demo里，而Controller放在com.example.controller（和启动类不同级也不是子包），@ComponentScan默认扫不到，Controller就没注册进去。

排查链路：先在浏览器确认URL路径，再去Controller类看注解，最后看包结构。对新手来说，包结构出错最坑，因为IDE不报错，启动日志也没异常，只有访问时才知道坏了。

8.4 Maven私服慢和IDE爆红的应急清单

Maven第一次下载慢的问题前面说过了配镜像，但配置完之后IDEA里可能还有一堆依赖标红。这时别慌，按顺序处理：

1. 检查settings.xml位置是否被IDEA识别（Settings → Maven → User settings file）
2. 在Maven工具窗口点刷新Reimport，强制重新解析依赖
3. 如果还不行，命令行执行mvn clean install -U，强制更新快照
4. 最后大招：删除本地仓库~/.m2/repository里对应报错的目录，重新下载

我遇到过一次很诡异的情况：某依赖在IDEA里标红，但命令行mvn compile能正常通过。后来发现是本地仓库里jar包损坏，删掉重新下就好了。这类问题本质上不是代码问题，是下载中断导致的文件不完整，重下的思路方向是对的。

9. 项目搭完还能往哪走：打包、部署和进阶方向

9.1 打成可执行jar包，命令行直接跑起来

项目跑通之后，第一个进阶动作是把它打包成可执行的jar文件。在项目根目录执行：

mvn clean package

或者用项目自带的Maven Wrapper：

./mvnw clean package

打包完成后，target目录下会生成一个demo-0.0.1-SNAPSHOT.jar。这个jar包有点特殊，spring-boot-maven-plugin会把它重构成一个可执行jar，内部包含内嵌Tomcat和所有依赖。在服务器上执行：

java -jar demo-0.0.1-SNAPSHOT.jar

你的Spring Boot项目就脱离IDEA跑起来了。这一步的意义是让新手理解：这个项目本质上就是一个Java程序，不需要什么特殊的Web容器，JDK就是它唯一的运行环境。

9.2 Dockerfile部署：一台新服务器一条命令启动

打包成jar后，最顺理成章的下一步是容器化部署。写一个最简单的Dockerfile：

FROM openjdk:17-jdk-slim WORKDIR /app COPY target/demo-0.0.1-SNAPSHOT.jar app.jar EXPOSE 8080 ENTRYPOINT ["java", "-jar", "app.jar"]

然后在项目根目录执行：

docker build -t demo:1.0 . docker run -d -p 8080:8080 demo:1.0

用docker ps看到容器已经在运行，访问服务器的http://IP:8080/api/hello就有响应。如果你用的是宝塔面板这类可视化工具，里面也有Docker管理器，把镜像构建好后通过面板直接创建容器，步骤大同小异。这一步走通后，你的项目就具备了上云的雏形，云服务器上装好JDK或Docker，把jar包传上去就能跑。

9.3 进阶方向：定时任务、中间件、前端整合

项目跑通加部署链路通了之后，很多新人会陷入“接下来学什么”的迷茫。我的建议是按项目需求驱动，这里列几个高频方向。

定时任务是开发里最常见的需求，Spring Boot实现起来极简。先在启动类上加@EnableScheduling注解，再写一个类：

package com.example.demo.task; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import java.time.LocalDateTime; @Component public class ScheduledTask { @Scheduled(cron = "0/5 * * * * ?") public void runEveryFiveSeconds() { System.out.println("定时任务执行：" + LocalDateTime.now()); } }

Cron表达式网上有生成工具，照着填就行。每次项目启动后，每隔5秒就会触发一次任务。

中间件整合也是重头戏。搜“Spring Boot整合ActiveMQ”“Spring Boot整合Flink”、或者接一些国内外的ASR语音识别接口（这类需求网上都有现成的starter或SDK），套路基本一致：加对应starter依赖，写配置，用Spring Boot的Template类或者SDK客户端直接调用。等你亲手整合过两三个中间件，就会真正理解“自动配置”给你省了多少事。

前端整合再提一种常见玩法：Vue项目执行npm run build之后生成的dist目录，直接拷贝到项目的src/main/resources/static下面，重新打包启动，前端页面和后端接口就同端口访问了。适合前后端都由一个人搞的小项目。正式团队更推荐前后端分离部署，前端用Nginx，后端用jar或Docker，各管各的。

说到最后，我每次带新人都会强调一句话：Spring Boot搭建本身不是目的，搞清楚它替你做了什么，才是成长最快的路径。骨架跑通之后，花一个下午把自动配置那一整条链路读一遍源码，把@SpringBootApplication的每个子注解都点进去看看，比机械地“搬运下一个功能”有价值得多。这个项目搭起来了，你就已经踩在Spring Boot最宽的那条大道上了。