用豆包辅助从头开始学习java spring cloud（一）

曾经学习过java基础，但是没有做过任何程序，spring框架听过，简单的看过但是没有学习也没有使用过，不过因为之前也是计算机专业的，所以把开发环境顺利的搭建好了，目前的开发环境是：jdk-8u311-windows-x64、apache-maven-3.8.6-bin、VSCodeUserSetup-x64-1.127.0、node-v18.20.8-x64、idea（原本电脑就有，不知道什么版本）。

现在开始想学习spring cloud，计划按照豆包的规划一步步的学习，看看按照豆包的规划的学习怎么样。

现在开始第一天的学习：

首先让豆包生成了一份学习计划如下：因为之前跟豆包提问了很多关于继承、接口、多态的问题，所以豆包认为我有java基础。

# Spring Cloud 零基础完整3个月落地学习计划（2026最新版）
## 前置重要说明
1. **学习顺序原则**：先夯实Spring Boot → 微服务理论 → Spring Cloud原生规范 → Spring Cloud Alibaba（国内企业主流）→ 全栈项目整合 → 运维&面试拔高
2. **版本选型（直接照抄）**
   - Spring Boot：3.2.x
   - Spring Cloud 官方版本：2023.0.x（代号 Leyton）
   - Spring Cloud Alibaba：2023.0.1.2
3. **核心概念一句话分清**
   - Spring Cloud：**微服务架构规范**，定义整套微服务需要哪些能力
   - Spring Cloud Netflix：第一代实现（Eureka、Hystrix已停止维护，仅做了解）
   - Spring Cloud Alibaba：第二代主流落地实现（Nacos、Sentinel、Seata，国内90%公司在用，重点学）

---

## 第一阶段：前置基础补全（7~10天，必须通关，否则Cloud寸步难行）
### 必备技术清单（你已有Java基础，重点攻坚下面4项）
1. **Spring Boot 深度吃透（重中之重，5天）**
   - 核心：自动配置原理、Maven父子工程聚合结构（Cloud全部用多模块Maven）、yml/properties配置、@Configuration、@Bean、@Conditional注解
   - 实操：搭建单体Web项目、MyBatis-Plus操作MySQL、全局异常处理、统一返回结果集
   - 产出：一个完整Spring Boot用户CRUD单体项目

2. **工具与中间件基础（2天）**
   - Maven：父子模块、dependencyManagement版本锁定（Cloud核心工程结构）
   - MySQL：多库设计、外键、事务ACID
   - Redis：基础命令、缓存穿透/击穿/雪崩解决方案（微服务高频）

3. **架构理论铺垫（2天）**
   - 单体架构 → 垂直拆分 → SOA → **微服务架构**演进过程
   - 微服务优缺点、服务拆分原则（单一职责、按业务域拆分）
   - RESTful API规范、HTTP接口调用、Postman测试

### 阶段验收
能独立创建Maven父工程+多个子模块，用Spring Boot写接口，理解为什么需要微服务拆分。

---

## 第二阶段：微服务架构理论 + Spring Cloud原生规范（2周，14天）
### 第1周：微服务通信与注册发现核心（7天）
#### Day1-2 微服务远程调用三种方式
1. RestTemplate（底层HTTP调用）
2. OpenFeign（声明式接口调用，企业标准）
3. LoadBalancer 负载均衡（替代老旧Ribbon）
**实操**：搭建`订单服务`、`用户服务`两个Boot模块，订单调用用户接口。

#### Day3-5 服务注册与发现
1. Eureka（仅了解，停更组件，知道原理即可）
2. Consul简单过
3. 核心吃透：**Nacos（Alibaba）**
   - Nacos下载启动、注册中心控制台、服务上下线感知、集群部署
   - 注解`@EnableDiscoveryClient`、权重负载、健康检查

#### Day6-7 API网关 Gateway（必考核心）
- 作用：路由转发、鉴权、限流、跨域、请求过滤
- 配置方式：yml配置、代码自定义路由、全局过滤器GlobalFilter
- 实操：Gateway网关统一代理所有微服务接口

### 第2周：配置中心、熔断降级、链路追踪（7天）
1. 分布式配置中心
   - Spring Cloud Config（原生，了解）
   - Nacos Config（重点，一套Nacos同时做注册+配置中心，动态刷新配置`@RefreshScope`）
2. 服务容错熔断
   - Resilience4j（Spring官方新容错组件）
   - Hystrix（淘汰，仅学习降级、熔断、舱壁模式思想）
3. 分布式链路追踪 Sleuth + Zipkin
   - 微服务调用链条日志排查，定位超时、报错节点

