Spring Boot 详细学习指南（上篇）：核心概念 + 环境搭建 + HelloWorld 实战

一、Spring Boot 核心认知

1. 什么是 Spring Boot？

Spring Boot 不是全新框架，而是 Spring 生态的 "脚手架" ------ 把 Spring、Spring MVC、MyBatis 等常用技术整合好，帮我们省去繁琐配置，让开发者专注业务逻辑。

可以理解为：以前用 Spring 开发，要手动搭框架、配依赖、写 XML 配置；现在用 Spring Boot，这些工作都被 "自动化" 了，就像搭积木时直接拿到现成的模块，拼起来就能用。

2. 核心优点

优点	通俗解释
快速创建独立应用	不用手动整合框架，一键生成可运行的项目
内嵌 Servlet 容器	项目不用打成 WAR 包，直接用 Java -jar 命令运行（自带 Tomcat）
Starters 依赖管理	要做 Web 开发就加 `spring-boot-starter-web`，要连数据库就加 `spring-boot-starter-jdbc`，不用记复杂的依赖坐标和版本
自动装配	不用写大量 XML 配置（比如以前配数据源、视图解析器），Spring Boot 自动帮你搞定
准生产监控	自带健康检查、日志输出等功能，上线后能方便查看项目状态
云计算友好	容易部署到云服务器（比如阿里云、腾讯云）

3. 与微服务的关系

微服务：是一种架构风格（不是技术）。把一个大项目拆成多个小服务（比如电商项目拆成 "用户服务""订单服务""支付服务"），每个服务独立开发、部署、运行，通过 HTTP 通信。
Spring Boot 与 Spring Cloud：Spring Boot 是 "微服务的基石"------ 每个微服务都可以用 Spring Boot 快速开发；Spring Cloud 是在 Spring Boot 基础上，提供了服务注册、发现、熔断等微服务治理功能（比如服务之间怎么找到对方、出错了怎么处理）。

微服务 vs 单体应用（举例）

单体应用：把所有功能（用户、订单、支付）写在一个项目里，打包成一个 WAR 包部署到 Tomcat。缺点是：项目大了启动慢、修改一个小功能要整体重启、团队协作冲突多。
微服务：把用户、订单、支付拆成 3 个独立的 Spring Boot 项目，分别部署。优点是：启动快、修改某一个服务不影响其他、小团队可以单独维护一个服务。

微服务的优缺点（真实场景）

优点：灵活（比如订单服务要扩容，只给订单服务加服务器）、技术栈灵活（用户服务用 Java，支付服务用 Python）、容错性强（一个服务挂了，其他服务还能运行）。
缺点：复杂（服务之间要通信、要处理分布式事务，比如下单后既要扣库存又要减余额）、运维成本高（要管理多个服务的部署、监控）。

二、环境准备（ step by step ）

1. 必须安装的工具

工具	版本要求	作用
JDK	1.8 及以上	Java 项目的运行基础
Maven	3.3 及以上	管理项目依赖（比如下载 Spring Boot 相关的 Jar 包）
IDE	IntelliJ IDEA 2017+ 或 STS	开发工具（推荐 IDEA，功能更全）
Spring Boot	2.0.x 或 1.5.x	核心框架版本（教程用 1.5.9.RELEASE，稳定）

2. Maven 配置（关键步骤）

Maven 是 "依赖管家"，要告诉它用 JDK 1.8 编译项目，否则会报错。

操作步骤：

找到 Maven 安装目录下的 conf/settings.xml 文件（比如 D:\devsoft\apache-maven-3.3.9\conf\settings.xml）。
在 <profiles> 标签内添加以下内容：

XML 复制代码

<profile>
    <id>jdk-1.8</id>
    <activation>
        <activeByDefault>true</activeByDefault>
        <jdk>1.8</jdk>
    </activation>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>
</profile>

3.保存文件，重启 IDE。

3. IDEA 配置（确保 Maven 生效）

打开 IDEA，进入 File -> Settings -> Build, Execution, Deployment -> Build Tools -> Maven。
配置 3 个选项：
- Maven home directory：选择你的 Maven 安装目录（比如 D:\devsoft\apache-maven-3.3.9）。
- User settings file：选择刚才修改的 settings.xml 文件（勾选 Override）。
- Local repository：Maven 下载依赖的存放目录（默认即可，勾选 Override）。
点击 Apply -> OK。

