Spring Boot实战：从零搭建电商秒杀系统，新手也能看懂的入门指南

一、开篇：一个真实的业务痛点

场景描述：

去年双十一，小王所在的公司开发了一个电商秒杀系统。作为刚入职1年的Java开发，他接到的第一个任务就是："在2周内上线一个商品秒杀功能"。

小王心里直打鼓：

• 需要搭建Spring MVC框架
• 配置数据库连接池
• 整合Redis缓存
• 实现限流防刷
• 还要考虑高并发场景...

光是配置XML文件就写了3天，项目启动时各种jar包冲突，折腾了一周还没跑通第一个接口。最终项目延期，被老板批了一顿。

痛点分析： 传统Java开发就像"组装一台电脑"，你需要自己选主板、CPU、内存、硬盘，然后一个个组装起来，还要考虑兼容性问题。对于新手来说，光是"搭建环境"就能劝退一半人。

Spring Boot的出现，就像"买一台品牌电脑"，开箱即用！

---

二、什么是Spring Boot？

2.1 通俗解释

想象一下，你想做一道"红烧肉"：

传统Spring开发（自己做饭）：

• 要先去买五花肉、酱油、糖、姜、蒜...
• 要自己切肉、焯水、炒糖色...
• 还要掌握火候、时间...
• 稍不注意就糊了

Spring Boot开发（点外卖）：

• 只需要说"我要一份红烧肉"
• 有人帮你把所有食材准备好
• 按照标准流程烹饪
• 你只需要"开吃"

2.2 官方定义

Spring Boot是Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。它遵循"约定优于配置"的原则，采用"习惯优于配置"的理念。

2.3 核心特性（用大白话讲）

| 特性 | 类比 | 实际意义 | |------|------|----------| | 自动配置 | 智能家居 | 根据你引入的依赖，自动帮你配置好相关组件 | | 起步依赖 | 套餐选择 | 想要什么功能，引入对应的"starter"即可 | | 内嵌服务器 | 自带发电机 | 不需要部署Tomcat，直接java -jar就能运行 | | 无需XML | 无纸化办公 | 不用写繁琐的配置文件，注解搞定一切 |

---

三、为什么要用Spring Boot？

3.1 传统Spring开发的痛点

// 传统Spring开发需要这样配置

// web.xml 配置
<web-app>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-mvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

// spring-mvc.xml 配置
<beans xmlns="http://www.springframework.org/schema/beans">
    <context:component-scan base-package="com.example"/>
    <mvc:annotation-driven/>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

// pom.xml 依赖管理
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.20</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.20</version>
    </dependency>
    <!-- 还要自己管理版本兼容性 -->
</dependencies>

问题：

1. 配置文件多且繁琐
2. 依赖版本冲突频发
3. 项目启动慢
4. 部署复杂
5. 新手学习曲线陡峭

3.2 Spring Boot的优势

// Spring Boot 只需要这样

// pom.xml
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!-- 版本由父工程管理，不用写 -->
    </dependency>
</dependencies>

// 一个启动类搞定
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

优势：

1. 🚀 开发速度快：从"搭环境"到"写业务"，时间缩短80%
2. 📦 依赖管理简单：starter自动管理版本兼容性
3. ⚡ 启动速度快：内嵌Tomcat，秒级启动
4. 🛠️ 配置简单：约定优于配置，0配置也能跑
5. 📈 学习曲线平缓：新手3天上手，1周能独立开发

3.3 数据对比

| 指标 | 传统Spring | Spring Boot | 提升 | |------|-----------|-------------|------| | 搭建项目时间 | 2-3天 | 30分钟 | 90%↓ | | 配置文件数量 | 5-10个 | 1个 | 80%↓ | | 依赖冲突概率 | 高 | 低 | 70%↓ | | 启动时间 | 30-60秒 | 5-10秒 | 80%↓ |

---

四、怎么用Spring Boot？

4.1 快速开始（5分钟创建第一个项目）

步骤1：创建项目

方式一：使用Spring Initializr（推荐）

1. 访问 https://start.spring.io/
2. 选择：
   • Project: Maven Project
   • Language: Java
   • Spring Boot: 2.7.14（稳定版本）
   • Group: com.example
   • Artifact: seckill-demo
   • Package name: com.example.seckill
   • Packaging: Jar
   • Java: 8或11
3. 添加依赖：
   • Spring Web
   • Spring Data JPA
   • MySQL Driver
   • Lombok
4. 点击"Generate"下载项目

方式二：使用IDEA创建