### 阶段产出
6个独立微服务模块：注册中心Nacos、网关Gateway、配置中心、用户、订单、支付服务，模块间正常远程调用、配置动态更新、异常自动熔断。

---

## 第三阶段：Spring Cloud Alibaba 企业级核心组件（3周，21天，最核心落地内容）
> 互联网公司真实技术栈，重点全部动手敲代码
### 第1周：Nacos 深度吃透（7天）
1. Nacos注册中心：持久化、命名空间、环境隔离（dev/test/prod）
2. Nacos配置中心：多环境配置、共享配置、配置灰度发布、监听回调
3. Nacos集群搭建（模拟生产高可用）

### 第2周：流量管控 + 分布式事务（7天）
1. **Sentinel 流量防卫兵（重点）**
   - 熔断、降级、限流（QPS限流、链路限流、热点参数限流）
   - Sentinel控制台可视化配置、规则持久化、网关Gateway集成Sentinel限流
2. **Seata 分布式事务（微服务最难考点）**
   - 为什么需要分布式事务（跨库/跨服务事务不一致）
   - AT模式（自动事务，99%场景使用）、TCC模式原理
   - 实操：下单扣库存、扣余额跨三个服务保证数据一致性

### 第3周：消息队列、Dubbo RPC、完整生态整合（7天）
1. RocketMQ 消息队列（Alibaba生态）
   - 异步解耦、最终一致性事务消息、削峰填谷
2. Dubbo RPC高性能调用（替代Feign）
   - Dubbo+Nacos注册中心，对比HTTP与RPC调用差异
3. 全套组件串联复盘：
   `Gateway网关 → Nacos注册配置 → OpenFeign/Dubbo调用 → Sentinel限流 → Seata事务 → RocketMQ异步`

### 阶段验收
独立搭建一套**标准Spring Cloud Alibaba企业微服务架构**，处理分布式事务、高并发限流、动态配置全部落地。

---

## 第四阶段：大型综合实战项目（2周，14天，求职/工作核心竞争力）
### 项目选题（推荐2套，循序渐进）
#### 项目1：简易电商微服务（基础版，1周）
拆分模块：
1. 网关模块 gateway
2. 公共依赖模块 common（实体、工具类、统一返回）
3. 用户服务 user-service（登录、注册、权限）
4. 商品服务 product-service（库存管理）
5. 订单服务 order-service（Seata分布式事务）
6. 支付服务 pay-service
7. Nacos注册配置、Sentinel限流、Zipkin链路追踪

#### 项目2：后台管理系统（贴合岗位，1周，加分项）
业务模块：
- 机构管理、账户管理、交易流水、权限菜单、日志审计
- 技术亮点：
  1. Gateway网关做接口权限拦截、IP白名单
  2. Nacos多环境隔离（开发/测试/生产）
  3. Sentinel对核心交易接口限流熔断，防止雪崩
  4. Seata保证转账跨账户分布式事务
  5. Redis缓存热点账户数据

### 项目必须完成的工程规范
1. Maven聚合父子工程拆分，版本统一管理
2. 全局统一异常处理器、统一JSON返回体
3. 所有组件yml配置抽离到Nacos远程配置
4. 写完整README文档：环境说明、启动顺序、接口文档

---

## 第五阶段：进阶拔高 + 运维部署 + 面试冲刺（1周，7天）
### 1. 云原生&容器部署（企业必备）
- Docker打包每个微服务为镜像、Docker Compose一键启动整套微服务集群
- 简单了解K8s基础概念（不用深挖，知道用途即可）

### 2. 监控运维体系
- Spring Boot Admin 微服务健康监控面板
- Prometheus + Grafana 指标监控（CPU、内存、QPS、异常率）

### 3. 高频面试题梳理（重点整理）
1. 微服务拆分原则、优缺点
2. Nacos vs Eureka区别、AP/CP架构
3. Sentinel限流规则、熔断降级触发条件
4. Seata AT模式执行原理、分布式事务解决方案
5. Gateway网关过滤器执行流程
6. OpenFeign负载均衡底层原理
7. 微服务雪崩效应怎么预防

---

# 总周期汇总（按每日2小时业余学习）
1. 前置Spring Boot基础：10天
2. Spring Cloud原生组件规范：14天
3. Spring Cloud Alibaba核心企业组件：21天
4. 两大实战项目落地：14天
5. 部署、监控、面试复盘：7天
**合计：66天 ≈ 2个半月完整精通，可以直接上手微服务项目开发**

---

