Spring Boot 核心注解完全手册

Spring Boot 核心注解完全手册 | 极客日志

package com.example.demo;

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

// 核心入口：默认扫描 com.example.demo 及子包
@SpringBootApplication
// 自定义扫描路径（解决跨包扫描问题）
// @SpringBootApplication(scanBasePackages = {"com.example.service", "com.example.mapper"})
// 排除指定自动配置（解决冲突）
// @SpringBootApplication(exclude = RedisAutoConfiguration.class)
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

痛点	解决方案
跨包的 Bean 扫描不到（如 com.example.api 下的 Controller）	1. 用 `scanBasePackages` 指定所有需要扫描的包；2. 将主类包名提升为根包（如 com.example）
自动配置冲突（如自定义 RedisTemplate 覆盖默认）	用 `exclude` 排除冲突的自动配置类；或用 `@ConditionalOnMissingBean` 自定义 Bean 覆盖
启动慢	缩小扫描范围，排除无需自动配置的组件

// 极少单独使用，通常随 @SpringBootApplication 生效
@EnableAutoConfiguration
@Configuration
public class AutoConfigDemo {
    // 自动配置会根据依赖加载 Tomcat、MVC、数据源等组件
}

痛点	解决方案
不知道哪些自动配置生效/失效	在 application.yml 中添加 `debug: true`，启动日志会打印 `Positive matches`（生效）和 `Negative matches`（失效）
自动配置类加载过多导致启动慢	用 `@SpringBootApplication(exclude)` 排除无需的自动配置；或自定义 starter 缩小依赖范围

package com.example.demo.config;

import com.example.external.ExternalService;
import org.springframework.context.annotation.Import;
import org.springframework.stereotype.Configuration;

// 导入单个类
@Import(ExternalService.class)
// 导入多个类
// @Import({ExternalService.class, CustomConfig.class})
@Configuration
public class ImportConfig {
    // ExternalService 会被注册为 Bean，即使它不在扫描路径下
}

痛点	解决方案
导入的类无默认构造器导致初始化失败	确保导入类有无参构造器；或通过 `@Bean` 手动创建实例
导入过多类导致配置混乱	按功能分组导入，避免一次性导入大量类

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan;

// 显式指定扫描路径
@ComponentScan(basePackages = {
    "com.example.demo.controller",
    "com.example.demo.service",
    "com.example.external" // 跨模块扫描
})
@org.springframework.boot.autoconfigure.SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

痛点	解决方案
报错 `No qualifying bean of type 'XxxService' available`	1. 检查 XxxService 是否加 `@Service`；2. 检查 `basePackages` 是否包含该类所在包；3. 用 `basePackageClasses` 精准扫描（如 `basePackageClasses = UserService.class`）
扫描路径过大导致启动慢	缩小扫描范围，只扫描核心业务包，排除测试/工具包

package com.example.demo.config;

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

// 全量模式（默认）：保证 @Bean 方法单例
@Configuration
// 轻量模式：启动更快，适合无 @Bean 方法依赖
// @Configuration(proxyBeanMethods = false)
public class AppConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    // 全量模式下，多次调用返回同一个实例
    @Bean
    public String appName() {
        return "demo-app";
    }
}

痛点	解决方案
配置类中调用 @Bean 方法返回多实例	保持 `proxyBeanMethods = true`；或通过 `@Autowired` 注入 Bean 而非直接调用方法
配置类过多导致维护混乱	按功能拆分配置类（如 RedisConfig、DataSourceConfig），用 `@Import` 批量导入

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BeanConfig {
    // 基础用法：默认 Bean 名称=方法名
    @Bean
    public UserService userService() {
        return new UserService();
    }

    // 自定义 Bean 名称 + 初始化/销毁方法
    @Bean(name = "customDataSource", initMethod = "init", destroyMethod = "close")
    public DataSource dataSource() {
        return new CustomDataSource();
    }

    // 依赖其他 Bean（方法参数自动注入）
    @Bean
    public OrderService orderService(UserService userService) {
        return new OrderService(userService);
    }

    // 静态内部类模拟
    public static class CustomDataSource {
        public void init() {
            System.out.println("数据源初始化");
        }

        public void close() {
            System.out.println("数据源销毁");
        }
    }
}

痛点	解决方案
@Bean 方法依赖的 Bean 不存在	1. 检查依赖 Bean 是否注册；2. 用 `@ConditionalOnBean` 确保依赖存在；3. 捕获初始化异常
原型 Bean 注入到单例 Bean 中仅创建一次	用 `ObjectFactory<XxxBean>` 延迟获取；或手动调用 `ApplicationContext.getBean()`

package com.example.demo.component;

import org.springframework.stereotype.Component;

// 默认 Bean 名称：userComponent
@Component
// 自定义 Bean 名称
// @Component("myUserComponent")
public class UserComponent {
    public String getUserName(Long id) {
        return "用户" + id;
    }
}

痛点	解决方案
同一类型多个 @Component Bean 导致注入冲突	1. 用 `@Qualifier` 指定 Bean 名称；2. 用 `@Primary` 标记首选 Bean；3. 自定义 Bean 名称避免重复
工具类加 @Component 导致多实例	工具类建议设计为静态方法，无需注册为 Bean；若必须注册，确保 `@Scope("singleton")`（默认）

