Spring 是什么（PPT 第 6-7 页）#

PPT 第 6、7 页给了一段相同的说明：

官网：spring.io Spring 发展到今天已经形成了一种开发生态圈，Spring 提供了若干个子项目，每个项目用于完成特定的功能。

这些子项目合起来就是常说的”Spring 全家桶”。PPT 第 6-7 页一字排开的就是其中几个（每张卡片下面都带一句官方定位）：

为什么还需要 SpringBoot（PPT 第 8-9 页）#

PPT 第 8 页把 Spring 的两大痛点摆在左边，把 SpringBoot 带来的两个词摆在右边：

PPT 第 9 页的结论原话：

Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。

回想一下 23-29 篇里做过的那些事：写 pom、copy 依赖坐标、配 junit 版本与范围、准备测试类……这些”必要但重复”的动作，SpringBoot 都用约定替我们做好了。下一篇（31 篇）会看到：工程里只写了两行依赖坐标，背后却带进来一整套 jar（连 Web 服务器都带了）。

实测：真的能拿到 Hello Heima~#

本机把上面的程序跑起来后，用命令行请求（JDK 17 / Spring Boot 3.2.8 / 内嵌 Tomcat 10.1.26）：

1
$ curl -s "http://localhost:8080/hello?name=Heima"
2
Hello Heima~

1
$ curl -si "http://localhost:8080/hello?name=Tom" | head -5
2
HTTP/1.1 200
3
Content-Type: text/plain;charset=UTF-8
4
Content-Length: 10
5
Date: Tue, 29 Sep 2026 07:39:29 GMT
6

7
Hello Tom~

1
Hello Controller ... hello ： Heima

1
$ curl -s -o /dev/null -w "%{http_code}" "http://localhost:8080/nope"
2
404

第 1 步：创建工程、勾选 web 依赖#

IDEA 里 New Module → 左边选 Spring Initializr（PPT 第 12 页截图里的样子）：

到下一页的 Dependencies 里，把 Web → Spring Web 勾上（右侧 Added dependencies 里会出现 Spring Web）：

点 Create 之后，IDEA 会生成工程并开始联网下载依赖。生成的工程里自带的 pom.xml、启动类、配置文件长什么样，下一篇 31 篇逐个拆。

第 2 步：定义请求处理类#

在 src/main/java/com/itheima/ 下新建 HelloController.java。课程源码的写法（springboot-web-quickstart/src/main/java/com/itheima/HelloController.java）：

1
package com.itheima;
2

3
import org.springframework.web.bind.annotation.RequestMapping;
4
import org.springframework.web.bind.annotation.RestController;
5

6
@RestController //标识当前是一个请求处理类
7
public class HelloController {
8

9
    @RequestMapping("/hello") //标识请求路径
10
    public String hello(String name){
11
        System.out.println("Hello Controller ... hello ： " + name);
12
        return "Hello " + name + "~";
13
    }
14

15
}

三行代码、两个注解，各管一件事：

第 3 步：运行启动类#

工程生成时就带好了一个启动类（也是整个工程的入口）：

1
package com.itheima;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5

6
/**
7
 * 启动类/引导类
8
 */
9
@SpringBootApplication
10
public class SpringbootWebQuickstartApplication {
11

12
    public static void main(String[] args) {
13
        SpringApplication.run(SpringbootWebQuickstartApplication.class, args);
14
    }
15

16
}

直接运行这个类的 main 方法（IDEA 里点左边的绿色三角），看到类似下面的日志就是启动成功：

1
Tomcat initialized with port(s): 8080 (http)
2
Tomcat started on port 8080 (http) with context path ''
3
Started SpringbootWebQuickstartApplication in 1.803 seconds

然后打开浏览器访问 http://localhost:8080/hello?name=Heima，页面上就是 Hello Heima~。

为什么一个 main 方法就能把 Web 应用跑起来？（PPT 第 16 页的标题问题）——答案在下一篇：SpringApplication.run(...) 启动时会创建 Spring 容器，并把内嵌的 Tomcat 一起拉起来（这就是日志里 Tomcat started on port 8080 的来源）。

一、知识回顾（读完直接做下面的实践题）#

