java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring Boot 3X 框架使用

Spring Boot 3X 框架核心组件的使用详解

作者：符哥2008

SpringBoot核心组件详解,涵盖Starter依赖、自动配置、主启动类、配置文件、核心注解、Web开发、数据访问和效率提升组件,适合企业开发,本文介绍Spring Boot 3X 框架核心组件的使用,感兴趣的朋友跟随小编一起看看吧

Spring Boot 框架核心组件的完整使用详解，我会聚焦 Spring Boot 最常用、企业开发必备的核心组件，从组件核心作用、配置方式、实战代码、使用场景四个维度讲解，基于Spring Boot 3.2.x（最新稳定版，适配 Java 17+、Spring 6），所有代码都是可直接复制的开箱即用版本，同时兼顾注解式配置（主流）和核心原理极简解读，让你既能快速上手使用，也能理解组件间的配合逻辑。

前置基础

Spring Boot 的核心是约定大于配置，通过自动配置（AutoConfiguration） 消除 Spring 原生的繁琐 XML 配置，所有组件都基于Starter 起步依赖引入，只需少量配置（甚至零配置）即可使用。

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

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

核心作用

Starter 是 Spring Boot 的组件依赖封装，将某个功能的所有相关依赖（如核心包、依赖包、配置包）整合为一个 Maven/Gradle 依赖，只需引入 1 个 Starter，即可自动引入该功能的所有必要依赖，避免手动管理依赖版本、解决依赖冲突。

核心设计

实战使用（pom.xml）

<!-- 基础核心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>

2. 主启动类（@SpringBootApplication）

核心作用

Spring Boot 项目的入口类，通过注解开启自动配置、组件扫描、配置属性绑定三大核心功能，是项目启动的唯一入口。

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

// 核心复合注解，等价于以下三个注解的组合
@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);
    }
}

关键注意

主启动类建议放在项目根包（如com.example.demo），否则需用scanBasePackages手动指定扫描包，否则子包的组件无法被 Spring 扫描并注册。

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

核心作用

Spring Boot 的全局配置文件，用于覆盖组件的默认自动配置（如端口、数据库连接、日志级别），支持yml（推荐，层级清晰） 和properties（键值对） 两种格式，项目启动时会自动加载src/main/resources/下的该文件。

配置优先级

application-dev.yml（开发环境） > application-prod.yml（生产环境） > application.yml（全局默认），可通过多环境配置切换不同环境的配置。

核心使用

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

# 服务器配置（覆盖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 # 项目名称，服务注册/日志中会使用

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

  1. 新建多环境配置文件：
    • 开发环境：application-dev.yml（本地开发，端口 8081，日志级别 DEBUG）
    • 生产环境：application-prod.yml（线上部署，端口 80，日志级别 INFO）
  2. 在application.yml中指定激活的环境：
spring:
  profiles:
    active: dev # 激活开发环境，改为prod即切换到生产环境

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

开发中常需要自定义配置（如自定义接口前缀、业务常量），Spring Boot 提供两种方式绑定到 Java 类：

方式 1：@Value（简单配置，单个属性绑定）适合单个 / 少量自定义属性，直接在 Bean 中注入：

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;
    }
}

对应的 yml 配置：

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

方式 2：@ConfigurationProperties（复杂配置，批量绑定）适合多个相关自定义属性（如微信配置、OSS 配置），批量绑定到一个配置类，更规范、支持配置提示：步骤 1：编写配置类，添加注解：

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; }
}

步骤 2：yml 中添加对应配置：

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

步骤 3：在业务类中注入使用：

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();
    }
}

步骤 4：添加配置提示依赖（可选，IDEA 中显示配置注解，避免手敲错误）：

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

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

Spring Boot 的所有组件都基于Spring IOC 容器，核心是将对象交给 Spring 管理（Bean 注册） + 从 Spring 容器中获取对象（依赖注入），以下是最核心的注解，所有业务开发都离不开：

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

标记在类上，Spring 启动时会自动扫描并创建该类的实例，存入 IOC 容器，全局唯一（默认单例）。

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

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

标记在字段 / 构造方法 /setter 方法上，Spring 会自动从 IOC 容器中找到对应的 Bean，注入到当前类中，无需手动new对象，实现解耦。

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

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

标记在配置类的方法上，用于将第三方组件 / 无注解的类注册为 Spring Bean（如 RedisTemplate、RestTemplate），方法返回值即为 Bean 实例，方法名为 Bean 名称。

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，直接使用

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

基于spring-boot-starter-web，实现 RESTful 接口开发，包含MVC 核心、请求处理、响应处理、拦截器、跨域等，是后端开发最核心的组件。

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

核心区别

实战使用（RESTful 接口）

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 setId(String name) { this.name = name; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
}

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

都是@RequestMapping的简化版，指定请求方式，避免在 @RequestMapping 中手动设置method = RequestMethod.GET：

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

核心作用

统一处理项目中所有的未捕获异常，避免接口返回默认的 500 错误页面 / 杂乱的异常信息，返回统一的 JSON 格式响应，提升接口的友好性和可维护性。

核心注解

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

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;
// 全局异常处理，作用于所有@RestController
@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不合法");
        }
        // 业务逻辑：删除用户
    }
}