package com.example.demo.service;

import org.springframework.stereotype.Service;

// 默认 Bean 名称：userService
@Service
// 自定义 Bean 名称
// @Service("userBiz")
public class UserService {
    public String getUserInfo(Long id) {
        // 业务逻辑：查询用户信息
        return "用户 ID：" + id + "，名称：张三";
    }
}

痛点	解决方案
误将 @Service 标注在 Controller/Repository 上	严格按分层标注：Controller→@Controller，Repository→@Repository，Service→@Service
Service 层依赖注入失败	1. 检查是否加 `@Service`；2. 检查 `@ComponentScan` 是否包含该包；3. 检查依赖的 Bean 是否存在

package com.example.demo.repository;

import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    public String findById(Long id) {
        // 模拟 JDBC 查询，抛出 SQLException
        // throw new SQLException("查询失败");
        return "用户 ID：" + id;
    }
}

痛点	解决方案
异常转换功能失效	1. 确保类加 `@Repository`；2. 确保 Spring 上下文存在 `PersistenceExceptionTranslationPostProcessor`（Spring Boot 自动配置）；3. 异常必须是持久层异常（如 SQLException）
与 MyBatis 的 @Mapper 混用	MyBatis 的 `@Mapper` 已包含 Bean 注册和代理生成，无需再加 `@Repository`

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class PageController {
    // 返回视图（需配置视图解析器，如 Thymeleaf）
    @GetMapping("/user/page")
    public String userPage() {
        // 解析为：classpath:/templates/user.html
        return "user";
    }

    // 配合 @ResponseBody 返回 JSON
    @GetMapping("/user/info")
    @ResponseBody
    public String userInfo() {
        return "{\"id\":1,\"name\":\"张三\"}";
    }
}

痛点	解决方案
方法返回字符串被解析为视图路径而非 JSON	1. 方法加 `@ResponseBody`；2. 类上加 `@RestController` 替代 `@Controller`
报错 `No mapping for GET /xxx`	1. 检查 `@GetMapping` 路径是否正确；2. 检查 Controller 是否加 `@Controller`；3. 检查扫描路径

package com.example.demo.controller;

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

@RestController
public class RestApiController {
    // 自动返回 JSON，无需 @ResponseBody
    @GetMapping("/order/info")
    public OrderVO getOrderInfo() {
        OrderVO vo = new OrderVO();
        vo.setId(1L);
        vo.setOrderNo("20240310001");
        vo.setAmount(99.9);
        return vo; // Spring 自动转换为 JSON
    }

    // 静态内部类：订单 VO
    public static class OrderVO {
        private Long id;
        private String orderNo;
        private Double amount;
        // getter/setter 省略
    }
}

痛点	解决方案
返回的 JSON 字段名与实体类不一致	1. 用 `@JsonProperty("order_no")` 标注实体类字段；2. 配置 Jackson 自定义命名策略
返回值为 null 时字段丢失	在 application.yml 中配置：`spring.jackson.default-property-inclusion=ALWAYS`

package com.example.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    // 字段注入（简单但不推荐，不利于单元测试）
    @Autowired
    private UserService userService;

    // 构造器注入（推荐，强制依赖，便于单元测试）
    private final ProductService productService;

    @Autowired
    public OrderService(ProductService productService) {
        this.productService = productService;
    }

    // 方法注入（适合可选依赖）
    private PayService payService;

    @Autowired(required = false)
    public void setPayService(PayService payService) {
        this.payService = payService;
    }

    // 多 Bean 时配合 @Qualifier
    @Autowired
    @Qualifier("vipUserService")
    private UserService vipUserService;
}

痛点	解决方案
报错 `No qualifying bean of type 'XxxService' available`	1. 检查 XxxService 是否加 `@Service`；2. 检查扫描路径；3. 设置 `required = false`（可选依赖）
报错 `NoUniqueBeanDefinitionException`（同一类型多 Bean）	1. 用 `@Qualifier` 指定 Bean 名称；2. 用 `@Primary` 标记首选 Bean；3. 自定义 Bean 名称匹配字段名
构造器注入时循环依赖	1. 重构代码解耦；2. 用 `@Lazy` 延迟加载其中一个 Bean；3. 改用 setter 注入

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean("normalUserService")
    public UserService normalUserService() {
        return new NormalUserService();
    }

    @Bean("vipUserService")
    public UserService vipUserService() {
        return new VipUserService();
    }
}

// 注入时指定名称
package com.example.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    @Autowired
    @Qualifier("vipUserService") // 精准注入 vipUserService
    private UserService userService;
}

痛点	解决方案
@Qualifier 指定的名称不存在	1. 检查 Bean 名称是否正确（区分大小写）；2. 检查 `@Bean`/`@Service` 的名称配置
同时使用 @Primary 和 @Qualifier	`@Qualifier` 优先级更高，会忽略 `@Primary`，按名称注入

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration
public class DataSourceConfig {
    // 首选数据源（@Autowired 默认注入这个）
    @Primary
    @Bean("masterDataSource")
    public DataSource masterDataSource() {
        return new MasterDataSource();
    }

    @Bean("slaveDataSource")
    public DataSource slaveDataSource() {
        return new SlaveDataSource();
    }
}

// 注入时自动选择 masterDataSource
package com.example.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DataService {
    @Autowired
    private DataSource dataSource; // 注入的是 masterDataSource
}