1. 静态资源：服务器上存储的不会改变的数据，通常不会根据用户的请求而变化（HTML、CSS、JS、图片、视频等），负责页面展示；动态资源：服务器端根据用户请求和其他数据动态生成的数据，内容可能每次请求都在变（Servlet、JSP 等），负责逻辑处理
2. B/S 架构：Browser/Server 浏览器/服务器架构模式，客户端只需浏览器、逻辑和数据都在服务器端，维护方便、体验一般；C/S 架构：Client/Server 客户端/服务器架构模式，需要单独开发维护客户端，体验不错、开发维护麻烦
3. 三个角色的分工：HTTP 协议规定浏览器和服务器之间数据传输的规则；**Web 服务器（Tomcat）**接收请求、解析协议、返回结果；Spring 框架用来写处理请求的动态资源程序
4. Spring 是什么：官网 spring.io，已经形成一种开发生态圈，提供若干个子项目（Spring 全家桶），每个项目完成特定功能——Spring Framework（依赖注入等核心支持）、Spring Boot、Spring Data、Spring Cloud、Spring Security……
5. Spring 的两个痛点是入门难度大、配置繁琐；SpringBoot 的两个关键词是简化配置、快速开发（“帮助非常快速的构建应用程序、简化开发、提高效率”）
6. 入门程序需求：基于 SpringBoot 开发 Web 应用，浏览器发起 /hello 请求后返回字符串 Hello Xxx；本地地址是 http://localhost:8080/hello?name=Heima（8080 是 SpringBoot 默认端口）
7. 快速入门三步：① 创建 SpringBoot 工程并勾选 web 开发相关依赖；② 定义请求处理类 HelloController，方法 hello 上加两个注解（类上标识”请求处理类”、方法上标识”请求路径”）；③ 运行启动类（main 方法里的 SpringApplication.run(...)）后用浏览器测试
8. 两个注解的作用：@RestController 标在类上，标识当前类是一个请求处理类；@RequestMapping("/hello") 标在方法上，标识请求路径；URL 上的 ?name=Heima 会自动传进方法的 String name 参数
9. 本机实测：curl -s "http://localhost:8080/hello?name=Heima" 返回 Hello Heima~；请求不存在的 /nope 返回状态码 404；服务端控制台打印出 Hello Controller ... hello ： Heima
10. 官方脚手架连不上：报 Initialization failed for 'https://start.spring.io'、Connect timed out 时，把 New Module 页面的 Server URL 改成 https://start.aliyun.com（阿里云脚手架）即可正常创建；换脚手架只影响生成工程，依赖下载还是走 Maven 仓库

二、裸写题#

• 2-1 写第一个请求处理类 写一个请求处理类：浏览器访问 /hello?name=Heima 时，页面返回 Hello Heima~；同时服务端控制台要把收到的名字打印出来。 （练习文件 test_30_HelloController.java 里给了包名、类名骨架和写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：这个类不是普通 Java 类，它是”接请求”的类——需要两个注解：一个告诉 Spring”这个类负责处理请求”，一个告诉 Spring”哪个路径归这个方法管” 二级 · 方法：类上用 @RestController；方法上用 @RequestMapping("/hello")；方法签名写成 public String hello(String name)（类名 HelloController、方法名 hello、包名 com.itheima，练习文件骨架里已给出），name 会自动接住 URL 上的 ?name= 三级 · 骨架：@RestController public class HelloController { @RequestMapping("/____") public String hello(String name){ System.out.println("____" + name); return "Hello " + name + "~"; } }

  参考答案（做完再点开）

  1
  package com.itheima;
  2
  
  3
  import org.springframework.web.bind.annotation.RequestMapping;
  4
  import org.springframework.web.bind.annotation.RestController;
  5
  
  6
  @RestController //标识当前是一个请求处理类
  7
  public class HelloController {
  8
  
  9
      @RequestMapping("/hello") //标识请求路径
  10
      public String hello(String name){
  11
          System.out.println("Hello Controller ... hello ： " + name);
  12
          return "Hello " + name + "~";
  13
      }
  14
  
  15
  }

  显示更多显示更少

  这就是课程源码 HelloController.java 的样子。本机实测（JDK 17 / Spring Boot 3.2.8 / 内嵌 Tomcat 10.1.26）：启动后 curl -s "http://localhost:8080/hello?name=Heima" 返回 Hello Heima~，服务端控制台出现 Hello Controller ... hello ： Heima——方法里那句打印真的执行了，方法的返回值真的变成了响应体。反过来，只要类上的注解漏了、或者请求路径写错（@RequestMapping 里的值和浏览器里敲的不一致），请求就会变成 404（服务器收到了请求，但没有方法接住它）。

