Spring依赖注入Bean流程深入解析

更新时间：2026年01月15日 09:11:37 作者：未来龙皇小蓝

本文主要介绍了Spring框架中依赖注入和Bean创建流程,包括注入方式、生命周期、代理模式、注入流程、构造函数参数处理以及创建Bean的详细过程,感兴趣的朋友跟随小编一起看看吧

1-注入方式

常见的方式：

一个类注入另一个类，其实本质都是使用的构造函数，这里以@RequiredArgsConstructor举例，常见的也有@AllArgsConstructor本质相差无几

@Configuration
@RequiredArgsConstructor
public class SecurityConfig {
    private final UserService userService;
}

@RequiredArgsConstructor：会为所有 final 修饰的字段生成构造函数参数

//等价于
@Configuration
public class SecurityConfig {
    private final UserService userService;
    public SecurityConfig(UserService userService) {
        this.userService = userService;
    }
}

优点：

使用 final 关键字确保依赖不会被意外修改
利用Lombok：减少重复代码，提高开发效率

推荐使用 @RequiredArgsConstructor + final 字段

不建议使用：@Autowired、@Resource等方式

2-生命周期

在singleton下:

SecurityConfig Bean 生命周期 == UserService Bean 生命周期

创建时注入
容器不销毁 → 引用一直有效
不会被替换
不会重新注入

运行时等价于：

// 在存在 AOP（如 @Transactional）时，为代理对象
private final UserService userService = UserService$$Proxy@7a3f21;

3-代理模式

3-1.没有代理

正常写业务

public interface UserService {
    void save();
}
public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("保存用户");
    }
}

调用方：

UserService userService = new UserServiceImpl();
userService.save();

3-2.简单代理

public class UserServiceProxy implements UserService {
    private final UserService target;
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    @Override
    public void save() {
        System.out.println("开启事务");
        try {
            target.save();
            System.out.println("提交事务");
        } catch (Exception e) {
            System.out.println("回滚事务");
            throw e;
        }
    }
}

使用：

UserService userService = new UserServiceProxy(new UserServiceImpl());
userService.save();

用一个“长得一样”的对象，包住真正对象，在调用前后加逻辑

有点像包装类，但是本质不同：

为了给这个对象多加点功能（如加密、压缩、缓存结果），那是包装，能访问到本体，且自己亲自放进包装类中
为了控制权限、延迟加载、单例保证，那是代理，且访问不到本体
包装：我帮你多做点事；代理：你只能通过我做这件事

3-3.Spring的代理

Spring的代理 = 自动生成的代理类，Spring只是帮你自动干了这件事

UserService proxy =
    (UserService) Proxy.newProxyInstance(
        loader,
        new Class[]{UserService.class},
        (obj, method, args) -> {
            System.out.println("开启事务");
            Object result = method.invoke(target, args);
            System.out.println("提交事务");
            return result;
        }
    );

4-注入流程

4-1.概念

【启动期】
1. 扫描 BeanDefinition
2. 创建原始对象
3. BeanPostProcessor 判断是否命中 Advisor(如@Transactional相关注解)
4. 命中 → 用代理对象替代原始对象
5. 代理 / 原始对象作为最终 Bean 放入 IOC（singleton）
【运行期】
6. 所有依赖注入，拿到的都是这个最终 Bean
7. 所有 AOP 能力，只存在于代理对象上

只有涉及到增强行为才会创建代理类，比如你在方法上包裹@Transactional，或者你自定义的@Aspect，以及@Async / @Cacheable等等

4-2.示例

@Configuration
public class SecurityConfig {
    private final UserService userService;// Bean 实例（通常是代理对象）的引用，并且在该 Bean 生命周期内长期存在
    public SecurityConfig(UserService userService) {
        this.userService = userService;
    }
    public void test(User user){
        userService.saveData(user);
    }
}
@Service
@RequiredArgsConstructor
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    private final UserMapper userMapper;
    @Transactional
    public void saveData(User user){
        userMapper.save(user);
    }
}

这样的代码：

Spring会首先在IOC容器中，按类型（by type）解析依赖，找到所有符合UserService的Bean，选出一个（或一组），注入（如果存在多个实现，会用@Primary或@Qualifier，否则直接报错）
这里因为UserServiceImpl内部挂上了@Transactional注解，所以创建了UserServiceImpl的实例后，就创建一个代理的Bean，即Proxy(UserServiceImpl)，后续的注入都将使用代理的Bean

具体如下：

1. 解析 BeanDefinition(UserServiceImpl)
2. new UserServiceImpl()               ← 原始对象
3. BeanPostProcessor 检查 @Transactional
4. 命中事务切点
5. 创建代理对象 Proxy(UserServiceImpl)
6. 将代理对象注册为 UserServiceImpl 的最终 Bean 实例