痛点	解决方案
同一类型多个 @Primary Bean	报错 `IllegalStateException`，确保同一类型只有一个 `@Primary` Bean
@Primary 不生效	检查是否同时使用了 `@Qualifier`（优先级更高）；检查 Bean 是否注册成功

package com.example.demo.service;

import jakarta.annotation.Resource; // Spring Boot 3+ 用 jakarta
import org.springframework.stereotype.Service;

@Service
public class CartService {
    // 默认按名称装配（字段名 cartRepository）
    @Resource
    private CartRepository cartRepository;

    // 指定 name 属性（精准按名称装配）
    @Resource(name = "vipCartRepository")
    private CartRepository vipCartRepository;

    // 指定 type 属性（按类型装配，等同于 @Autowired）
    @Resource(type = OrderRepository.class)
    private OrderRepository orderRepository;
}

痛点	解决方案
Spring Boot 3+ 中找不到 @Resource	替换为 `jakarta.annotation.Resource`；确保引入 `spring-boot-starter-web`（包含 jakarta 依赖）
按名称找不到，按类型找到多个	1. 指定 `name` 属性精准匹配；2. 避免同一类型多个 Bean 未命名

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@Configuration
public class ScopeConfig {
    // 单例（默认）：全局唯一，启动时创建
    @Bean
    @Scope("singleton")
    public SingletonBean singletonBean() {
        return new SingletonBean();
    }

    // 原型：每次 getBean() 创建新实例
    @Bean
    @Scope("prototype")
    public PrototypeBean prototypeBean() {
        return new PrototypeBean();
    }

    // Web 作用域：每个 HTTP 请求一个实例（需 Web 环境）
    @Bean
    @Scope("request")
    public RequestBean requestBean() {
        return new RequestBean();
    }

    // 静态内部类
    public static class SingletonBean {}
    public static class PrototypeBean {}
    public static class RequestBean {}
}

痛点	解决方案
原型 Bean 注入到单例 Bean 中仅创建一次	1. 用 `ObjectFactory<PrototypeBean>` 延迟获取；2. 用 `@Lookup` 注解；3. 手动调用 `ApplicationContext.getBean()`
request/session 作用域在非 Web 环境报错	1. 仅在 Web 环境使用；2. 配置 `@ConditionalOnWebApplication` 确保仅 Web 环境加载

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

@Configuration
public class LazyConfig {
    // 延迟创建：第一次使用时才实例化
    @Bean
    @Lazy
    public LazyBean lazyBean() {
        System.out.println("LazyBean 创建");
        return new LazyBean();
    }

    // 立即创建（默认）：启动时实例化
    @Bean
    public EagerBean eagerBean() {
        System.out.println("EagerBean 创建");
        return new EagerBean();
    }

    public static class LazyBean {}
    public static class EagerBean {}
}

痛点	解决方案
@Lazy 标注后 Bean 仍启动时创建	1. 检查是否是单例 Bean；2. 检查是否有其他 Bean 提前注入该 Bean；3. 检查是否调用了 `ApplicationContext.getBean()`
循环依赖问题未解决	确保两个 Bean 都加 `@Lazy`；或重构代码解耦

package com.example.demo.service;

import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class CacheService {
    @Autowired
    private StringRedisTemplate redisTemplate;

    // 构造器中无法使用 redisTemplate（未注入）
    public CacheService() {
        // System.out.println(redisTemplate); // 报错：NullPointerException
    }

    // 初始化完成后执行：加载数据到缓存
    @PostConstruct
    public void initCache() {
        System.out.println("初始化缓存...");
        redisTemplate.opsForValue().set("init_key", "init_value");
    }
}

痛点	解决方案
@PostConstruct 方法抛出异常	Bean 初始化失败，容器启动报错；1. 捕获异常并处理；2. 确保初始化逻辑稳定
多个 @PostConstruct 方法执行顺序不确定	1. 合并为一个方法；2. 重构代码逻辑，避免多个初始化方法

package com.example.demo.service;

import jakarta.annotation.PreDestroy;
import org.springframework.stereotype.Service;

@Service
public class ResourceService {
    private Connection connection;

    // 初始化连接
    @PostConstruct
    public void initConnection() {
        System.out.println("创建数据库连接...");
        connection = new Connection();
    }

    // 销毁前释放连接
    @PreDestroy
    public void closeConnection() {
        System.out.println("关闭数据库连接...");
        if (connection != null) {
            // connection.close(); // 释放资源
        }
    }

    // 模拟连接类
    private static class Connection {}
}

痛点	解决方案
@PreDestroy 方法未执行	1. 确保是单例 Bean；2. 确保容器正常关闭（如调用 `ApplicationContext.close()`）；3. 检查是否有异常导致方法未执行
资源释放失败	1. 捕获异常并记录日志；2. 确保资源释放逻辑幂等

package com.example.demo.component;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ConfigComponent {
    // 基础用法：注入配置文件中的值
    @Value("${app.name}")
    private String appName;

    // 注入默认值（配置不存在时使用）
    @Value("${app.version:1.0.0}")
    private String appVersion;

    // SpEL 表达式：引用其他 Bean 的属性
    @Value("#{@appConfig.appName + '-test'}")
    private String testAppName;

    public void printConfig() {
        System.out.println("appName: " + appName);
        System.out.println("appVersion: " + appVersion);
    }
}