• 2-2 一个类里放两个处理方法 在同一个请求处理类里再加一个处理方法：浏览器访问 /hi?name=Tom 时返回 Hi Tom 你好~，并在控制台打印 hi : Tom。 做完再回答：为什么两个不同的请求能由同一个类里的两个方法来处理？

  提示（先自己想，实在想不出再点开）

  一级 · 思路：一个类里可以有多个”处理方法”，它们靠路径区分；给新方法再标一个路径注解就行，类上的”我是处理类”注解不用重复写 二级 · 方法：类还是 HelloController，新增的方法叫 hi；在新方法上写 @RequestMapping("/hi")，方法签名同样用 String name 接参数 三级 · 骨架：@RequestMapping("/____") public String hi(String name){ ... return "Hi " + name + " 你好~"; }

  参考答案（做完再点开）

  1
  @RestController //标识当前是一个请求处理类
  2
  public class HelloController {
  3
  
  4
      @RequestMapping("/hello") //标识请求路径
  5
      public String hello(String name){
  6
          System.out.println("Hello Controller ... hello ： " + name);
  7
          return "Hello " + name + "~";
  8
      }
  9
  
  10
      @RequestMapping("/hi") //第二个请求路径，同样由这个类处理
  11
      public String hi(String name){
  12
          System.out.println("hi : " + name);
  13
          return "Hi " + name + " 你好~";
  14
      }
  15
  
  16
  }

  显示更多显示更少

  原因：@RequestMapping 标在方法上时，标识的是”这个方法负责哪个请求路径”——一个类可以有任意多个带不同路径的方法，Spring 收到请求后按路径找到对应的方法执行。所以 http://localhost:8080/hi?name=Tom 走 hi 方法，/hello 走 hello 方法，互不干扰。

• 2-3 找错：这段代码为什么访问不了 下面这个类在能正常启动的 SpringBoot 工程里，但浏览器访问 http://localhost:8080/hello?name=Heima 返回 404。请指出缺了什么、为什么缺了就会 404，并把代码补完整：

  1
  public class HelloController {
  2
  
  3
      public String hello(String name){
  4
          return "Hello " + name + "~";
  5
      }
  6
  
  7
  }

  提示（先自己想，实在想不出再点开）

  一级 · 思路：Java 代码本身没报错，问题在”Spring 不知道这个类是干什么的”——回想一下 2-1 里这个类比普通类多写了什么 二级 · 方法：类上少了标识”请求处理类”的注解，方法上少了标识”请求路径”的注解；404 的含义是”服务器收到了请求，但找不到能处理它的映射/资源” 三级 · 骨架：@____ public class HelloController { @____("/____") public String hello(...) }

  参考答案（做完再点开）

  缺两个注解：类上缺 @RestController（Spring 启动时不会把这个类注册成请求处理类），方法上缺 @RequestMapping("/hello")（没有路径映射，/hello 这个请求没人接）。补完整就是 2-1 的代码。 404 的意思是”服务器收到了请求，但找不到对应的资源或映射”——本机实测访问一个不存在的地址（/nope）时也是这个结果：

  1
  $ curl -s -o /dev/null -w "%{http_code}" "http://localhost:8080/nope"
  2
  404

  所以写后端时看到 404，第一反应就是查两个地方：请求路径写对了吗（@RequestMapping 里的值、浏览器里敲的地址）、这个类被 Spring 认出来了吗（类上的注解加了吗、类放的位置对不对）。

• 2-4 排错：创建工程时脚手架连不上 你在 IDEA 里按 2-1 的步骤创建 SpringBoot 工程，Name、Group 都填好了，刚点 Next 就弹出错误窗口，里面写着：

  1
  Initialization failed for 'https://start.spring.io'
  2
  Please check URL, network and proxy settings.
  3
  Error message:
  4
  Cannot download 'https://start.spring.io': Connect timed out

  请写出你的处理思路（至少三条），并说明”改脚手架”和”依赖下不下来”是不是同一件事。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：先判断”是谁连不上谁”——你填的信息没错，是 IDEA 去访问的那个模板服务器连不通 二级 · 方法：New Module 页面上的 Server URL 可以换；国内可选阿里云的脚手架地址 三级 · 骨架：Server URL = https://____.____（把 start.spring.io 换成阿里的域名）

  参考答案（做完再点开）

  ① 这不是填错了信息，也不是 IDEA 坏了：错误详情 Cannot download 'https://start.spring.io': Connect timed out 说明是访问官方脚手架服务器超时（默认脚手架在国外）； ② 处理办法：在 New Module 页面把 Server URL 从 start.spring.io 改成阿里的 https://start.aliyun.com（点输入框后面的编辑按钮，在弹出对话框里改），再点 Next 就能正常创建工程； ③ 生成工程之后，照旧要联网下载依赖——这一步走的是 Maven 仓库（24 篇配的阿里云私服），和脚手架是两回事； ④ 所以”改脚手架”和”依赖下不下来”不是同一件事：前者解决”工程骨架生成不了”，后者要按 29 篇的办法看 Maven 报错（Could not find artifact、xxx.lastUpdated 缓存失败等）。

