创建日期：2026-09-08 ｜ 最近更新：2026-09-08 版本事实核对自 Maven Central 与 start.spring.io（本机可访问）：当前稳定主线 Spring Boot 4.1.1，JDK 基线 17（start.spring.io 默认，另提供 21/25/26）。 ⚠️ 诚实声明：本机只有 JDK 11、无 Maven，Spring Boot 4 需要 JDK 17+，所以本文代码没有在本机跑过。 代码按 Boot 4.1 / Jakarta 生态的官方 API 编写，命令与版本以官方为准，跑前请用 start.spring.io 生成一份当前版本骨架对照。不伪装「实测输出」。

Spring & Spring Boot 入门：用 Boot 写出第一个 REST 服务

一句话：Spring Boot 是「把 Spring 包好的脚手架」——你不用先精通 Spring Framework 的 IoC 容器、装配、AOP，也能在十几分钟里跑起一个带分层、能配置、能打包的 Web 服务；但它藏起来的东西（依赖注入、Bean 生命周期、自动配置原理）正是你进阶时迟早要回去补的 Spring Framework。这个系列就从「先用起来」开始，需要时再把背后的 Spring 概念一个个拆开。

本文定位

本系列第 0 篇（入门），目标是让 JVM 新人或回坑的人，30 分钟跑起第一个 Spring Boot 服务，并一次理清三件事：

Spring 家族的名份：Framework / Boot / Data / Security / Cloud / AI 各自管什么，别一上来就被吓到；
Boot 到底帮你省了什么：脚手架、起步依赖、自动配置、内嵌容器、外部化配置、健康检查；
它藏起来的 Spring 长什么样：@SpringBootApplication、@Service、@RestController 背后对应 Framework 的哪些机制，给后续系列铺路。

计划中的学习路径：

篇	主题	状态
0	入门：家族名份 + 第一个 REST 服务 + Boot 藏了什么（本文）	✅
1	Spring Framework 核心：IoC / 依赖注入 / Bean 生命周期	待写
2	配置体系：`application.yml`、`@ConfigurationProperties`、profile、外部化	待写
3	Web 深入：参数绑定、校验、异常处理、拦截器	待写
4	数据：Spring Data JDBC / JPA 的取舍与起步	待写
5	测试与 Actuator：把服务调到「敢上线」	待写

1. 先理清「Spring 家族」的名份

你会看到一堆以 Spring 打头的东西，它们其实是分层的：

Spring AI            ← 让 Spring 应用接 LLM/agent（2025 后热起来）
Spring Cloud         ← 微服务套件（服务发现/配置中心/网关…）
Spring Data / Security / Batch / Session  ← 各领域能力，按需引入
─────────────────────────────────────────────
Spring Boot          ← 「脚手架层」：自动配置 + 起步依赖 + 内嵌容器 + Actuator
Spring Framework     ← 「地基」：IoC 容器 / 依赖注入 / AOP / 事务抽象
─────────────────────────────────────────────
JDK（17+）            ← Boot 4 / Framework 7 的基线

Spring Framework：真正做「核心」的那个。它最大的功劳是 IoC 容器——你声明「这是个 Bean（服务/组件）」，容器负责创建、装配依赖、管理生命周期；你写的代码不 new、不找依赖，只管用。
Spring Boot：不替代 Framework，而是把它藏起来。它负责让你「少配能用」：按依赖自动装配（你在 pom 里加 web，它自动配好内嵌 Tomcat + DispatcherServlet）、外置配置、健康检查、一键打包成可执行 jar。
其余（Data / Security / Cloud / AI）都是在上面两层的领域能力，入门阶段一概不用管。

记忆锚点：Boot = 「能跑起来的 Spring 的速成外壳」；Framework = 「Boot 藏起来的那层内核」。用 Boot 写业务没问题，但面试、调优、看懂日志、理解别人写的 @Configuration，都要回 Framework。

版本线（2026-09 核对）：Boot 3.5.x（收尾到 3.5.16，OSS 支持已于 2026-06 结束）→ Boot 4.x（当前主线 4.1.1，基于 Spring Framework 7 / JDK 17+ / Jakarta EE 11）。新项目直接上 4.1，别再开 3.x。