三、Hello World 实战（亲手写第一个 Spring Boot 项目）

本文将用两种方式创建项目：Maven 手动创建 （适合理解底层）和 Spring Initializer 快速创建（实际开发常用）。

方式一：Maven 手动创建（推荐入门学习）

步骤 1：创建 Maven 项目

打开 IDEA，选择 File -> New -> Project。
左侧选择 Maven，勾选 Create from archetype，选择 org.apache.maven.archetypes:maven-archetype-quickstart（快速创建 Java 项目）。
填写项目信息：
- GroupId：公司域名反转（比如 com.example）。
- ArtifactId：项目名（比如 spring-boot-hello）。
- Version：默认 1.0-SNAPSHOT。
一路点击 Next，最后 Finish，等待项目初始化完成。

步骤 2：导入 Spring Boot 依赖

打开项目的 pom.xml 文件，添加以下内容（依赖管家会自动下载需要的 Jar 包）：

XML 复制代码

<!-- 父项目：Spring Boot 的版本仲裁中心，控制所有依赖的版本 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
</parent>

<!-- Web 启动器：包含 Spring MVC、Tomcat 等 Web 开发必需的依赖 -->
<<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</</dependencies>

<!-- 打包插件：把项目打成可执行的 Jar 包 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

解释：spring-boot-starter-web 是 "Web 场景启动器"，导入它就相当于自动导入了 Spring MVC、Tomcat、Jackson（JSON 解析）等依赖，不用手动一个个加。

步骤 3：编写主程序（项目入口）

在 src/main/java/com/example 下创建 HelloWorldMainApplication.java：

java 复制代码

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

// @SpringBootApplication：标注这是 Spring Boot 的主配置类，启动时会扫描这个类所在的包及子包
@SpringBootApplication
public class HelloWorldMainApplication {
    public static void main(String[] args) {
        // 启动 Spring Boot 应用（参数：主配置类.class，命令行参数）
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}

关键注解：@SpringBootApplication 是核心，它包含了 3 个重要功能：
1. 标记这是配置类。
2. 开启自动配置（@EnableAutoConfiguration）。
3. 扫描组件（@ComponentScan）：扫描主类所在包及子包下的 @Controller、@Service 等注解。

步骤 4：编写 Controller（处理请求）

在 com.example 下创建 controller 包，然后创建 HelloController.java：

java 复制代码

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

// @Controller：标记这是一个控制器（处理浏览器请求）
@Controller
public class HelloController {