三、综合题#

• 3-1 从零跑通第一个 SpringBoot Web 程序 照课程的连贯实践完整做一遍：

  1. 建工程：New Module → Spring Initializr，Server URL 用阿里云脚手架，Type 选 Maven、Language 选 Java、JDK 选 17、Packaging 选 Jar，Group 填 com.itheima，Name/Artifact 起 springboot-web-quickstart；
  2. 勾依赖：在 Dependencies 里展开 Web，勾上 Spring Web，点 Create，等 IDEA 把依赖下完；
  3. 写处理类：在 src/main/java/com/itheima/ 下建 HelloController，加类注解与方法注解，方法返回 Hello Xxx~，并把收到的名字打印到控制台；
  4. 跑起来：运行工程自带的启动类（SpringbootWebQuickstartApplication），等控制台出现 Tomcat started on port 8080；
  5. 测：浏览器访问 http://localhost:8080/hello?name=Heima，把页面上看到的字符串抄到练习文件；
  6. 试错：再访问 http://localhost:8080/nope，把它的结果（404）记下来，并写出”为什么这一次访问不到”；
  7. 答一问：这个”跑起来的 Web 服务器（Tomcat）“是你自己安装、启动的吗？它是从哪来的？

  涉及知识点

  知识点	在这里的应用
  静态资源/动态资源	/hello 返回的字符串是服务端现算出来的动态资源
  B/S 架构	客户端只用浏览器，程序跑在服务器端（本机的 8080 端口）
  Spring 与 SpringBoot	SpringBoot 帮我们简化配置、快速开发，所以三步就能出结果
  创建工程	Spring Initializr + 勾选 Spring Web 依赖（脚手架连不上就换阿里云）
  请求处理类	@RestController 标识处理类、@RequestMapping("/hello") 标识路径
  启动与测试	运行启动类 → 8080 端口 → 浏览器/curl 请求

  提示（先自己想，实在想不出再点开）

  一级 · 思路：整条链路是”生成骨架 → 勾 web 依赖 → 写处理类 → 运行启动类 → 用地址访问”；第 6 步的 404 和第 7 步的问题都指向同一个东西——工程里自带的 Web 服务器 二级 · 方法：Server URL 换成 https://start.aliyun.com；处理类用 @RestController + @RequestMapping("/hello")；启动类是带 @SpringBootApplication 和 main 方法的那个类 三级 · 骨架：@____ public class HelloController { @____("/hello") public String hello(String name){ return "Hello " + name + "~"; } }

  参考答案（做完再点开）

  1. 创建页面上的关键选择：Type = Maven、Language = Java、JDK = 17、Packaging = Jar，Server URL 用 https://start.aliyun.com（官方脚手架连不上时）；Group 用 com.itheima。
  2. 依赖只勾一项：Spring Web（Web 分类下），右侧 Added dependencies 里会出现 Spring Web。
  3. HelloController：

     1
     package com.itheima;
     2
     
     3
     import org.springframework.web.bind.annotation.RequestMapping;
     4
     import org.springframework.web.bind.annotation.RestController;
     5
     
     6
     @RestController //标识当前是一个请求处理类
     7
     public class HelloController {
     8
     
     9
         @RequestMapping("/hello") //标识请求路径
     10
         public String hello(String name){
     11
             System.out.println("Hello Controller ... hello ： " + name);
     12
             return "Hello " + name + "~";
     13
         }
     14
     
     15
     }

     显示更多显示更少
  4. 运行启动类后控制台的关键行（本机实测，Spring Boot 3.2.8）：

     1
     Tomcat initialized with port 8080 (http)
     2
     Starting Servlet engine: [Apache Tomcat/10.1.26]
     3
     Tomcat started on port 8080 (http) with context path ''
     4
     Started SpringbootWebQuickstartApplication in 1.803 seconds

     完整启动日志的逐行解读在下一篇 31 篇。
  5. 浏览器/命令行实测结果：

     1
     $ curl -s "http://localhost:8080/hello?name=Heima"
     2
     Hello Heima~

  6. /nope 的结果是 404：请求确实到达了服务器，但没有任何方法和这个路径对应（@RequestMapping 里只标识了 /hello），所以服务器回 404。“打错地址""路径没写对""类没被注册成处理类”都会表现为 404。
  7. 不是自己装的：Tomcat 是 SpringBoot 自带的内嵌服务器，跟着工程依赖一起下回来的，SpringApplication.run(...) 启动时把它一起拉起来——下一篇文章把这件事讲透。