Spring Boot 3.x 框架核心组件使用详解

Spring Boot 3.x 框架核心组件使用详解 | 极客日志

<!-- 基础核心 Starter（所有 Spring Boot 项目必加） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- Web 开发 Starter（MVC+Tomcat，后端接口必加） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 测试 Starter（Junit5+MockMvc，单元测试必加） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

// 核心复合注解，等价于以下三个注解的组合
// @SpringBootApplication = @SpringBootConfiguration + @EnableAutoConfiguration + @ComponentScan

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

// 注解加在主类上，扫描包：com.example.demo 及其所有子包
@SpringBootApplication
// 可选：指定扫描包（若主类不在项目根包，需手动指定）
// @SpringBootApplication(scanBasePackages = "com.example")
public class SpringBootComponentDemoApplication {
    // 项目启动入口方法，固定写法
    public static void main(String[] args) {
        // 启动 Spring Boot 应用，返回 Spring 容器（ApplicationContext）
        SpringApplication.run(SpringBootComponentDemoApplication.class, args);
    }
}

# 服务器配置（覆盖 spring-boot-starter-web 的默认配置）
server:
  port: 8081 # 项目启动端口，默认 8080
  servlet:
    context-path: /demo # 接口上下文路径，默认/，访问时需加/demo（如 http://localhost:8081/demo/hello）

# Spring 核心配置
spring:
  application:
    name: spring-boot-component-demo # 项目名称，服务注册/日志中会使用

spring:
  profiles:
    active: dev # 激活开发环境，改为 prod 即切换到生产环境

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

// 组件注解：将该类注册为 Spring Bean
@Component
// 配置前缀：绑定 yml 中的 wechat 节点下的所有属性
@ConfigurationProperties(prefix = "wechat")
public class WechatProperties {
    // 与 yml 中的属性名一致（驼峰自动匹配横杠命名：app-id → appId）
    private String appId;
    private String appSecret;
    private String mchId; // 商户号

    // 必须提供 getter/setter，否则无法绑定（Lombok 的@Data可自动生成）
    public String getAppId() { return appId; }
    public void setAppId(String appId) { this.appId = appId; }
    public String getAppSecret() { return appSecret; }
    public void setAppSecret(String appSecret) { this.appSecret = appSecret; }
    public String getMchId() { return mchId; }
    public void setMchId(String mchId) { this.mchId = mchId; }
}