2. 环境：先把地基说清楚

项	要求
JDK	17 起步，官方推荐 21 / 25（长期支持）；本文示例按 21 写
构建	Maven 3.9+（推荐用项目自带的 `mvnw` wrapper，不用单独装）或 Gradle
IDE	不强求；IntelliJ 社区版 / VS Code + Java 插件都行
网络	首次构建要能访问 Maven Central

如果你跟我一样只有旧 JDK，先把 JDK 升上来再继续（本文机器是 JDK 11，故未能实跑；macOS 上用 Homebrew 一条命令，下面命令未在本机执行，仅为给你参考）：

brew install --cask temurin@21     # JDK 21
java -version                       # 应显示 21.x

3. 三分钟：用 start.spring.io 生成骨架

不用记初始化的咒语，直接浏览器开 start.spring.io（或命令行 curl 它），选：

Project：Maven
Language：Java
Spring Boot：4.1.1（默认即此）
Group / Artifact：如 com.example / hello
Packaging：Jar
Java：21
Dependencies（点着加）：Spring Web、Spring Boot Actuator、Spring Boot DevTools、Validation（Web/DevTools/Actuator 就够第一篇跑）

点 Generate 下载 zip，解压后用 ./mvnw 跑。生成的工程自带 mvnw/mvnw.cmd（Maven wrapper），你机器上没有 Maven 也不影响。

生成的 pom.xml 只需要看懂三块（其余是元数据）：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.1.1</version>
    <relativePath/>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>   <!-- Web：内嵌 Tomcat + MVC -->
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId> <!-- 健康/指标端点 -->
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>      <!-- 热重启（仅开发） -->
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>  <!-- 打包成可执行 jar -->
        </plugin>
    </plugins>
</build>

读懂 starter 是第一步：spring-boot-starter-web 一个坐标背后拉进了一整组依赖（spring-webmvc、内嵌 Tomcat、Jackson…），并激活对应的自动配置。这就是 Boot 的「起步依赖 + 自动配置」——加依赖即加能力。

4. 生成的目录长什么样

hello/
├─ pom.xml
├─ mvnw / mvnw.cmd                     # Maven wrapper
└─ src/
   ├─ main/java/com/example/hello/
   │  └─ HelloApplication.java         # 唯一必须有的类 = 入口
   ├─ main/resources/
   │  └─ application.properties        # 配置文件（常用 .yml）
   └─ test/java/com/example/hello/
      └─ HelloApplicationTests.java

入口类（放包根目录，这是约定，别乱挪）：

package com.example.hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class, args);
    }
}

@SpringBootApplication 一个注解顶三个：@SpringBootConfiguration（这是一个配置类）+ @EnableAutoConfiguration（让 Boot 按 classpath 里的依赖自动装配）+ @ComponentScan（扫描本包及其子包的 @Component/@Service/@Controller… 收进容器）。

5. 第一个接口 + 顺手做成分层

新建三个文件，全部放在 HelloApplication 的子包里（否则扫不到）：

① web/HelloController.java（表现层）——只接 HTTP，不写业务：

package com.example.hello.web;

import com.example.hello.service.GreetingService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController                                  // = @Controller + @ResponseBody
public class HelloController {

    private final GreetingService greetingService;

    public HelloController(GreetingService greetingService) {   // 构造器注入，不用 new
        this.greetingService = greetingService;
    }

    @GetMapping("/api/hello")                    // GET /api/hello?name=Lin
    Greeting hello(@RequestParam(defaultValue = "world") String name) {
        return greetingService.greet(name);
    }
}

② service/GreetingService.java（业务层）：

package com.example.hello.service;

import java.time.LocalDateTime;
import org.springframework.stereotype.Service;
import com.example.hello.web.Greeting;

@Service
public class GreetingService {
    public Greeting greet(String name) {
        return new Greeting("Hello, " + name + "!", LocalDateTime.now());
    }
}