1. New Project → Spring Initializr
2. 后续步骤同上

步骤2：项目结构说明

seckill-demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/seckill/
│   │   │       ├── SeckillDemoApplication.java  # 启动类
│   │   │       ├── controller/                   # 控制器层

│   │   │       ├── service/                      # 业务层
│   │   │       ├── dao/                          # 数据访问层
│   │   │       ├── entity/                       # 实体类
│   │   │       └── config/                       # 配置类
│   │   └── resources/
│   │       ├── application.yml                   # 配置文件
│   │       ├── static/                           # 静态资源
│   │       └── templates/                       # 模板文件
│   └── test/                                     # 测试代码
├── pom.xml                                       # Maven配置
└── README.md

4.2 实战：电商秒杀系统核心功能

4.2.1 数据库设计

-- 商品表
CREATE TABLE `product` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) NOT NULL COMMENT '商品名称',
  `price` decimal(10,2) NOT NULL COMMENT '商品价格',
  `stock` int(11) NOT NULL COMMENT '库存数量',
  `seckill_price` decimal(10,2) NOT NULL COMMENT '秒杀价格',
  `seckill_start_time` datetime NOT NULL COMMENT '秒杀开始时间',
  `seckill_end_time` datetime NOT NULL COMMENT '秒杀结束时间',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品表';

-- 订单表
CREATE TABLE `order` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` bigint(20) NOT NULL COMMENT '用户ID',
  `product_id` bigint(20) NOT NULL COMMENT '商品ID',
  `order_no` varchar(64) NOT NULL COMMENT '订单号',
  `amount` decimal(10,2) NOT NULL COMMENT '订单金额',
  `status` tinyint(4) NOT NULL DEFAULT '0' COMMENT '订单状态:0-待支付,1-已支付,2-已取消',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_order_no` (`order_no`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表';

-- 插入测试数据
INSERT INTO `product` (`name`, `price`, `stock`, `seckill_price`, `seckill_start_time`, `seckill_end_time`) VALUES
('iPhone 15 Pro', 7999.00, 100, 5999.00, '2024-01-01 10:00:00', '2024-01-01 12:00:00'),
('MacBook Pro', 12999.00, 50, 9999.00, '2024-01-01 10:00:00', '2024-01-01 12:00:00');

4.2.2 配置文件

# application.yml
server:
  port: 8080

spring:
  application:
    name: seckill-demo
  
  # 数据源配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/seckill?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: your_password
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
  
  # JPA配置
  jpa:
    hibernate:
      ddl-auto: update  # 开发环境用update，生产环境用none或validate
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        dialect: org.hibernate.dialect.MySQL8Dialect

# 日志配置
logging:
  level:
    com.example.seckill: debug
    org.hibernate.SQL: debug

4.2.3 实体类

package com.example.seckill.entity;

import lombok.Data;
import javax.persistence.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 商品实体类
 * 使用Lombok简化getter/setter
 */
@Data
@Entity
@Table(name = "product")
public class Product {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, length = 100)
    private String name;
    
    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal price;
    
    @Column(nullable = false)
    private Integer stock;
    
    @Column(name = "seckill_price", nullable = false, precision = 10, scale = 2)
    private BigDecimal seckillPrice;
    
    @Column(name = "seckill_start_time", nullable = false)
    private LocalDateTime seckillStartTime;
    
    @Column(name = "seckill_end_time", nullable = false)
    private LocalDateTime seckillEndTime;
    
    @Column(name = "create_time", nullable = false, updatable = false)
    private LocalDateTime createTime;
    
    @PrePersist
    protected void onCreate() {
        createTime = LocalDateTime.now();
    }
}

package com.example.seckill.entity;

import lombok.Data;
import javax.persistence.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 订单实体类
 */
@Data
@Entity
@Table(name = "order")
public class Order {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "user_id", nullable = false)
    private Long userId;
    
    @Column(name = "product_id", nullable = false)
    private Long productId;
    
    @Column(name = "order_no", nullable = false, unique = true, length = 64)
    private String orderNo;
    
    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal amount;
    
    @Column(nullable = false)
    private Integer status = 0; // 0-待支付,1-已支付,2-已取消
    
    @Column(name = "create_time", nullable = false, updatable = false)
    private LocalDateTime createTime;
    
    @PrePersist
    protected void onCreate() {
        createTime = LocalDateTime.now();
    }
}

4.2.4 Repository层

package com.example.seckill.dao;

import com.example.seckill.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Lock;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import javax.persistence.LockModeType;
import java.util.Optional;