5-构造函数的参数

是Spring在创建Bean时会调用其构造函数，然后根据构造函数的参数，会进行注入：

@Component
@Slf4j
public class PushDataStrategyManager {
    private final Map<Integer, PushDataStrategy> strategyMap = new HashMap<>();
	// 这里构造函数的参数是List<PushDataStrategy> strategies，Spring会找出所有相关的Bean放进来
    public PushDataStrategyManager(List<PushDataStrategy> strategies) {
        // 自动注册所有策略实现
        for (PushDataStrategy strategy : strategies) {
            strategyMap.put(strategy.getType(), strategy);
            log.info("注册推送策略: type={}, class={}", strategy.getType(), strategy.getClass().getSimpleName());
        }
    }
}

常见的Spring支持的构造函数如下，Spring会自动的进行操作：

构造参数	Spring的行为
`PushDataStrategy`	按类型查找Bean；必须唯一，否则报错
`List<PushDataStrategy>`	查找容器中所有PushDataStrategy类型的Bean，按顺序注入
`Set<PushDataStrategy>`	同上，不保证顺序
`Map<String, PushDataStrategy>`	key = BeanName，value = Bean 实例

具体流程：

当 Spring 创建 PushDataStrategyManager 时：

解析构造函数参数

public PushDataStrategyManager(List<PushDataStrategy> strategies)
// Spring通过反射拿到泛型信息
// 参数类型：List
// 泛型参数：PushDataStrategy

发现这是一个集合类型依赖

isCollectionType(parameterType)// 是 List

解析集合的泛型元素类型

ResolvableType.forConstructorParameter(...)
// 得到
elementType = PushDataStrategy.class

去IOC容器中查找所有候选Bean

// 等价于
applicationContext.getBeansOfType(PushDataStrategy.class)

只要同时满足下方条件就收集：

是 Bean（@Component / @Service / @Bean）
类型是 PushDataStrategy 或其子类
没被 @Conditional 排除
没被 @Profile 排除

排序（如果有顺序规则）

AnnotationAwareOrderComparator.sort(list)

注入到构造函数

// 最终等价于：
new PushDataStrategyManager(allStrategies);

6-创建Bean流程

大致的创建流程：

@Component
public class TestStrategy implements PushDataStrategy {}

启动期-注册阶段：

BeanDefinition:
- beanName = "testStrategy" # BeanName默认为类名首字母小写
- beanClass = TestStrategy.class
- scope = singleton
- lazy = false
- autowire = constructor
# 此时 还没有 this 实例地址
# Spring 存的是 BeanName → BeanDefinition（包含 class 信息）

IOC内部结构，Spring 核心容器本质是两张表：

BeanDefinition Map（启动期）

Map<String, BeanDefinition>

"testStrategy" -> BeanDefinition(TestStrategy.class)

也可以去直接看代码，查看启动期注册信息，示例：

// Springboot主启动类：
@SpringBootApplication  // SpringBoot 核心注解，标记这是一个启动类
@EnableDiscoveryClient  // 开启 Nacos 注册发现
@ComponentScan(basePackages = {"org.myproject.user", "org.myproject.common"})// 公共模块扫描
public class UserServiceApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(UserServiceApplication.class, args);
        // debug查看beanDefinitionMap
        // 获取 BeanFactory
        DefaultListableBeanFactory beanFactory =
                (DefaultListableBeanFactory) context.getBeanFactory();
        // 查看所有 BeanDefinition 名称
        String[] beanNames = beanFactory.getBeanDefinitionNames();
        System.out.println("BeanDefinition 数量：" + beanNames.length);
        // 注意bean名字是类名的小写
        BeanDefinition bd = beanFactory.getBeanDefinition("userServiceImpl");
        // 查看某一个 BeanDefinition 的“元信息”
        System.out.println(bd.getBeanClassName());
        System.out.println(bd.getScope());
        System.out.println(bd.isLazyInit());
        // 看到类似：
        //org.myproject.user.service.impl.UserServiceImpl
        //singleton
        //false
    }
}

Singleton Objects Map（运行期）

Map<String, Object>

"testStrategy" -> TestStrategy@5f3a4d

也可以去直接看代码，查看真正的实例，示例：