③ web/Greeting.java（DTO，Java record）：

package com.example.hello.web;

import java.time.LocalDateTime;

public record Greeting(String message, LocalDateTime at) { }

注意看 ②→①：HelloController 的构造函数里声明需要一个 GreetingService，代码里没有任何 new——这个实例是 Spring 容器在启动时创建并「注入」进来的。你只管声明依赖，容器负责组装。这就是 Spring 的核心（IoC/DI）在你第一次写 Boot 时就已经在用，只是被藏得很自然。

启动（开发期，内嵌 Tomcat 默认端口 8080）：

./mvnw spring-boot:run
# 另开终端验证
curl http://localhost:8080/api/hello?name=Lin
# 期望返回形如：{"message":"Hello, Lin!","at":"2026-09-08T..."}

上面的 curl 结果是我按代码逻辑推演的预期返回，不是真实抓包——再次提醒，本文未在本机运行。

6. 配置：`application.properties` / `.yml`

Boot 的外置配置让「改行为不动代码」成为可能。把 application.properties 改成 application.yml（更常用）：

server:
  port: 8081            # 换个端口

app:
  greeting:
    default-name: 朋友   # 自定义配置，留给 @ConfigurationProperties 读

代码里读配置，推荐用类型安全的 @ConfigurationProperties（而不是散落 @Value）：

package com.example.hello.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "app.greeting")   // 绑定上面 app.greeting.*
public record GreetingProperties(String defaultName) { }

再在入口类加 @EnableConfigurationProperties(GreetingProperties.class)（或写成 @ConfigurationPropertiesScan），Service 里注入 GreetingProperties，把「问候对象默认值」交给配置。改一个 yml 就改全局默认值，这正是 Boot 的可配置性卖点。

7. 打包：可执行 jar 与健康检查

./mvnw clean package          # 产出 target/hello-0.0.1-SNAPSHOT.jar
java -jar target/hello-0.0.1-SNAPSHOT.jar   # 直接跑，内嵌容器

加了 Actuator 后，默认暴露 /actuator/health：

curl http://localhost:8080/actuator/health
# {"status":"UP"}   —— 部署探活、K8s liveness 都靠它

（这就是为什么「加 actuator = 有健康检查」——又一个自动配置的例子。）

8. 结课自检：Boot 藏起来的 Spring，你能答出几个

你写的东西	背后 Spring 机制（后续系列会拆）
`@SpringBootApplication`	`@Configuration` + `@EnableAutoConfiguration` + `@ComponentScan`
`@RestController` / `@Controller`	Spring MVC 的 DispatcherServlet 路由
`@Service` / `@Repository` / `@Component`	被容器管理的 Bean
构造器注入	依赖注入（DI），IoC 容器在启动时装配对象图
starter 一加就能用	自动配置（`spring.factories` / 配置类按条件生效）
内嵌容器跑 jar	Boot 把 Tomcat 打成依赖，无需外置 web 容器

如果这些词眼熟但不完全懂——正常。Boot 的价值就是让你先不被它们卡住也能产出；系列第 1 篇就回头把这些词拆开。

参考

官方快速上手（图文 + 可下载）：spring.io/quickstart
生成骨架：start.spring.io（拿当前 Boot 版本与依赖的最佳方式）
Spring Boot 参考文档：docs.spring.io/spring-boot
版本核对源：Maven Central org/springframework/boot（2026-09-08 抓取，Boot 4.1.1 / 3.5.16）
许可：Apache-2.0
⚠️ 本文代码未在本机运行（本机 JDK 11 < 17）；请以 start.spring.io 生成的当前版本骨架 + 官方文档为准。

本文定位​

1. 先理清「Spring 家族」的名份​

2. 环境：先把地基说清楚​

3. 三分钟：用 start.spring.io 生成骨架​

4. 生成的目录长什么样​

5. 第一个接口 + 顺手做成分层​

6. 配置：application.properties / .yml​

7. 打包：可执行 jar 与健康检查​

8. 结课自检：Boot 藏起来的 Spring，你能答出几个​

参考​