/**
 * 商品数据访问层
 * JpaRepository提供了基础的CRUD操作
 */
public interface ProductRepository extends JpaRepository<Product, Long> {
    
    /**
     * 根据ID查询商品，并加悲观锁
     * 用于秒杀场景防止超卖
     */
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT p FROM Product p WHERE p.id = :id")
    Optional<Product> findByIdWithLock(@Param("id") Long id);
    
    /**
     * 减少库存
     * 使用原生SQL更新，避免JPA的先查后更新问题
     */
    @Modifying
    @Query(value = "UPDATE product SET stock = stock - :num WHERE id = :id AND stock >= :num", nativeQuery = true)
    int reduceStock(@Param("id") Long id, @Param("num") Integer num);
}

package com.example.seckill.dao;

import com.example.seckill.entity.Order;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * 订单数据访问层
 */
public interface OrderRepository extends JpaRepository<Order, Long> {
}

4.2.5 Service层

package com.example.seckill.service;

import com.example.seckill.dao.OrderRepository;
import com.example.seckill.dao.ProductRepository;
import com.example.seckill.entity.Order;
import com.example.seckill.entity.Product;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.UUID;

/**
 * 秒杀业务服务类
 * 
 * @Transactional注解：声明式事务管理
 * @RequiredArgsConstructor：Lombok生成构造函数，用于依赖注入
 * @Slf4j：Lombok生成日志对象
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class SeckillService {
    
    private final ProductRepository productRepository;
    private final OrderRepository orderRepository;
    
    /**
     * 执行秒杀操作
     * 
     * @param userId 用户ID
     * @param productId 商品ID
     * @return 订单号
     */
    @Transactional(rollbackFor = Exception.class)
    public String doSeckill(Long userId, Long productId) {
        log.info("用户{}开始秒杀商品{}", userId, productId);
        
        // 1. 查询商品信息（加悲观锁）
        Product product = productRepository.findByIdWithLock(productId)
                .orElseThrow(() -> new RuntimeException("商品不存在"));
        
        // 2. 校验秒杀时间
        LocalDateTime now = LocalDateTime.now();
        if (now.isBefore(product.getSeckillStartTime())) {
            throw new RuntimeException("秒杀尚未开始");
        }
        if (now.isAfter(product.getSeckillEndTime())) {
            throw new RuntimeException("秒杀已结束");
        }
        
        // 3. 校验库存
        if (product.getStock() <= 0) {
            throw new RuntimeException("商品已售罄");
        }
        
        // 4. 减少库存
        int rows = productRepository.reduceStock(productId, 1);
        if (rows == 0) {
            throw new RuntimeException("库存不足，秒杀失败");
        }
        
        // 5. 创建订单
        Order order = new Order();
        order.setUserId(userId);
        order.setProductId(productId);
        order.setOrderNo(generateOrderNo());
        order.setAmount(product.getSeckillPrice());
        order.setStatus(0); // 待支付
        orderRepository.save(order);
        
        log.info("用户{}秒杀商品{}成功，订单号：{}", userId, productId, order.getOrderNo());
        
        return order.getOrderNo();
    }
    
    /**
     * 生成订单号
     */
    private String generateOrderNo() {
        return UUID.randomUUID().toString().replace("-", "");
    }
    
    /**
     * 查询商品详情
     */
    public Product getProductDetail(Long productId) {
        return productRepository.findById(productId)
                .orElseThrow(() -> new RuntimeException("商品不存在"));
    }
}

4.2.6 Controller层

package com.example.seckill.controller;

import com.example.seckill.entity.Product;
import com.example.seckill.service.SeckillService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

/**
 * 秒杀接口控制器
 * 
 * @RestController：组合了@Controller和@ResponseBody
 * @RequiredArgsConstructor：Lombok生成构造函数
 * @Slf4j：Lombok生成日志对象
 */
@Slf4j
@RestController
@RequestMapping("/api/seckill")
@RequiredArgsConstructor
public class SeckillController {
    
    private final SeckillService seckillService;
    