3. 拦截器（Interceptor）

核心作用

拦截接口请求，在请求处理前、处理后、视图渲染后（Rest 接口无此步骤） 执行自定义逻辑，如登录验证、接口限流、日志记录、参数校验等。

实现步骤

  1. 实现HandlerInterceptor接口，重写拦截方法；
  2. 在配置类中实现WebMvcConfigurer接口，重写addInterceptors方法，注册拦截器并指定拦截 / 放行路径。

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

// 步骤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"); // 放行登录/注册接口
    }
}

4. 跨域配置（CORS）

核心作用

解决前后端分离项目中的跨域问题（浏览器同源策略限制：协议、域名、端口任一不同即为跨域，如前端http://localhost:3000访问后端http://localhost:8081）。

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

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

在WebMvcConfig中重写addCorsMappings方法：

@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); // 预检请求有效期（秒），避免重复发送预检请求
    }
    // 拦截器注册...
}

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

用@CrossOrigin注解，标记在控制器 / 方法上：

// 控制器级别：该类所有接口允许跨域
@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\":\"张三\"}";
    }
}

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

Spring Boot 提供了多种数据访问组件，适配不同的数据库操作框架，最常用的是 MyBatis-Plus（简化 MyBatis） 和Spring Data JPA（ORM 框架），以下讲解基于MyBatis-Plus（企业开发主流，比原生 MyBatis 少写 80% 代码）。

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

<!-- 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>

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

配置数据库连接、MyBatis-Plus、连接池参数：

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日志，方便调试

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

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

标记实体类与数据库表的映射关系：

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...
}

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

MyBatis-Plus 的核心，继承BaseMapper<T>即可获得单表 CRUD 所有方法，无需手动编写 Mapper 接口和 XML：

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/注解
}

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

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;
    }
}

4. 事务管理（@Transactional）

核心作用

保证多个数据库操作的原子性（要么全部成功，要么全部失败），避免出现数据不一致（如转账时扣了 A 的钱，没加 B 的钱）。

实战使用

标记在服务层方法上（必须在服务层，控制器层无效），Spring 会自动为该方法添加事务支持：

@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;
    }
}

核心属性

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

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

核心作用

修改代码 / 配置后，无需手动重启项目，自动重启 Spring Boot 应用，提升开发效率（仅开发环境使用，生产环境禁用）。

依赖与配置

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

yml 配置（可选，优化热部署）：

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

IDEA 配置（必做，否则热部署不生效）：

  1. 开启自动编译：File → Settings → Build, Execution, Deployment → Compiler → 勾选Build project automatically；
  2. 开启高级自动编译：按住Ctrl+Alt+Shift+/ → 选择 Registry → 勾选compiler.automake.allow.when.app.running。

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

核心作用

通过注解替代 Java 中繁琐的getter/setter/toString/ 构造方法，减少代码量，提升开发效率（需安装 IDEA Lombok 插件）。

核心依赖与注解

<!-- 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;
}

其他常用注解：

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

核心作用

自动生成RESTful 接口文档，支持在线调试、接口测试、文档导出，替代传统的 Word 文档，实现接口文档与代码同步更新（Swagger3 的增强版，更适配 Spring Boot 3+）。

核心依赖与配置

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

配置类（开启 Swagger3）：

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"));
    }
}

yml 配置（开发环境开启，生产环境关闭）：

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, "zhangsan@163.com");
    }
}

访问文档

项目启动后，访问：http://localhost:8081/doc.html（替换为自己的端口 / 上下文路径），即可看到接口文档，支持在线调试（直接填写参数，点击 “发送” 即可测试接口）。

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

plaintext

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

全局组件兜底：

六、总结（核心关键点）

  1. Spring Boot 核心思想：约定大于配置，通过Starter 起步依赖和自动配置消除繁琐配置，专注业务开发；
  2. 基础三件套：主启动类（@SpringBootApplication）+ 配置文件（application.yml）+ 核心注解（Bean 注册 / 依赖注入），所有项目必用；
  3. Web 开发核心：@RestController 实现 RESTful 接口，@RestControllerAdvice 实现全局异常处理，Interceptor 实现请求拦截，CORS 解决跨域；
  4. 数据访问核心：MyBatis-Plus 简化数据库操作，@Transactional 保证事务原子性，Druid 作为高性能连接池；
  5. 效率提升组件：Lombok 消除样板代码，devtools 实现热部署，Knife4j 自动生成接口文档，都是企业开发必备；
  6. 核心原则：
    • 所有组件通过Starter引入，避免手动管理依赖；
    • 所有自定义 Bean 通过 **@Configuration + @Bean** 声明，或通过 @Component 系列注解注册；
    • 所有依赖通过 **@Autowired/@Resource** 注入，无需手动 new，实现解耦；
    • 开发环境与生产环境通过多环境配置分离，避免配置混用。

以上就是 Spring Boot 最核心、最常用的组件使用详解，覆盖了从基础项目搭建到后端接口开发、数据库操作、效率提升的全流程，所有代码都可直接复制到 Spring Boot 3.2.x 项目中使用，适配企业开发的主流场景。

到此这篇关于Spring Boot 3X 框架核心组件的使用详解的文章就介绍到这了,更多相关Spring Boot 3X 框架使用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文