app:
  name: demo-app

痛点	解决方案
报错 `Could not resolve placeholder 'xxx' in value "${xxx}"`	1. 检查配置文件中是否存在该 key；2. 设置默认值（如`${xxx:default}`）；3. 检查配置文件是否加载
注入静态变量失败	1. 不能直接标注静态变量；2. 提供非静态 setter 方法，标注 `@Value` 并赋值给静态变量

package com.example.demo.config;

import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotEmpty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.validation.annotation.Validated;
import java.util.List;
import java.util.Map;

@ConfigurationProperties(prefix = "app")
@Validated // 启用数据校验
public class AppProperties {
    @NotEmpty(message = "应用名称不能为空")
    private String name;

    private Upload upload;
    private List<String> allowedIps;
    private Map<String, String> envConfig;

    // 嵌套配置
    public static class Upload {
        @Min(value = 1, message = "最小文件大小不能小于 1MB")
        @Max(value = 100, message = "最大文件大小不能超过 100MB")
        private Integer maxSize;

        @NotEmpty(message = "上传路径不能为空")
        private String path;

        // getter/setter 省略
    }

    // getter/setter 省略
}

app:
  name: demo-app
  upload:
    max-size: 50
    path: /usr/local/upload
  allowed-ips:
    - 127.0.0.1
    - 192.168.1.1
  env-config:
    dev: development
    prod: production

@Configuration
@EnableConfigurationProperties(AppProperties.class)
public class ConfigRegister {}

痛点	解决方案
绑定失败（字段为 null）	1. 检查 prefix 是否正确；2. 检查字段名是否支持松散绑定；3. 确保有 setter 方法；4. 加 `@EnableConfigurationProperties`
数据校验不生效	1. 加 `@Validated` 注解；2. 引入 `spring-boot-starter-validation` 依赖；3. 检查校验注解是否正确（jakarta.validation.constraints）

package com.example.demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

// 加载自定义配置文件，指定编码
@PropertySource(value = "classpath:custom.properties", encoding = "UTF-8")
@Configuration
public class CustomConfig {}

custom.name=自定义配置
custom.age=20

痛点	解决方案
加载 YAML 文件失败	1. `@PropertySource` 默认不支持 YAML；2. 自定义 YAML 加载器（实现 `PropertySourceFactory`）；3. 改用 application.yml 的多环境配置
配置文件找不到	1. 检查文件路径（classpath:/xxx.properties）；2. 确保文件在 resources 目录下

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
public class EnvConfig {
    // 开发环境数据源
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        System.out.println("加载开发环境数据源");
        return new DevDataSource();
    }

    // 生产环境数据源
    @Bean
    @Profile({"prod", "default"})
    public DataSource prodDataSource() {
        System.out.println("加载生产环境数据源");
        return new ProdDataSource();
    }

    // 静态内部类
    public static class DevDataSource {}
    public static class ProdDataSource {}
}

spring:
  profiles:
    active: dev # 激活开发环境

痛点	解决方案
无匹配的 Profile 时 Bean 加载失败	1. 指定默认 Profile（如 `@Profile("default")`）；2. 确保 `spring.profiles.active` 配置正确
多 Profile 激活时 Bean 冲突	1. 确保不同 Profile 的 Bean 名称不同；2. 避免同时激活冲突的 Profile

package com.example.demo.controller;

import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Validated // 开启 Controller 参数校验
public class ValidateController {
    @PostMapping("/user/save")
    public String saveUser(@RequestBody @Validated UserVO user) {
        return "保存用户：" + user.getName();
    }

    // 分组校验
    @PostMapping("/user/update")
    public String updateUser(@RequestBody @Validated(UpdateGroup.class) UserVO user) {
        return "更新用户：" + user.getId();
    }

    // 分组接口
    public interface UpdateGroup {}

    // 用户 VO
    public static class UserVO {
        @NotNull(groups = UpdateGroup.class, message = "用户 ID 不能为空")
        private Long id;

        @NotEmpty(message = "用户名不能为空")
        private String name;

        // getter/setter 省略
    }
}

痛点	解决方案
校验不生效	1. 加 `@Validated` 注解；2. 引入 `spring-boot-starter-validation` 依赖；3. 确保参数前加 `@Validated`/`@Valid`
分组校验不生效	1. 确保分组接口正确；2. 校验注解指定分组；3. 参数前指定分组（如 `@Validated(UpdateGroup.class)`）

package com.example.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user") // 类级别路径
public class UserController {
    // 匹配 GET 请求
    @RequestMapping(value = "/info", method = RequestMethod.GET)
    public String getUserInfo() {
        return "用户信息";
    }

    // 多路径映射
    @RequestMapping(value = {"/save", "/create"}, method = RequestMethod.POST)
    public String saveUser() {
        return "保存用户";
    }
}

痛点	解决方案
请求路径冲突	1. 区分请求方法（GET/POST）；2. 增加请求头/参数条件；3. 调整路径命名
Ant 风格路径匹配错误	1. 明确规则（匹配一级，*匹配多级）；2. 避免过度使用通配符

package com.example.demo.controller;

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