# 避坑关键规则（零基础必看）
1. **不要跳过Spring Boot直接学Cloud**：Cloud所有组件都基于Boot自动配置，跳过会全程看不懂配置；
2. **不要死磕淘汰组件**：Eureka、Hystrix只看原理，主力投入Nacos、Sentinel、Seata；
3. **每学一个组件必须敲代码**：微服务重在工程搭建，只看视频不写项目等于0；
4. **优先学Spring Cloud Alibaba**：国内职场、金融行业全部在用，原生Netflix版本仅做理论了解。

我不知道这份计划好还是不好，不过还是先投入学习，下面进入第一天的学习：

# Day1 第一天学习任务（总时长2～3小时，不搞复杂，落地看得见成果）
## 核心目标
1. 搞懂**微服务到底是什么、为什么要用**，建立宏观认知
2. 学会搭建 Spring Cloud Alibaba 最核心结构：**Maven父子聚合工程**
3. 搭建第一个 Spring Boot 子模块并运行成功

---

## 第一部分：理论认知（30分钟）
### 1. 架构演进只记4个阶段
1. 单体架构：所有代码写在一个项目里，小系统好用，迭代、并发、发布卡死
2. 垂直拆分：拆成多个单体项目（用户系统、订单系统），解决一部分问题，但重复代码多
3. SOA架构：用ESB总线做服务调用，笨重、中心化瓶颈
4. **微服务架构**：按业务领域高度拆分，每个服务独立部署、独立数据库、独立扩容，通过注册中心发现、远程调用通信

### 2. 三个名词死记（后面天天用）
1. **Spring Boot**：快速开发单体Java Web，Cloud的地基，必须熟练
2. **Spring Cloud**：一套微服务**标准规范**，定义了注册中心、网关、熔断、配置中心该怎么玩
3. **Spring Cloud Alibaba**：阿里基于Cloud规范做的**具体实现**（Nacos、Sentinel、Seata），国内企业、金融系统主流技术栈

### 3. 微服务核心5大组件先混个脸熟（不用深究）
- Nacos：注册中心 + 配置中心（最核心）
- OpenFeign：服务之间远程调用
- Gateway：API网关，统一入口
- Sentinel：限流、熔断、降级，防止服务雪崩
- Seata：解决跨服务、跨数据库的**分布式事务**（银行转账必用）

---

## 第二部分：实操重头戏（2小时，今天最重要）
### 步骤1：环境检查（5分钟）
确认本地装好：
1. JDK 1.8（配置好环境变量，cmd java -version验证）
2. Maven 3.6+ 配置阿里云镜像（关键，否则依赖下载卡死）
3. IDEA 开发工具
4. MySQL 8.0（后面用，今天可以不启动）

Maven settings.xml 镜像粘贴（直接复制）
```xml
<mirror>
    <id>aliyunmaven</id>
    <mirrorOf>central</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
</mirror>
```

### 步骤2：在IDEA创建父工程 parent（40分钟）
1. IDEA 新建 Maven 项目，**打包方式 packaging = pom**
2. 把我上一轮发给你的**父工程完整pom.xml**全部替换进去
3. 理解两个关键点：
   - `dependencyManagement`：只锁定版本，子模块不用写版本号，统一管控
   - 父工程本身不能运行，只用来管理依赖、统一版本

### 步骤3：创建第一个子模块 common 公共模块（30分钟）
1. 右键父工程 → New → Module → Maven
2. 自动继承父工程，pom里只有parent标签
3. common作用：放统一返回结果类、全局异常、工具类、实体类，所有业务服务依赖它
今天不用写复杂代码，只建空模块，看结构层级即可

### 步骤4：创建第一个可运行微服务 demo-service（40分钟）
1. 继续在父工程下新建子模块 demo-service
2. pom引入 spring-boot-starter-web 依赖
3. 编写启动类
```java
package com.bank.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);
    }
}
```
4. resources 新建 application.yml
```yaml
server:
  port: 8081
spring:
  application:
    name: demo-service
```
5. 写一个测试Controller
```java
@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello(){
        return "第一个微服务模块启动成功";
    }
}
```
6. 运行启动类，浏览器访问 `http://localhost:8081/hello`
✅ 能输出文字 = 今天任务圆满完成

---

## 第三部分：今日复盘+明天预习（10分钟）
### 今天必须掌握的3个知识点
1. 父工程 packaging 必须是 pom，用来做版本统一管理
2. 子模块通过 `<parent>` 继承父工程依赖，简化版本维护
3. SpringBoot启动注解 `@SpringBootApplication` 作用

### 明天要学内容预告
1. Spring Boot 基础复习：yml配置、Lombok、统一返回体封装
2. 搭建第二个服务 user-service，用 RestTemplate 实现两个服务互相调用（微服务远程通信入门）

---