    // @RequestMapping("/hello")：映射浏览器的 /hello 请求
    // @ResponseBody：把返回值直接响应给浏览器（不是跳转页面）
    @ResponseBody
    @RequestMapping("/hello")
    public String hello() {
        // 浏览器访问 /hello 时，返回这句话
        return "Hello World!";
    }
}

步骤 5：运行项目测试

右键点击 HelloWorldMainApplication.java，选择 Run 'HelloWorldMainApplication'。
看到控制台输出 Tomcat started on port(s): 8080 (http)，说明启动成功。
打开浏览器，输入 http://localhost:8080/hello，页面显示 Hello World!，成功！

步骤 6：简化部署（打包成 Jar 包）

打开 IDEA 的 Maven 面板（右侧），展开项目 -> Lifecycle -> 双击 package。
等待打包完成，在项目的 target 目录下会生成 spring-boot-hello-1.0-SNAPSHOT.jar。
打开命令行，进入 target 目录，执行命令：java -jar spring-boot-hello-1.0-SNAPSHOT.jar。
再次访问 http://localhost:8080/hello，依然能看到结果（不用启动 Tomcat，Jar 包自带）。

方式二：Spring Initializer 快速创建（实际开发常用）

手动创建项目需要写依赖、配置主类，比较繁琐。实际开发中，推荐用 Spring Initializer 快速生成项目（IDEA/STS 都支持）。

步骤 1：创建项目

打开 IDEA，选择 File -> New -> Project。
左侧选择 Spring Initializr（默认联网创建，需保证网络通畅），点击 Next。
填写项目信息（和手动创建一致）：
- Group：com.example。
- Artifact：spring-boot-quick。
- Type：Maven Project。
- Language：Java。
- Spring Boot：2.0.2.RELEASE。
点击 Next，选择依赖模块：勾选 Web -> Spring Web Starter（其他模块如数据库、缓存可后续添加）。
点击 Next，选择项目保存路径，最后 Finish。

步骤 2：项目结构说明

Spring Initializer 会自动生成完整的项目结构，无需手动配置：

主配置类：SpringBootQuickApplication.java（已带 @SpringBootApplication 注解）。
pom.xml：已自动导入所选依赖（如 spring-boot-starter-web）。
resources 目录：
- static：存放静态资源（JS、CSS、图片等）。
- templates：存放模板页面（如 Thymeleaf、Freemarker，默认不支持 JSP）。
- application.properties：全局配置文件（空文件，可直接添加配置）。

步骤 3：编写 Controller 测试

在 com.example.springbootquick 下创建 controller 包，添加 HelloController.java（和手动创建一致），运行主类即可测试。

四、HelloWorld 探究：底层原理是什么？

写好了 HelloWorld，我们来探究一下：为什么不用配置 Tomcat、不用写 Spring MVC 配置，项目就能运行？

1. POM 文件解析：依赖是怎么管理的？

（1）父项目：版本仲裁中心

pom.xml 中的父项目 spring-boot-starter-parent，其底层还有一个父项目 spring-boot-dependencies：

XML 复制代码

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
</parent>

<!-- 底层父项目 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>1.5.9.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

作用：spring-boot-dependencies 管理了 Spring Boot 所有依赖的版本（比如 Spring MVC、Tomcat 的版本），这就是 "版本仲裁"。
好处：以后导入依赖时，默认不用写版本号（比如 spring-boot-starter-web 不用写版本），避免版本冲突。

（2）启动器：场景化依赖集合

spring-boot-starter-web 是 "Web 场景启动器"，它的作用是：帮我们导入 Web 开发所需的所有依赖（Spring MVC、Tomcat、Jackson 等）。

Spring Boot 提供了各种场景启动器，比如：

spring-boot-starter-jdbc：数据库操作场景（包含 JDBC、数据源等依赖）。
spring-boot-starter-redis：Redis 缓存场景。
spring-boot-starter-test：单元测试场景。

核心思想：按需导入，要用什么功能就导入什么启动器。

2. 主程序类解析：自动配置是怎么生效的？

主程序类的核心是 @SpringBootApplication 注解，我们拆解它的底层实现：

java 复制代码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration // 标记为 Spring Boot 配置类
@EnableAutoConfiguration // 开启自动配置（核心）
@ComponentScan(...) // 扫描组件
public @interface SpringBootApplication {
}

（1）@SpringBootConfiguration：配置类标记

底层是 @Configuration 注解，说明当前类是配置类（替代传统 XML 配置文件）。
配置类也是 Spring 容器中的组件（底层包含 @Component 注解）。

（2）@ComponentScan：组件扫描

扫描主配置类所在包及子包下的所有组件（@Controller、@Service、@Component 等注解）。
比如 HelloController 就在主类的子包下，所以能被 Spring 扫描到并生效。

（3）@EnableAutoConfiguration：自动配置核心

这是 Spring Boot 自动配置的 "开关"，它的作用是：自动导入当前场景所需的组件，并配置好这些组件。

底层原理：

@EnableAutoConfiguration 会触发 SpringFactoriesLoader.loadFactoryNames() 方法。
该方法会扫描所有 Jar 包下的 META-INF/spring.factories 文件。
从文件中读取 EnableAutoConfiguration 对应的所有自动配置类（比如 HttpEncodingAutoConfiguration、DispatcherServletAutoConfiguration）。
将这些自动配置类导入 Spring 容器，自动配置类会帮我们配置好核心组件（比如 DispatcherServlet、CharacterEncodingFilter）。

简单说：以前需要手动配置的组件（比如 Spring MVC 的前端控制器、乱码过滤器），现在由自动配置类帮我们自动配置了。

五、总结

上篇博客我们从核心概念入手，完成了 Spring Boot 环境搭建、两种方式创建 HelloWorld 项目，并深入解析了依赖管理和自动配置的底层原理。

关键收获：

Spring Boot 的核心是 "自动配置" 和 "依赖管理"，简化了 Spring 应用开发。
启动器（Starter）是场景化依赖集合，按需导入即可。
@SpringBootApplication 是主配置类的核心注解，包含配置类标记、组件扫描、自动配置开关三大功能。

下篇博客将重点讲解 Spring Boot 的配置文件（properties/yml）、热部署、配置注入、多环境配置、自动配置原理详解等核心功能。