@RestController
@RequestMapping("/order")
public class OrderController {
    // 查询（GET）
    @GetMapping("/{id}")
    public String getOrder(@PathVariable Long id) {
        return "查询订单：" + id;
    }

    // 新增（POST）
    @PostMapping
    public String createOrder(@RequestBody OrderVO order) {
        return "创建订单：" + order.getOrderNo();
    }

    // 全量更新（PUT）
    @PutMapping("/{id}")
    public String updateOrder(@PathVariable Long id, @RequestBody OrderVO order) {
        return "更新订单：" + id;
    }

    // 删除（DELETE）
    @DeleteMapping("/{id}")
    public String deleteOrder(@PathVariable Long id) {
        return "删除订单：" + id;
    }

    // 部分更新（PATCH）
    @PatchMapping("/{id}/status")
    public String updateOrderStatus(@PathVariable Long id, @RequestParam Integer status) {
        return "更新订单" + id + "状态为：" + status;
    }

    public static class OrderVO {
        private String orderNo;
        // getter/setter 省略
    }
}

痛点	解决方案
PUT/PATCH/DELETE 请求被拦截	1. 配置跨域（`@CrossOrigin`）；2. 配置 Spring Security 允许这些方法；3. 前端用 X-HTTP-Method-Override 模拟
PATCH 请求接收参数复杂	1. 用 `@RequestBody` 接收 JSON；2. 避免传递过多参数

package com.example.demo.controller;

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

@RestController
@RequestMapping("/product")
public class ProductController {
    // 基础用法：参数名与路径变量名一致
    @GetMapping("/info/{id}")
    public String getProductInfo(@PathVariable Long id) {
        return "商品 ID：" + id;
    }

    // 参数名与路径变量名不一致
    @GetMapping("/name/{productName}")
    public String getProductName(@PathVariable("productName") String name) {
        return "商品名称：" + name;
    }

    // 可选路径变量（Spring 5.3+）
    @GetMapping("/optional/{id:\d+}?")
    public String getOptionalProduct(@PathVariable(required = false) Long id) {
        return id == null ? "无商品 ID" : "商品 ID：" + id;
    }
}

痛点	解决方案
类型转换失败（如 String→Long）	1. 确保路径变量格式正确；2. 用正则限制格式（如 `{id:\d+}`）；3. 全局异常处理转换异常
可选路径变量不生效	1. 确保 Spring 版本≥5.3；2. 路径模板后加？（如`/{id}?`）；3. 设置 `required = false`

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

@RestController
@RequestMapping("/search")
public class SearchController {
    // 必填参数
    @GetMapping("/user")
    public String searchUser(@RequestParam String name) {
        return "搜索用户：" + name;
    }

    // 可选参数 + 默认值
    @GetMapping("/product")
    public String searchProduct(
        @RequestParam(required = false, defaultValue = "手机") String keyword,
        @RequestParam(defaultValue = "1") Integer pageNum
    ) {
        return "关键词：" + keyword + "，页码：" + pageNum;
    }

    // 多值参数
    @GetMapping("/batch")
    public String searchBatch(@RequestParam List<Long> ids) {
        return "批量搜索 ID：" + ids;
    }
}

痛点	解决方案
必选参数缺失	1. 设置 `required = false`；2. 提供默认值；3. 全局异常处理返回友好提示
多值参数接收不到	1. 前端传递多个相同参数名（如 `ids=1&ids=2`）；2. 用逗号分隔字符串，后端拆分

package com.example.demo.controller;

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

@RestController
@RequestMapping("/api")
public class JsonController {
    // 接收单个对象
    @PostMapping("/user")
    public String receiveUser(@RequestBody UserVO user) {
        return "接收用户：" + user.getName();
    }

    // 接收数组
    @PostMapping("/users")
    public String receiveUsers(@RequestBody List<UserVO> users) {
        return "接收" + users.size() + "个用户";
    }

    public static class UserVO {
        private String name;
        private Integer age;
        // getter/setter 省略
    }
}

痛点	解决方案
接收不到 JSON 数据	1. 检查 Content-Type 是否为 application/json；2. 检查 JSON 格式；3. 检查实体类有 setter 方法；4. 用 `@JsonProperty` 匹配字段名
日期类型转换失败	1. 配置 Jackson 日期格式；2. 实体类字段加 `@JsonFormat(pattern = "yyyy-MM-dd")`

package com.example.demo.controller;

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

@RestController
@RequestMapping("/header")
public class HeaderController {
    // 获取请求头
    @GetMapping("/user-agent")
    public String getUserAgent(@RequestHeader("User-Agent") String userAgent) {
        return "User-Agent：" + userAgent;
    }

    // 获取 Cookie
    @GetMapping("/cookie")
    public String getCookie(@CookieValue(value = "JSESSIONID", required = false) String sessionId) {
        return "JSESSIONID：" + sessionId;
    }

    // @ModelAttribute 预处理数据
    @ModelAttribute
    public void preProcess(@RequestParam(required = false) String token, Model model) {
        model.addAttribute("token", token == null ? "default-token" : token);
    }

    // 使用预处理数据
    @GetMapping("/model")
    public String getModel(Model model) {
        return "Token：" + model.getAttribute("token");
    }
}

package com.example.demo.controller;

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