    /**
     * 查询商品详情
     * GET请求：/api/seckill/product/1
     */
    @GetMapping("/product/{id}")
    public Result<Product> getProduct(@PathVariable Long id) {
        try {
            Product product = seckillService.getProductDetail(id);
            return Result.success(product);
        } catch (Exception e) {
            log.error("查询商品失败：{}", e.getMessage());
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 执行秒杀
     * POST请求：/api/seckill/do?userId=1&productId=1
     */
    @PostMapping("/do")
    public Result<String> doSeckill(@RequestParam Long userId, @RequestParam Long productId) {
        try {
            String orderNo = seckillService.doSeckill(userId, productId);
            return Result.success(orderNo, "秒杀成功");
        } catch (Exception e) {
            log.error("秒杀失败：userId={}, productId={}, error={}", userId, productId, e.getMessage());
            return Result.error(e.getMessage());
        }
    }
    
    /**
     * 统一返回结果封装
     */
    @lombok.Data
    public static class Result<T> {
        private Integer code;
        private String message;
        private T data;
        
        public static <T> Result<T> success(T data) {
            return success(data, "操作成功");
        }
        
        public static <T> Result<T> success(T data, String message) {
            Result<T> result = new Result<>();
            result.setCode(200);
            result.setMessage(message);
            result.setData(data);
            return result;
        }
        
        public static <T> Result<T> error(String message) {
            Result<T> result = new Result<>();
            result.setCode(500);
            result.setMessage(message);
            return result;
        }
    }
}

4.2.7 启动类

package com.example.seckill;

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

/**
 * Spring Boot启动类
 * 
 * @SpringBootApplication：这是一个组合注解，包含：
 * - @SpringBootConfiguration：标识为配置类
 * - @EnableAutoConfiguration：开启自动配置
 * - @ComponentScan：自动扫描组件
 */
@SpringBootApplication
public class SeckillDemoApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(SeckillDemoApplication.class, args);
        System.out.println("");
        System.out.println("========================================");
        System.out.println("  秒杀系统启动成功！访问地址：http://localhost:8080");
        System.out.println("========================================");
        System.out.println("");
    }
}

4.3 测试接口

使用Postman测试

1. 查询商品详情

GET http://localhost:8080/api/seckill/product/1

响应：

{
    "code": 200,
    "message": "操作成功",
    "data": {
        "id": 1,
        "name": "iPhone 15 Pro",
        "price": 7999.00,
        "stock": 100,
        "seckillPrice": 5999.00,
        "seckillStartTime": "2024-01-01T10:00:00",
        "seckillEndTime": "2024-01-01T12:00:00",
        "createTime": "2024-01-01T00:00:00"
    }
}

2. 执行秒杀

POST http://localhost:8080/api/seckill/do?userId=1&productId=1

响应：

{
    "code": 200,
    "message": "秒杀成功",
    "data": "a1b2c3d4e5f6g7h8i9j0"
}

使用curl测试

# 查询商品
curl http://localhost:8080/api/seckill/product/1

# 执行秒杀
curl -X POST "http://localhost:8080/api/seckill/do?userId=1&productId=1"

---

五、实战踩坑总结

坑1：事务失效问题

现象：

@Service
public class SeckillService {
    
    @Transactional
    public void doSeckill(Long userId, Long productId) {
        // 业务逻辑
    }
    
    // 问题：内部调用，事务失效
    public void outerMethod() {
        doSeckill(1L, 1L); // 事务不生效！
    }
}

原因： Spring的事务是基于AOP实现的，通过代理对象调用才会生效。内部调用绕过了代理，导致事务失效。

解决方案：

// 方案1：自己注入自己
@Service
@RequiredArgsConstructor
public class SeckillService {
    
    private final SeckillService self; // Spring会自动注入代理对象
    
    public void outerMethod() {
        self.doSeckill(1L, 1L); // 事务生效
    }
}

// 方案2：使用AopContext
@Service
public class SeckillService {
    
    @Transactional
    public void doSeckill(Long userId, Long productId) {
        // 业务逻辑
    }
    
    public void outerMethod() {
        ((SeckillService) AopContext.currentProxy()).doSeckill(1L, 1L);
    }
}

坑2：日期时间格式化问题

现象：

{
    "seckillStartTime": "2024-01-01T10:00:00",  // 前端不想要这个T
    "seckillEndTime": "2024-01-01T12:00:00"
}

解决方案：

// 方案1：全局配置
@Configuration
public class JacksonConfig {
    
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer customizer() {
        return builder -> {
            builder.simpleDateFormat("yyyy-MM-dd HH:mm:ss");
            builder.serializers(new LocalDateTimeSerializer(
                DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
            ));
        };
    }
}

// 方案2：字段注解
public class Product {
    
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime seckillStartTime;
}

坑3：循环依赖问题

现象：

***************************
APPLICATION FAILED TO START
***************************

Description:

The dependencies of some of the beans in the application context form a cycle:

┌─────┐
|  seckillService
↑     ↓
|  orderService
└─────┘