# 微信配置
wechat:
  app-id: wx1234567890abcdef
  app-secret: 1234567890abcdef1234567890abcdef
  mch-id: 1234567890

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class WechatController {
    // 注入配置类
    @Autowired
    private WechatProperties wechatProperties;

    @GetMapping("/wechat/info")
    public String wechatInfo() {
        return "微信 AppId：" + wechatProperties.getAppId() + "，商户号：" + wechatProperties.getMchId();
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    // 绑定 yml 中的自定义配置：app.api-prefix
    @Value("${app.api-prefix:/api/v1}") // 冒号后为默认值，若配置中无该属性则使用默认值
    private String apiPrefix;

    @GetMapping("/hello")
    public String hello() {
        return "Hello Spring Boot! 接口前缀：" + apiPrefix;
    }
}

# 自定义配置
app:
  api-prefix: /api/v2

注解	作用	适用场景
`@Component`	通用 Bean 注册注解	通用工具类、非业务层类
`@Controller`	继承自 @Component，标记控制层	接口请求处理类（接收请求、返回响应）
`@Service`	继承自 @Component，标记服务层	业务逻辑处理类（核心业务、事务控制）
`@Repository`	继承自 @Component，标记数据访问层	数据库操作类（DAO/Mapper，MyBatis 中一般用 @Mapper 替代）
`@Configuration`	标记配置类	声明自定义 Bean（如第三方组件配置、拦截器配置）

注解	作用	特点
`@Autowired`	按类型注入 Bean	Spring 核心注解，自动匹配类型，支持`required = false`（非必须注入）
`@Resource`	按名称注入 Bean（JDK 原生）	若有多个同类型 Bean，可通过`name`指定，如`@Resource(name = "userServiceImpl")`
`@Qualifier`	配合 @Autowired，按名称注入	解决同类型多个 Bean 的注入问题，如`@Autowired + @Qualifier("userServiceImpl")`

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

// 配置类
@Configuration
public class WebConfig {
    // 声明 RestTemplate 为 Spring Bean，全局可注入使用
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Autowired
private RestTemplate restTemplate; // 无需 new，直接使用

import org.springframework.web.bind.annotation.*;

// 标记为 RestController，所有方法返回 JSON
@RestController
// 类级别的请求路径，所有方法的路径都基于此（如/hello → /user/hello）
@RequestMapping("/user")
public class UserController {
    // GET 请求：查询用户，路径/ user /get/{id}（路径参数）
    @GetMapping("/get/{id}")
    // @PathVariable：获取 URL 路径中的参数
    public String getUser(@PathVariable Long id) {
        return "{\"id\":" + id + ", \"name\":\"张三\", \"age\":25}";
    }

    // POST 请求：新增用户，接收 JSON 参数
    @PostMapping("/add")
    // @RequestBody：将请求体的 JSON 字符串绑定到 User 对象（自动反序列化）
    public String addUser(@RequestBody User user) {
        return "新增用户成功：" + user.getName();
    }

    // GET 请求：分页查询，接收请求参数（如/page?pageNum=1&pageSize=10）
    @GetMapping("/page")
    // @RequestParam：获取请求参数，支持默认值
    public String pageQuery(@RequestParam Integer pageNum, @RequestParam(defaultValue = "10") Integer pageSize) {
        return "分页查询：第" + pageNum + "页，每页" + pageSize + "条";
    }
}

// 实体类（配合@RequestBody 使用，需提供 getter/setter，Lombok@Data可简化）
class User {
    private Long id;
    private String name;
    private Integer age;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
}

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import java.util.HashMap;
import java.util.Map;

// 全局异常处理，作用于所有@RestControllerr
@RestControllerAdvice
public class GlobalExceptionHandler {
    // 处理所有未捕获的异常（兜底）
    @ExceptionHandler(Exception.class)
    public Map<String, Object> handleAllException(Exception e) {
        Map<String, Object> result = new HashMap<>();
        result.put("code", HttpStatus.INTERNAL_SERVER_ERROR.value()); // 500
        result.put("msg", "服务器内部错误：" + e.getMessage()); // 异常信息
        result.put("data", null);
        return result;
    }

    // 处理自定义业务异常（推荐，项目中自定义异常，精准处理）
    @ExceptionHandler(BusinessException.class)
    public Map<String, Object> handleBusinessException(BusinessException e) {
        Map<String, Object> result = new HashMap<>();
        result.put("code", e.getCode()); // 自定义错误码
        result.put("msg", e.getMsg()); // 自定义错误信息
        result.put("data", null);
        return result;
    }

    // 处理空指针异常（精准处理特定异常）
    @ExceptionHandler(NullPointerException.class)
    public Map<String, Object> handleNPE(NullPointerException e) {
        Map<String, Object> result = new HashMap<>();
        result.put("code", 400);
        result.put("msg", "空指针异常：" + e.getMessage());
        result.put("data", null);
        return result;
    }
}

// 自定义业务异常（项目中建议创建，用于业务逻辑错误）
class BusinessException extends RuntimeException {
    private Integer code;
    private String msg;

    public BusinessException(Integer code, String msg) {
        super(msg);
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() { return code; }
    public String getMsg() { return msg; }
}

@Service
public class UserService {
    public void deleteUser(Long id) {
        if (id == null || id <= 0) {
            // 抛出自定义业务异常，由全局异常处理器处理
            throw new BusinessException(400, "用户 ID 不合法");
        }
        // 业务逻辑：删除用户
    }
}

// 步骤 1：实现 HandlerInterceptor，编写拦截逻辑
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginInterceptor implements HandlerInterceptor {
    // 核心方法：请求处理前执行（return true：放行，return false：拦截）
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 逻辑：从请求头获取 token，验证是否登录
        String token = request.getHeader("token");
        if (token == null || token.isEmpty()) {
            // 未登录，返回 401 错误
            response.setStatus(401);
            response.getWriter().write("{\"code\":401, \"msg\":\"未登录，请先登录\", \"data\":null}");
            return false; // 拦截请求
        }
        // 登录验证通过，放行
        return true;
    }

    // 可选：请求处理后执行（控制器方法执行完，未返回响应前）
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, org.springframework.web.servlet.ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    // 可选：视图渲染后执行（Rest 接口无需实现）
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

// 步骤 2：配置类中注册拦截器
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    // 注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**") // 拦截所有路径
                .excludePathPatterns("/user/login", "/user/register"); // 放行登录/注册接口
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    // 全局跨域配置
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**") // 允许所有路径跨域
                .allowedOriginPatterns("*") // 允许所有域名跨域（Spring Boot 2.4+替代 allowedOrigins("*")）
                .allowedMethods("GET", "POST", "PUT", "DELETE", "PATCH") // 允许的请求方式
                .allowedHeaders("*") // 允许的请求头
                .allowCredentials(true) // 允许携带 Cookie
                .maxAge(3600); // 预检请求有效期（秒），避免重复发送预检请求
    }

    // 拦截器注册...
}

// 控制器级别：该类所有接口允许跨域
@RestController
@RequestMapping("/user")
@CrossOrigin(origins = "*", maxAge = 3600)
public class UserController {
    // 方法级别：仅该接口允许跨域（覆盖控制器级别配置）
    @GetMapping("/get/{id}")
    @CrossOrigin(origins = "http://localhost:3000")
    public String getUser(@PathVariable Long id) {
        return "{\"id\":" + id + ", \"name\":\"张三\"}";
    }
}

<!-- MyBatis-Plus Starter（整合 MyBatis+ 自动配置） -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.5</version> <!-- 最新稳定版 -->
</dependency>
<!-- MySQL 驱动（适配 MySQL8+，5.x 需修改版本为 5.1.49） -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
<!-- 阿里 Druid 连接池（高性能，推荐，替代默认的 HikariCP） -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.20</version>
</dependency>

spring:
  # 数据库连接配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource # 指定 Druid 连接池
    driver-class-name: com.mysql.cj.jdbc.Driver # MySQL8+ 驱动类
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false
    username: root # 数据库用户名
    password: 123456 # 数据库密码

  # Druid 连接池配置
  druid:
    initial-size: 5 # 初始连接数
    min-idle: 5 # 最小空闲连接数
    max-active: 20 # 最大活跃连接数
    max-wait: 60000 # 最大等待时间（ms）

  # MyBatis-Plus 配置
  mybatis-plus:
    mapper-locations: classpath:mapper/*.xml # Mapper.xml 文件路径（若用注解开发可省略）
    type-aliases-package: com.example.demo.entity # 实体类包名，简化 XML 中的类名
    configuration:
      map-underscore-to-camel-case: true # 开启下划线转驼峰（数据库 user_name → 实体类 userName）
      log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 开启 SQL 日志，方便调试

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

// 映射数据库表：t_user（若实体类名与表名一致，可省略）
@TableName("t_user")
public class User {
    // 主键注解，type = IdType.AUTO：自增主键
    @TableId(type = IdType.AUTO)
    private Long id;

    // 字段注解，若实体类属性与表字段名一致，可省略
    @TableField("user_name")
    private String userName;
    private Integer age;
    private String email;

    // getter/setter...
}

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

// 标记为 MyBatis Mapper，Spring Boot 自动扫描并注册
@Mapper
public interface UserMapper extends BaseMapper<User> {
    // 无需编写任何方法，BaseMapper 已提供所有单表 CRUD
    // 若需复杂查询，可手动编写方法+XML/注解
}

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    // 新增用户
    public boolean addUser(User user) {
        return userMapper.insert(user) > 0;
    }

    // 根据 ID 查询用户
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    // 条件查询：根据姓名模糊查询，年龄大于 20
    public List<User> listUser(String name) {
        // LambdaQueryWrapper：条件构造器，链式编程，避免硬编码字段名
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(User::getUserName, name) // 姓名模糊查询
               .gt(User::getAge, 20); // 年龄大于 20
        return userMapper.selectList(wrapper);
    }

    // 修改用户
    public boolean updateUser(User user) {
        return userMapper.updateById(user) > 0;
    }

    // 删除用户
    public boolean deleteUser(Long id) {
        return userMapper.deleteById(id) > 0;
    }
}

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    // 新增用户并记录日志，开启事务
    // rollbackFor = Exception.class：所有异常都回滚（默认仅运行时异常回滚）
    @Transactional(rollbackFor = Exception.class)
    public boolean addUserAndLog(User user) {
        // 操作 1：新增用户
        userMapper.insert(user);

        // 模拟异常：若出现异常，事务回滚，用户不会被新增
        // int i = 1 / 0;

        // 操作 2：记录日志（假设有 LogMapper）
        // logMapper.insert(new Log("新增用户：" + user.getUserName()));

        return true;
    }
}

<!-- 热部署依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

spring:
  devtools:
    restart:
      enabled: true # 开启热部署
    additional-paths: src/main/java # 监听的代码目录
    exclude: static/**,templates/** # 排除的目录（静态资源/视图，修改后无需重启）

<!-- Lombok 依赖 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.ToString;

@TableName("t_user")
@Data // 自动生成 getter/setter/equals/hashCode/toString
@NoArgsConstructor // 自动生成无参构造方法
@AllArgsConstructor // 自动生成全参构造方法
// @ToString // 单独生成 toString（@Data 已包含）
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String userName;
    private Integer age;
    private String email;
}

<!-- Knife4j Starter（整合 Swagger3，适配 Spring Boot 3+） -->
<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-spring-boot-starter</artifactId>
    <version>4.4.0</version> <!-- 最新稳定版 -->
</dependency>

import com.github.xiaoymin.knife4j.spring.annotations.EnableKnife4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;

@Configuration
@EnableWebMvc
@EnableKnife4j // 开启 Knife4j 增强功能
public class Knife4jConfig {
    // 配置接口文档基本信息
    @Bean
    public OpenAPI openAPI() {
        return new OpenAPI()
                .info(new Info()
                        .title("Spring Boot 组件演示接口文档")
                        .description("Spring Boot 核心组件实战接口")
                        .version("1.0.0"));
    }
}

knife4j:
  enable: true # 开启 Knife4j
openapi:
  title: Spring Boot 组件演示接口文档
  description: 核心组件实战接口
  version: 1.0.0
spring:
  profiles:
    active: dev # 开发环境开启，生产环境改为 prod 并设置 knife4j.enable=false

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Parameters;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {
    // 接口描述
    @Operation(summary = "根据 ID 查询用户", description = "传入用户 ID，返回用户详细信息")
    // 参数描述
    @Parameters({@Parameter(name = "id", description = "用户 ID", required = true)})
    @GetMapping("/get/{id}")
    public User getUser(@PathVariable Long id) {
        return new User(id, "张三", 25, "[email protected]");
    }
}

┌─────────────────────────────────────────────────────────┐
│ 客户端请求（浏览器/前端/Postman） │
└───────────────────────────┬─────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────┐
│ 服务器（Tomcat，由 spring-boot-starter-web 自动嵌入） │
└───────────────────────────┬─────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────┐
│ 拦截器（Interceptor）：登录验证/日志记录/限流 │
└───────────────────────────┬─────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────┐
│ 控制器（@RestController）：接收请求/参数绑定/返回响应 │
└───────────────────────────┬─────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────┐
│ 服务层（@Service）：业务逻辑处理 + 事务管理（@Transactional）│
└───────────────────────────┬─────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────┐
│ 数据访问层（@Mapper/MyBatis-Plus）：操作数据库 │
└───────────────────────────┬─────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────┐
│ 数据库（MySQL/Redis） │
└─────────────────────────────────────────────────────────┘

Spring Boot 3.x 框架核心组件使用详解

前置基础

一、核心基础组件（所有项目必用）

1. Starter 起步依赖（组件入口）

核心作用

核心设计

实战使用（pom.xml）

2. 主启动类（@SpringBootApplication）

核心作用

核心注解拆解（@SpringBootApplication 是复合注解）

实战使用（主启动类代码）

关键注意

3. 配置文件（application.yml/properties）

核心作用

配置优先级

核心使用

（1）基础配置（application.yml，修改默认端口 / 上下文路径）

（2）多环境配置（最常用，避免开发 / 生产配置混用）

（3）自定义配置与属性绑定（@Value/@ConfigurationProperties）

4. 核心注解（Bean 注册与依赖注入）

（1）Bean 注册注解（将类交给 Spring 管理）

（2）依赖注入注解（从 Spring 容器中获取 Bean）

（3）自定义 Bean 声明（@Bean）

二、Web 开发核心组件（后端接口必用）

1. @RestController & @Controller（请求处理核心）

核心区别

实战使用（RESTful 接口）

核心请求注解（@GetMapping/@PostMapping 等）

2. 全局异常处理（@RestControllerAdvice + @ExceptionHandler）

核心作用

核心注解

实战使用（统一异常返回）

使用自定义异常（业务层中抛出）

3. 拦截器（Interceptor）

核心作用

实现步骤

实战使用（登录验证拦截器）

4. 跨域配置（CORS）

核心作用

实战实现（两种方式，推荐全局配置）

方式 1：全局跨域配置（推荐，作用于所有接口）

方式 2：局部跨域配置（作用于单个接口 / 控制器）

三、数据访问核心组件（操作数据库必用）

1. 核心依赖（MyBatis-Plus + 数据库驱动 + 连接池）

2. 数据库配置（application.yml）

3. 核心注解与使用（MyBatis-Plus）

（1）实体类注解（@TableName/@TableId/@TableField）

（2）Mapper 接口（继承 BaseMapper，零 SQL 实现 CRUD）

（3）业务层使用（注入 Mapper，直接调用方法）

4. 事务管理（@Transactional）

核心作用

实战使用

核心属性

四、常用辅助组件（提升开发效率）

1. 热部署（spring-boot-starter-devtools）

核心作用

依赖与配置

2. Lombok（简化代码，消除样板代码）

核心作用

核心依赖与注解

3. 接口文档（Knife4j，替代 Swagger）

核心作用

核心依赖与配置

接口注解（标记接口 / 参数，生成更详细的文档）

访问文档

五、Spring Boot 组件核心配合逻辑（一张图理解）

六、总结（核心关键点）

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具