// 类级别：允许所有域名跨域
@CrossOrigin(origins = "*", maxAge = 3600)
@RestController
@RequestMapping("/cors")
public class CorsController {
    // 方法级别：仅允许指定域名
    @CrossOrigin(origins = "http://localhost:8080")
    @GetMapping("/info")
    public String getInfo() {
        return "跨域访问成功";
    }
}

痛点	解决方案
跨域仍报错	1. 检查 origins 是否配置正确；2. 确保 maxAge 设置合理；3. 全局配置跨域（替代注解）

package com.example.demo.advice;

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

// 全局异常处理，返回 JSON
@RestControllerAdvice
public class GlobalExceptionHandler {
    // 处理参数校验异常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, String>> handleValidException(MethodArgumentNotValidException e) {
        Map<String, String> errors = new HashMap<>();
        e.getBindingResult().getFieldErrors().forEach(error -> {
            errors.put(error.getField(), error.getDefaultMessage());
        });
        return new ResponseEntity<>(errors, HttpStatus.BAD_REQUEST);
    }

    // 处理通用异常
    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception e) {
        return new ResponseEntity<>("服务器内部错误：" + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

痛点	解决方案
全局异常处理不生效	1. 检查是否加 `@RestControllerAdvice`/`@ControllerAdvice`；2. 检查异常类型是否匹配；3. 检查扫描路径是否包含该类
特定 Controller 不适用全局处理	1. 在 Controller 内定义 `@ExceptionHandler`（优先级更高）；2. 用 `@RestControllerAdvice(basePackages = "com.example.demo.controller")` 限定范围

package com.example.demo.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect // 标记切面类
@Component
public class PerformanceAspect {
    // 定义切点：所有 Controller 的方法
    @Pointcut("@within(org.springframework.web.bind.annotation.RestController)")
    public void controllerPointcut() {}

    // 环绕通知：监控方法执行时间
    @Around("controllerPointcut()")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        // 执行目标方法
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        // 打印耗时
        System.out.println(joinPoint.getSignature() + " 执行耗时：" + (end - start) + "ms");
        return result;
    }
}

痛点	解决方案
切面不生效	1. 检查是否加 `@Aspect` 和 `@Component`；2. 检查切点表达式是否正确；3. 确保目标方法是 public（AOP 不支持 private）
内部调用切面不生效	1. 通过代理对象调用方法；2. 启用 `@EnableAspectJAutoProxy(exposeProxy = true)`，用 `AopContext.currentProxy()` 获取代理

package com.example.demo.service;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {
    // 类级别：所有方法都开启事务
    // @Transactional
    private final OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    // 方法级别：覆盖类级别配置
    @Transactional(
        rollbackFor = Exception.class, // 所有异常都回滚（默认仅 RuntimeException）
        propagation = Propagation.REQUIRED, // 默认传播行为
        isolation = Isolation.READ_COMMITTED // 隔离级别
    )
    public void createOrder(OrderVO order) {
        // 业务逻辑：新增订单 + 更新库存
        orderRepository.save(order);
        // 模拟异常：触发回滚
        // throw new RuntimeException("创建订单失败");
    }
}

痛点	解决方案
事务失效	1. 方法非 public（AOP 不支持）；2. 同类内部调用（未走代理）；3. 异常被捕获未抛出；4. 异常类型不匹配（默认仅 RuntimeException）；5. 数据库引擎不支持事务（如 MyISAM）
事务回滚不全	1. 指定 `rollbackFor = Exception.class`；2. 确保所有操作在同一个事务中；3. 检查是否有非事务操作（如调用外部接口）

package com.example.demo.entity;

import jakarta.persistence.*;
import java.util.Date;

@Entity // 标记为 JPA 实体
@Table(name = "t_user") // 映射数据库表名
public class User {
    @Id // 主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增策略
    private Long id;

    @Column(name = "user_name", length = 50, nullable = false) // 字段映射
    private String userName;

    @Temporal(TemporalType.DATE) // 日期精度
    private Date createTime;

    @Transient // 不映射到数据库
    private String tempField;

    // getter/setter 省略
}

痛点	解决方案
实体映射失败	1. 检查注解是否正确（jakarta.persistence 而非 javax）；2. 检查表名/字段名是否匹配；3. 确保有无参构造器
主键生成策略失效	1. 检查数据库是否支持自增（如 MySQL 支持 IDENTITY，Oracle 支持 SEQUENCE）；2. 确保主键字段类型匹配

package com.example.demo.mapper;

import org.apache.ibatis.annotations.*;
import java.util.List;

@Mapper // 标记为 MyBatis Mapper 接口
public interface UserMapper {
    // 查询
    @Select("SELECT * FROM t_user WHERE id = #{id}")
    User findById(Long id);

    // 新增：获取自增主键
    @Insert("INSERT INTO t_user(user_name) VALUES (#{userName})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    int insert(User user);

    // 更新
    @Update("UPDATE t_user SET user_name = #{userName} WHERE id = #{id}")
    int update(User user);

    // 删除
    @Delete("DELETE FROM t_user WHERE id = #{id}")
    int delete(Long id);

    // 多参数：用 @Param 指定名称
    @Select("SELECT * FROM t_user WHERE user_name = #{name} AND age = #{age}")
    List<User> findByCondition(@Param("name") String name, @Param("age") Integer age);
}

@SpringBootApplication
@MapperScan("com.example.demo.mapper") // 扫描所有 Mapper 接口
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

痛点	解决方案
Mapper 注入失败	1. 检查是否加 `@Mapper` 或 `@MapperScan`；2. 检查扫描路径是否正确；3. 确保 Mapper 是接口（非类）
多参数绑定失败	1. 用 `@Param` 指定参数名称；2. 用 Map 传递参数；3. 用实体类封装参数

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;

@Configuration
@EnableAsync // 开启异步支持
public class AsyncConfig {
    // 自定义线程池（避免使用默认的 SimpleAsyncTaskExecutor）
    @Bean("asyncExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); // 核心线程数
        executor.setMaxPoolSize(10); // 最大线程数
        executor.setQueueCapacity(20); // 队列容量
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }
}

// 异步方法
package com.example.demo.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {
    // 使用自定义线程池
    @Async("asyncExecutor")
    public void asyncTask() {
        // 耗时操作：如发送邮件、生成报表
        System.out.println("异步任务执行中，线程：" + Thread.currentThread().getName());
    }
}

痛点	解决方案
异步方法失效	1. 未加 `@EnableAsync`；2. 同类内部调用（未走代理）；3. 方法非 public；4. 返回值为 void 时异常无法捕获
线程池耗尽	1. 自定义线程池，设置合理参数；2. 监控线程池状态；3. 避免提交大量异步任务

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import java.util.concurrent.ScheduledExecutorService;

@Configuration
@EnableScheduling // 开启定时任务
public class SchedulerConfig {
    // 自定义定时任务线程池（避免单线程阻塞）
    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(5);
        scheduler.setThreadNamePrefix("scheduler-");
        return scheduler;
    }
}

// 定时任务
package com.example.demo.service;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class ScheduledService {
    // cron 表达式：每分钟执行一次
    @Scheduled(cron = "0 * * * * ?")
    public void cronTask() {
        System.out.println("Cron 任务执行：" + System.currentTimeMillis());
    }

    // 固定频率：每隔 5 秒执行（以上次开始时间计算）
    @Scheduled(fixedRate = 5000)
    public void fixedRateTask() {
        System.out.println("固定频率任务执行");
    }

    // 固定延迟：每隔 5 秒执行（以上次结束时间计算）
    @Scheduled(fixedDelay = 5000)
    public void fixedDelayTask() {
        System.out.println("固定延迟任务执行");
    }
}

痛点	解决方案
定时任务阻塞	1. 自定义线程池（ThreadPoolTaskScheduler）；2. 避免任务执行时间过长；3. 异步执行耗时任务
cron 表达式错误	1. 在线工具验证 cron 表达式；2. 注意秒/分/时/日/月/周的顺序；3. 避免日和周同时指定

package com.example.demo.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class RabbitMQListener {
    // 监听指定队列
    @RabbitListener(queues = "demo.queue")
    public void receiveMessage(String message) {
        System.out.println("接收 RabbitMQ 消息：" + message);
    }
}

package com.example.demo.config;

import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ConditionConfig {
    // 类路径下存在 RedisTemplate 时生效
    @ConditionalOnClass(name = "org.springframework.data.redis.core.RedisTemplate")
    @Bean
    public RedisService redisService() {
        return new RedisService();
    }

    // 容器中不存在 MyService 时才创建
    @ConditionalOnMissingBean(MyService.class)
    @Bean
    public MyService defaultMyService() {
        return new DefaultMyService();
    }

    // 配置文件中 my.feature.enabled=true 时生效
    @ConditionalOnProperty(name = "my.feature.enabled", havingValue = "true")
    @Bean
    public FeatureService featureService() {
        return new FeatureService();
    }

    // 静态内部类
    public static class RedisService {}
    public static class MyService {}
    public static class DefaultMyService extends MyService {}
    public static class FeatureService {}
}

痛点	解决方案
条件装配不生效	1. 检查条件是否满足（如类是否存在、配置是否正确）；2. 启动日志添加 `debug: true` 查看条件匹配结果；3. 确保条件注解标注在 @Bean 方法/配置类上

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity // 开启 Web 安全
@EnableGlobalMethodSecurity(prePostEnabled = true) // 开启 @PreAuthorize
public class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll() // 公开接口
                .anyRequest().authenticated() // 其他接口需认证
        ).formLogin(); // 启用表单登录
        return http.build();
    }
}