原因： 两个Service互相依赖，形成循环引用。

解决方案：

// 方案1：重构代码，消除循环依赖
// 将公共逻辑抽取到第三个Service

// 方案2：使用@Lazy注解（不推荐，治标不治本）
@Service
@RequiredArgsConstructor
public class SeckillService {
    
    @Lazy  // 延迟加载
    private final OrderService orderService;
}

// 方案3：使用Setter注入（Spring 2.6+默认不允许循环依赖）
@Service
public class SeckillService {
    
    private OrderService orderService;
    
    @Autowired
    public void setOrderService(OrderService orderService) {
        this.orderService = orderService;
    }
}

坑4：跨域问题

现象： 浏览器控制台报错：

Access to XMLHttpRequest at 'http://localhost:8080/api/seckill/do' from origin 
'http://localhost:3000' has been blocked by CORS policy

解决方案：

@Configuration
public class CorsConfig {
    
    @Bean
    public CorsFilter corsFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedOrigin("*"); // 生产环境要指定具体域名
        config.addAllowedMethod("*");
        config.addAllowedHeader("*");
        config.setAllowCredentials(true);
        
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        
        return new CorsFilter(source);
    }
}

坑5：连接池耗尽

现象：

java.sql.SQLTransientConnectionException: 
HikariPool-1 - Connection is not available, request timed out after 30000ms.

原因： 数据库连接池配置不合理，或者连接没有正确释放。

解决方案：

spring:
  datasource:
    hikari:
      maximum-pool-size: 20      # 最大连接数
      minimum-idle: 5             # 最小空闲连接
      connection-timeout: 30000   # 获取连接超时时间
      idle-timeout: 600000        # 空闲连接超时时间
      max-lifetime: 1800000       # 连接最大生命周期
      connection-test-query: SELECT 1  # 连接测试查询

代码层面：

// 确保使用@Transactional，自动释放连接
@Transactional
public void doSeckill(Long userId, Long productId) {
    // 业务逻辑
}

// 手动管理连接时，确保在finally中关闭
public void manualConnection() {
    Connection conn = null;
    try {
        conn = dataSource.getConnection();
        // 业务逻辑
    } finally {
        if (conn != null) {
            conn.close();
        }
    }
}

---

六、延伸阅读与进阶方向

6.1 Spring Boot核心原理

• 自动配置原理：了解@EnableAutoConfiguration的工作机制
• Starter原理：学习如何自定义Starter
• 启动流程：掌握SpringApplication的启动过程

6.2 高并发优化

• Redis缓存：使用Redis缓存热点数据
• 消息队列：使用RabbitMQ/Kafka异步处理订单
• 分布式锁：使用Redisson实现分布式锁
• 限流降级：使用Sentinel实现接口限流

6.3 微服务架构

• Spring Cloud：学习微服务全家桶
• 服务注册与发现：Nacos/Eureka
• 服务调用：OpenFeign
• 网关：Spring Cloud Gateway

6.4 监控与运维

• Actuator：Spring Boot应用监控
• Prometheus + Grafana：监控可视化
• ELK Stack：日志收集与分析

6.5 推荐学习资源

| 资源类型 | 名称 | 推荐理由 | |---------|------|----------| | 官方文档 | Spring Boot Reference Guide | 最权威、最全面的资料 | | 书籍 | 《Spring Boot实战》 | 入门经典，案例丰富 | | 书籍 | 《深入理解Spring Boot》 | 进阶必读，剖析原理 | | 视频 | B站尚硅谷Spring Boot教程 | 讲解细致，适合初学者 | | 博客 | 程序猿DD | 持续更新，干货满满 |

---

七、总结

通过本文的学习，你应该已经掌握了：

✅ Spring Boot的核心概念：自动配置、起步依赖、内嵌服务器 ✅ Spring Boot的优势：简化开发、提高效率、降低门槛 ✅ 实战项目开发：从0到1搭建秒杀系统 ✅ 常见问题解决：事务、跨域、连接池等问题 ✅ 进阶学习方向：微服务、高并发、监控运维

最后送给大家一句话：

"纸上得来终觉浅，绝知此事要躬行。"

看完本文，一定要自己动手敲一遍代码，遇到问题不要怕，解决问题的过程就是你成长的过程！

如有疑问，欢迎在评论区留言讨论！ 🎉

---

作者简介：10年Java开发经验，先后在阿里、美团任职，专注于高并发、微服务架构设计。喜欢分享技术，致力于帮助更多Java初学者快速成长。