## 极简执行顺序抄作业
1. 看微服务架构演进理论 30min
2. 配置Maven阿里云镜像
3. 创建父工程 → common模块 → demo-service运行测试
4. 浏览器访问接口验证成功

如果操作哪一步报错（比如Maven依赖爆红、启动报错），直接把pom或者报错截图发我，我给你当场修正。

步骤一中，找到了本地settings.xml，使用记事本打开但是里面太多太多被注释的内容，结果第一次好像没有设置正确：

 <mirrors>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
 <mirror>
    <id>aliyunmaven</id>
    <mirrorOf>central</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
 </mirror>
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
    <mirror>
      <id>maven-default-http-blocker</id>
      <mirrorOf>external:http:*</mirrorOf>
      <name>Pseudo repository to mirror external repositories initially using HTTP.</name>
      <url>http://0.0.0.0/</url>
      <blocked>true</blocked>
    </mirror>
  </mirrors>

这个坑在后面更新maven的时候才发现，现在自以为正确的先向下了。

看着步骤二，结果因为创建工程的部分看不懂，于是提问：“步骤 2：在 IDEA 创建父工程 parent，怎么创建，具体步骤是什么”。

根据提示创建工程如下：

根据步骤说明，删除src文件夹，修改pom文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.learnspring.cloud</groupId>
    <artifactId>learn-spring-cloud-parent</artifactId>
    <version>1.0.0</version>
    <name>微服务父工程</name>
    <description>Spring Cloud Alibaba 聚合父工程</description>
    <!-- 核心：父工程打包类型必须为pom -->
    <packaging>pom</packaging>

    <!-- 统一版本常量 -->
    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <!-- 锁定全套版本（JDK8最稳定组合） -->
        <spring.boot.version>2.7.18</spring.boot.version>
        <spring.cloud.version>2021.0.8</spring.cloud.version>
        <spring.cloud.alibaba.version>2021.0.5.0</spring.cloud.alibaba.version>

        <mysql.version>8.0.33</mysql.version>
        <mybatis.plus.version>3.5.3.1</mybatis.plus.version>
        <druid.version>1.2.20</druid.version>
    </properties>

    <!-- 依赖版本统一管理：子模块无需写版本号 -->
    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot 版本锁定 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- Spring Cloud 原生规范 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- Spring Cloud Alibaba 核心 -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring.cloud.alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- 数据库组件 -->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatis.plus.version}</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>${druid.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 所有子模块自动继承的公共依赖 -->
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <!-- 编译插件 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

开始创建子模块：

在最顶层的learn-spring-cloud-parent工程上点鼠标右键，new-module：

发现有点不太懂，于是截图再次提问，最后创建子模块如下：

创建模块后，修改pom文件，如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.learnspring.cloud</groupId>
        <artifactId>learn-spring-cloud-parent</artifactId>
        <version>1.0.0</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>demo-service</artifactId>
    <name>demo演示微服务</name>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- SpringBoot Web 依赖，版本由父工程统一管理，不用写version -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

修改好后，如果有红色波浪线，就打开右侧的m标识，点刷新后，就正常了。

展开 demo-service → src → main → java

在 java 文件夹上右键 → New → Package，输入包名：com.learnspring.cloud

在这个包里面新建启动类 DemoApplication.java

创建后如下：

配置yml文件

进入 demo-service/src/main/resources 文件夹

新建文件 application.yml，写入：

server:
  port: 8080
spring:
  application:
    name: demo-service

写测试接口

在com.learnspring.cloud下新建子包 controller，创建 HelloController.java

package com.learnspring.cloud.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello(){
        return "恭喜！Maven父子聚合工程搭建完成，第一个微服务成功启动";
    }
}

最后运行测试

右键DemoApplication的 main 方法 → Run，打开浏览器访问：

http://localhost:8080/hello

发现运行成功：

虽然运行成功了，但是点run的时候有个弹出窗口，于是截图询问

反馈为：

现在可以不用管它，不影响当前项目启动和运行。这个提示只是 Lombok 注解处理器没开启，你目前 demo-service 里还没用到@Data、@Slf4j这类 Lombok 注解，直接启动项目完全没问题。

于是，暂时先忽略。

run界面：

截止当前，提示我已完成第一天学习内容。

小结

今天搭建了一个父工程和一个子工程

父工程负责统一管理所有依赖的版本，子工程作为业务模块，编写了一个spring boot启动类，yml配置、测试了一个controller，并成功运行了这个web服务。

计划下一次学习创建第二个服务，学习RestTemplate,实现第一个服务调用第二个服务的接口，完成微服务之间的调用，创建一个通用模块，用来返回通用结果。