// 方法级权限
package com.example.demo.controller;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/admin")
public class AdminController {
    // 仅 ADMIN 角色可访问
    @PreAuthorize("hasRole('ADMIN')")
    @GetMapping("/info")
    public String adminInfo() {
        return "管理员信息";
    }

    // 支持 SpEL 表达式，更复杂的权限校验
    @PreAuthorize("authentication.name == #username")
    @GetMapping("/user/{username}")
    public String userInfo(@PathVariable String username) {
        return "用户信息：" + username;
    }
}

@RestController
@RequestMapping("/user")
public class UserController {
    // 必须有 ADMIN 角色才能访问
    @PreAuthorize("hasRole('ADMIN')")
    @GetMapping("/list")
    public List<User> list() {
        return userService.list();
    }

    // 只能查看自己的信息：登录用户名 == 路径参数 username
    @PreAuthorize("authentication.name == #username")
    @GetMapping("/info/{username}")
    public User info(@PathVariable String username) {
        return userService.getByUsername(username);
    }

    // 拥有某个权限
    @PreAuthorize("hasAuthority('user:delete')")
    @DeleteMapping("/{id}")
    public void delete(@PathVariable Long id) {
        userService.delete(id);
    }
}

@Service
public class OrderService {
    // 返回订单的用户名 == 当前登录用户才允许返回
    @PostAuthorize("returnObject.username == authentication.name")
    public Order getOrder(Long orderId) {
        return orderMapper.selectById(orderId);
    }
}