@SpringBootApplication  // SpringBoot 核心注解，标记这是一个启动类
@EnableDiscoveryClient  // 开启 Nacos 注册发现
@ComponentScan(basePackages = {"org.myproject.user", "org.myproject.common"})// 公共模块扫描
public class UserServiceApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(UserServiceApplication.class, args);
        DefaultListableBeanFactory beanFactory =
                (DefaultListableBeanFactory) context.getBeanFactory();
        // 强转为可访问单例池的类型
        DefaultSingletonBeanRegistry registry =
                (DefaultSingletonBeanRegistry) beanFactory;
        // 查看当前已经创建的单例 Bean
        String[] singletonNames = registry.getSingletonNames();
        System.out.println("已创建的 singleton 数量：" + singletonNames.length);
        // 查看某个 Bean 的真实实例
        Object bean = registry.getSingleton("userServiceImpl");
        System.out.println(bean);
        System.out.println(bean.getClass());
        //已创建的 singleton 数量：410
        //org.myproject.user.service.impl.UserServiceImpl@6f26e775
        //class org.myproject.user.service.impl.UserServiceImpl$$EnhancerBySpringCGLIB$$9d7c1b34
        //user使用了事务注解，会创建代理类
        //包含 $$EnhancerBySpringCGLIB$$ 标识
        //这是 Spring CGLIB 动态代理的典型命名模式
    }
}

7-创建顺序

实际创建顺序假设：

@Component
public class PushDataStrategyManager {
    public PushDataStrategyManager(List<PushDataStrategy> strategies) {}
}

Spring 执行流程：

需要创建PushDataStrategyManager

→ 发现构造器参数：
List<PushDataStrategy>

Spring尝试解析这个参数

→ 发现需要：
所有 PushDataStrategy 类型的 Bean

Spring去查容器中已有的BeanDefinition

发现：
testStrategy
emailStrategy
smsStrategy

如果这些Bean尚未实例化

Spring 会：
先创建它们（递归）

将这些实例组成List

List.of(testStrategy, emailStrategy, smsStrategy)

调用Manager构造器

new PushDataStrategyManager(list)

Manager实例化完成

总结：

Spring不是先“批量创建所有Bean”，而是在创建某个Bean时，递归创建它所依赖的Bean
但由于：singleton、non-lazy，看起来像是“启动时全部创建完”

到此这篇关于Spring依赖注入Bean流程及其理解的文章就介绍到这了,更多相关Spring依赖注入Bean内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java判断一个时间是否在当前时间区间代码示例
这篇文章主要给大家介绍了关于使用Java判断一个时间是否在当前时间区间的相关资料,在日常开发中我们经常会涉及到时间的大小比较或者是判断某个时间是否在某个时间段内,需要的朋友可以参考下
2023-07-07
Java实现Excel数据导出的实战指南
Excel 导出是后台管理系统中的标配功能,用于将系统数据导出为 Excel 文件供用户下载、分析或归档,本文提供了一个完整的Excel数据导出实战指南,主要针对后台管理系统中的员工信息导出场景,有需要的小伙伴可以了解下
2026-06-06
MyBatis Plus如何实现获取自动生成主键值
这篇文章主要介绍了MyBatis Plus如何实现获取自动生成主键值问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-09-09
java定义受限制的类型参数操作
这篇文章主要介绍了java定义受限制的类型参数操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2020-08-08
SpringBoot 整合 Apache Tika提取数据的具体操作
Apache Tika 是一个功能强大的内容分析工具,它能够从多种文件格式中提取文本、元数据以及其他结构化信息,本文介绍了SpringBoot整合ApacheTika进行文件内容提取和数据泄露防护的实现,感兴趣的朋友一起看看吧
2025-02-02
Spring Boot 配置文件类型properties 格式与yml 格式
这篇文章主要介绍了Spring Boot 配置文件类型properties 格式与yml 格式，文章围绕主题展开详细内容，具有一定的参考价值，需要的小伙伴可以参考一下
2022-05-05
基于SpringBoot创建Web页面并热更新的操作步骤
SpringBoot是一个用于快速开发单个微服务的框架,它基于 Spring 框架,简化了Spring应用的初始化过程和开发流程,本文给大家介绍了如何基于SpringBoot创建Web页面并热更新,文中通过图文介绍的非常详细,需要的朋友可以参考下
2023-11-11
Java如何替换第一个和最后一个字符串
这篇文章主要介绍了Java如何替换第一个和最后一个字符串的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-08-08
如何通过Java代码实现KMP算法
这篇文章主要介绍了如何通过Java代码实现KMP算法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2019-11-11
Java RabbitMQ 中的消息长期不消费会过期吗
RabbitMQ支持消息的过期时间,在消息发送时可以进行指定。 RabbitMQ支持队列的过期时间,从消息入队列开始计算,只要超过了队列的超时时间配置,那么消息会自动的清除
2021-09-09