@GetMapping("/me")
public R currentUser(@AuthenticationPrincipal UserDetails userDetails) {
    return R.ok(userDetails.getUsername());
}

// 如果你自定义了 LoginUser 实现 UserDetails，可以直接写
@GetMapping("/me")
public R me(@AuthenticationPrincipal LoginUser loginUser) {
    return R.ok(loginUser.getUser());
}

@Secured("ROLE_ADMIN")
@GetMapping("/admin")
public String admin() {
    return "admin page";
}

@RolesAllowed("ADMIN")
@GetMapping("/manage")
public String manage() {
    return "manage";
}

@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testList() {
        List<User> list = userService.list();
        Assert.notNull(list, "列表不能为空");
    }
}

@WebMvcTest(UserController.class)
public class UserControllerTest {
    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    public void testInfo() throws Exception {
        // 模拟 Service 返回
        User user = new User();
        user.setId(1L);
        user.setUsername("test");
        Mockito.when(userService.getById(1L)).thenReturn(user);

        // 模拟请求
        mockMvc.perform(MockMvcRequestBuilders.get("/user/1"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.jsonPath("username").value("test"));
    }
}

@DataJpaTest
public class UserRepositoryTest {
    @Autowired
    private UserRepository userRepository;

    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("test");
        User saved = userRepository.save(user);
        Assert.notNull(saved.getId(), "保存后 ID 不能为空");
    }
}

@SpringBootTest
public class OrderServiceTest {
    @Autowired
    private OrderService orderService;

    @MockBean
    private UserService userService; // 用模拟对象替换

    @Test
    public void testCreate() {
        // 模拟 userService 返回
        Mockito.when(userService.getById(1L)).thenReturn(newUser());
        orderService.create(1L);
    }
}

@SpyBean
private UserService userService;

@Test
public void testSpy() {
    // 只模拟 getById，其他方法真实走业务
    Mockito.when(userService.getById(1L)).thenReturn(newUser());
}

@SpringBootTest
// 执行测试前跑脚本
@Sql(scripts = "classpath:init-test-data.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
public class SqlTest {
    @Test
    public void testQuery() {
        // 数据库已有初始化数据
    }
}

@SpringBootTest
@TestPropertySource("classpath:application-test.yml")
public class ConfigTest {}

@Service
@Slf4j
public class UserService {
    public void list() {
        log.info("查询用户列表");
    }
}

// 查询：缓存不存在则执行方法，结果存入缓存
@Cacheable(value = "user", key = "#id")
public User getById(Long id) {
    return userMapper.selectById(id);
}

// 更新：更新数据库，并更新缓存
@CachePut(value = "user", key = "#user.id")
public User update(User user) {
    userMapper.updateById(user);
    return user;
}

// 删除：删除缓存
@CacheEvict(value = "user", key = "#id")
public void delete(Long id) {
    userMapper.deleteById(id);
}

@Tag(name = "用户管理")
@RestController
@RequestMapping("/user")
public class UserController {
    @Operation(summary = "获取用户详情")
    @Parameter(name = "id", description = "用户 ID")
    @GetMapping("/{id}")
    public User getById(@PathVariable Long id) {
        return userService.getById(id);
    }
}

Spring Boot 核心注解完全手册

Spring Boot 核心注解完全手册（逻辑版·痛点 + 原理 + 实战）

一、启动与自动配置（应用入口级）

1. @SpringBootApplication

核心功能

底层原理

实际示例

使用痛点 & 解决方案

2. @EnableAutoConfiguration

核心功能

底层原理

实际示例

使用痛点 & 解决方案

3. @Import

核心功能

底层原理

实际示例

使用痛点 & 解决方案

4. @ComponentScan

核心功能

底层原理

实际示例

使用痛点 & 解决方案

二、IoC 容器与 Bean 定义（组件注册级）

1. @Configuration

核心功能

底层原理

实际示例

使用痛点 & 解决方案

2. @Bean

核心功能

底层原理

实际示例

使用痛点 & 解决方案

3. @Component

核心功能

底层原理

实际示例

使用痛点 & 解决方案

4. @Service

核心功能

底层原理

实际示例

使用痛点 & 解决方案

5. @Repository

核心功能

底层原理

实际示例

使用痛点 & 解决方案

6. @Controller

核心功能

底层原理

实际示例

使用痛点 & 解决方案

7. @RestController

核心功能

底层原理

实际示例

使用痛点 & 解决方案

三、依赖注入与 Bean 控制（生命周期/作用域）

1. @Autowired

核心功能

底层原理

实际示例

使用痛点 & 解决方案

2. @Qualifier

核心功能

底层原理

实际示例

使用痛点 & 解决方案

3. @Primary

核心功能

底层原理

实际示例

使用痛点 & 解决方案

4. @Resource

核心功能

底层原理

实际示例

使用痛点 & 解决方案