Spring之注入模型

已于 2024-04-15 16:59:18 修改
阅读量1k 收藏 20
点赞数 12
分类专栏： Spring 文章标签： spring java 后端
于 2024-03-12 08:43:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38257958/article/details/136532468
版权

前言

之前我写过一篇关于BeanDefinition的文章,讲述了各个属性的作用,其中有一个属性我没有提到,因为这个属性比较重要,所以这里单独开一篇文章来说明

上一篇博文链接 Spring之BeanDefinition

再探AbstractBeanDefinition源码

通过源码我们得出结论,注入类型有四种

  • AUTOWIRE_NO (0)
  • AUTOWIRE_BY_NAME (1)
  • AUTOWIRE_BY_TYPE (2)
  • AUTOWIRE_CONSTRUCTOR (3)

PS : 实际有五种,AUTOWIRE_AUTODETECT已过期,我们暂不讨论

默认情况下的注入模型

代码准备

创建配置类AppConfig

package com.test.model.config;


import org.springframework.context.annotation.ComponentScan;

@ComponentScan("com.test.model")
public class AppConfig {

}

创建一个普通bean

package com.test.model.component;

import org.springframework.stereotype.Component;

@Component
public class MixComponent {

}

创建一个BeanFactoryPostProcessor(后面简称bfpp) 

package com.test.model.bfpp;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class AutowireBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {


    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) registry.getBeanDefinition("mixComponent");
        int autowireMode = beanDefinition.getAutowireMode();
        System.out.println(autowireMode);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}

创建启动类

package com.test.model;

import com.test.model.config.AppConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    }
}

运行main方法,查看运行结果 

 结论 : 默认的注入模型是0 (AUTOWIRE_NO)

默认情况下的依赖注入

创建三个普通bean

@Component
public class ComponentA {
}

@Component
public class ComponentB {
}

@Component
public class ComponentC {
}

依赖注入

package com.test.model.component;

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

@Component
public class MixComponent {

    @Autowired
    private ComponentA componentA;

    private ComponentB componentB;

    private ComponentC componentC;

    @Autowired
    public void setComponentB(ComponentB componentB) {
        this.componentB = componentB;
    }

    public MixComponent() {
    }

    @Autowired
    public MixComponent(ComponentC componentC) {
        this.componentC = componentC;
    }
}

默认情况下的依赖注入的三种方式

  • 属性注入
  • setter注入
  • 构造器注入

运行main方法,查看运行结果

 byName情况下的依赖注入

通过bfpp修改注入模型

package com.test.model.bfpp;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class AutowireBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {


    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) registry.getBeanDefinition("mixComponent");
        // 将注入模型改为byName
        beanDefinition.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_NAME);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}

改造MixComponent 

package com.test.model.component;

import org.springframework.stereotype.Component;

@Component
public class MixComponent {
    
    // 没有Autowired注解
    private ComponentA componentA;

    // 没有Autowired注解
    private ComponentB componentB;

    // 没有Autowired注解
    private ComponentC componentC;

    public void setComponentA(ComponentA componentA) {
        this.componentA = componentA;
    }

    public void setComponentB(ComponentB componentB) {
        this.componentB = componentB;
    }

    public void setComponentC(ComponentC componentC) {
        this.componentC = componentC;
    }
}

 运行main方法,查看运行结果

源码解析

AbstractAutowireCapableBeanFactory#populateBean

AbstractAutowireCapableBeanFactory#autowireByName

AbstractAutowireCapableBeanFactory#unsatisfiedNonSimpleProperties

 unsatisfiedNonSimpleProperties方法大概分为两个步骤

  1. 利用Spring的内省机制获取pds
  2. 判断这个pd是否符合条件
    1. 判断pd是否存在writeMethod
    2. 判断pd的propertyType是不是需要忽略的类
    3. pvs是否已存在相同name的值
    4. propertyType是不是普通类

我来解释一下pd需要满足的四个条件

条件1
package com.test.model.component;

import org.springframework.stereotype.Component;

@Component
public class Demo1 {

    public Object getAbc() {
        return null;
    }

    public void setAbc(Object abc) {

    }

    public Object getXyz() {
        return null;
    }

    public void setXyz(Object xyz) {

    }
}

不管我们是不是真实存在abc、xyz这样的属性，只要类中存在setXxx或者getXxx这样的方法，我们就认为类中存在一个名称为xxx的属性。如果存在setXxx方法,表示该属性存在writeMethod

PS : 我测试了一下,setXxx方法只能存在一个参数

条件2

比如bean实现了xxxAware接口,其相应的实现方法会被过滤掉

相关源码

AbstractApplicationContext#prepareBeanFactory

PS : 可能还有其他地方也添加了相关接口,debug的时候不止这几个

条件3
package com.test.model.bfpp;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class Demo1FactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        AbstractBeanDefinition b2 = (AbstractBeanDefinition) registry.getBeanDefinition("demo1");

        b2.getPropertyValues().add("abc", new Object());
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}

我们可以手动给指定bean的属性设置值,那样就不会在Spring容器中查找符合条件的bean了。

条件4

Spring定义的普通类

byType情况下的依赖注入

byType和byName类似 主要就是根据参数类型从Spring中查找符合条件的bean,主要关注unsatisfiedNonSimpleProperties方法

测试发现一个有意思的情况,下方代码在byName的情况下会错,在byType的情况下会正确注入

package com.test.model.component;

import org.springframework.stereotype.Component;

@Component
public class Demo2 {

    private ComponentC componentC;

    public void setComponentA(ComponentC componentC) {
        this.componentC = componentC;
    }
}

构造器注入

修改MixComponent代码,并将注入模型改成AUTOWIRE_CONSTRUCTOR

@Component
public class MixComponent {

    private ComponentA componentA;

    private ComponentB componentB;

    private ComponentC componentC;

    public MixComponent() {
    }

    protected MixComponent(ComponentA componentA, ComponentB componentB, ComponentC componentC) {
        this.componentA = componentA;
        this.componentB = componentB;
        this.componentC = componentC;
    }

    public MixComponent(ComponentA componentA, ComponentB componentB) {
        this.componentA = componentA;
        this.componentB = componentB;
    }
}

@Component
public class AutowireBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) registry.getBeanDefinition("mixComponent");
        // 将注入模型改为AUTOWIRE_CONSTRUCTOR
        beanDefinition.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}

运行main方法,查看运行结果

最终选择了两个参数的构造方法,排序规则如下

  1. 修饰方法 : public > 其他
  2. 参数个数 : 从多到小
  3. 编译顺序 : 先解析 > 后解析

排序完,会计算权重,最终选择权重最小的(即优先级最高的),一般情况下排完序的第一个构造器就是选中的构造方法,详情可以看我之前的博文 : Spring之推断构造方法

除了注入模型是AUTOWIRE_CONSTRUCTOR,如果满足下列三个条件也会执行构造器注入的逻辑

  • ctors != null
  • mbd.hasConstructorArgumentValues()
  • !ObjectUtils.isEmpty(args)

相关源码AbstractAutowireCapableBeanFactory#createBeanInstance

四个条件下的候选构造方法

  • AUTOWIRE_CONSTRUCTOR : 所有构造方法
  • ctors != null : 需要推断,我会在下文中,举例几种case
  • mbd.hasConstructorArgumentValues() : 手动设置内容相关构造方法
  • !ObjectUtils.isEmpty(args) : 手动设置内容相关构造方法

演示ctors != null能推断出构造方法的几种情况,以及两种手动设置构造函数的用法

ctors != null的几种情况
package com.test.model.component;

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

@Component
public class Demo3 {

    /**
     * case1:有且仅有一个有参构造方法
     */
    private ComponentA componentA;

    public Demo3(ComponentA componentA) {
        this.componentA = componentA;
    }

    /**
     * case2:有且仅有一个@Autowired(required = true)标注的构造方法
     */
    private ComponentB componentB;

    private ComponentC componentC;

    @Autowired(required = true)
    public Demo3(ComponentB componentB) {
        this.componentB = componentB;
    }

    public Demo3(ComponentC componentC) {
        this.componentC = componentC;
    }

    /**
     * case3:有多个@Autowired(required = false)标注的构造方法
     */
    @Autowired(required = false)
    public Demo3(ComponentB componentB) {
        this.componentB = componentB;
    }

    @Autowired(required = false)
    public Demo3(ComponentC componentC) {
        this.componentC = componentC;
    }
}
mbd.hasConstructorArgumentValues()
package com.test.model.component;

import org.springframework.stereotype.Component;

@Component
public class Demo4 {

    private ComponentB componentB;

    private ComponentC componentC;


    public Demo4(ComponentB componentB) {
        this.componentB = componentB;
    }

    public Demo4(ComponentC componentC) {
        this.componentC = componentC;
    }
}

package com.test.model.bfpp;

import com.test.model.component.ComponentB;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class Demo4FactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) registry.getBeanDefinition("demo4");
        // 指定构造器Demo4(ComponentB componentB)
        beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0,new ComponentB());
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}
 !ObjectUtils.isEmpty(args)
package com.test.model.component;

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
@Lazy
public class Demo5 {

    private ComponentB componentB;

    private ComponentC componentC;


    public Demo5(ComponentB componentB) {
        this.componentB = componentB;
    }

    public Demo5(ComponentC componentC) {
        this.componentC = componentC;
    }
}

如果同时存在@Autowired注解并且注入类型是byType(byName),以byType(byName)注入的结果为准

demo演示

创建一个接口和两个实现其接口的bean

public interface Car {
}

@Component
public class RedCar implements Car {
}

@Component
public class WhiteCar implements Car {
}

创建一个类型为Person的bean,并将其注入模型改为byType

@Component
public class Person {

    @Autowired
    @Qualifier("whiteCar")
    private Car car;

    public Car getCar() {
        return car;
    }

    public void setCar(RedCar redCar) {
        this.car = redCar;
    }
}

@Component
public class PersonFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) registry.getBeanDefinition("person");
        // 将注入模型改为AUTOWIRE_BY_TYPE
        beanDefinition.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}

运行main方法查看运行结果

注入的是byType选中的bean 

关于两种说法的自我理解

两种说法

  1. @Autowired是不是自动注入
  2. @Autowired是byType还是byName

自我理解

  1. @Autowired客观上存在使用者想注入一个依赖的明确目的,只是查找依赖过程是由Spring完成的,并没有达到不干预自动注入的现象,最多可以认为是半自动注入
  2. 从注入模型的角度上说@Autowired和三种自动注入没有任何关系,只是在查找依赖的过程中,会先通过类型查找依赖,如果找到多个符合条件的bean,再根据名称进行筛选。我们不要把根据类型查找依赖，根据名称查找依赖，与byType或者byName划上等号。它们一个是查找bean的手段，一个是自动注入枚举
一只懒鱼a
关注
  • 12
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JAVAspring学习资料
03-29
Spring MVC：用于构建Web应用程序的模块，提供了基于MVC（模型-视图-控制器）的开发方式，简化了Web应用程序的开发和测试2. Spring Data：用于简化与数据库的交互，提供了对多种数据库的支持，并提供了一套统一的API...
spring自动注入模型
小小少年的博客
10-21 546
spring的注入，可以分为两种，分别是手动注入和自动注入 我们这里要记录的是自动注入 自动注入模型 spring的自动注入模型有四种，分别是： autowire_no(0): 默认的装配模式，如果注入indexBean，没有在属性上加@Autowired或者@Resource，这时候，indexBean是无法注入的 autowire_name(1): 通过set方法，并且set方法的名称必须和bean的name名称一致， byName autowire_type(2): 通过set方法，这种方式set方
Spring自动注入
Moonxiyue的博客
05-17 1340
spring的ioc 在刚开始学习spring的时候肯定都知道spring的两个特点:ioc,aop,控制反转和切面编程,这篇就只说说ioc ioc是什么:在我们原来的代码中,如果A依赖了B,那么我们会自己在A类中来new B,创建B的实例来使用,是程序主动的去创建依赖,但是我们在使用spring的了之后还会在A中主动的去创建B吗?基本不会,因为创建对象的这个操作从原来的我们来控制变成了spring来管理,这个过程就称为控制反转,ioc并不是一种技术,而是一种编程思想,代码的设计思路 那么这样做的好处
Spring之依赖注入
自由人的博客
08-13 1028
1、探索Spring的依赖注入 2、Spring的依赖注入有几种方式，源码解析 3、循环依赖，问题及解决
spring 对于注入的理解
TBryant的博客
06-09 1280
"注入"的概念 本文讨论的"注入"，指的是spring给Bean注入属性（也可以称之为"装配"），并非其他注入。 spring要给Bean注入属性，有两种方式： 如果程序员手动提供配置信息给spring，则是 如果依赖配置信息，我们需要手动配置，故称为手动注入；如果不依赖配置信息，spring根据注入模型进行注入，故称为自动注入。其实注入的动作都是spring内部完成的，手动和自动区别在于是否有手动提供配置信息给spring。 xml风格手动配置 // 创建一个X类，一个Y类，X类包含一个属性，类型是Y
spring.zip
03-20
Spring4.0 引入了众多 Java 开发者期盼的新特性，如泛型依赖注入、SpEL、校验及格式化框架、Rest风格的 WEB 编程模型等
Spring+MVC+Mybatis 书城项目
03-08
Spring提供了很多功能，包括事务管理、依赖注入、AOP（面向切面编程）等。 Spring MVC: Spring MVC是Spring框架的一个模块，它实现了MVC（模型-视图-控制器）设计模式，用于构建Web应用。Spring MVC允许你将应用的...
base-model:Spring模型实用程序
04-29
Spring4基本模型 内容 该库包含一组定义以下内容的类： 型号： ：每个可持久类都应扩展的Interface - Primary Key是一个Long变量，称为id ：每个用户类应扩展的Interface 验证： ： Validator用于管理多个验证 ...
JavaSpring的商城项目前台+后台+api
03-03
JavaSpring的商城项目 Java Spring是一个开源的Java平台，它为基于Java的企业级应用提供了全面的基础架构支持。Spring框架的核心特性可以用于任何Java应用程序，但存在扩展，它们...模型-视图-控制器（MVC）：Spring的W
(三)Spring教程——依赖注入与控制反转
05-14 559
Spring有两个重要的接口：BeanFactory和ApplicationContext，所谓的容器就是实现了BeanFactory接口或者是ApplicationContext接口的类的实例，BeanFactory是最顶层、最基本的接口，它描述了容器需要实现的最基本的功能，比如对象的注册、获取等。在编写传统的Java应用代码时，我们一般是直接在对象内部通过new来创建对象，让程序主动去创建依赖对象，这就是一个“谁使用，谁创建”的过程，创建依赖对象的主动权和创建时机都是由自己来把控。
【Spring Security】授权
最新发布
weixin_43676950的博客
05-20 403
RBAC（Role-Based Access Control，基于角色的访问控制）是一种常用的数据设计方案，它将用户的权限分配和管理与角色相关联。通过对用户角色关联和角色权限关联表进行操作，可以实现灵活的权限管理和访问控制。1、用户表（User table）：包含用户的基本信息，例如用户名、密码和其他身份验证信息。5、角色权限关联表（Role-Permission table）：将角色与权限关联起来。4、用户角色关联表（User-Role table）：将用户与角色关联起来。
spring 循环依赖
weixin_45849726的博客
05-14 442
先创建ABean1.0. 记录正在创建ABean singletonCurrentlyInCreation<1.1.实例化ABean–>得到一个对象–>存入singletonFactories1.2. 填充BBean属性–>去单例池找BBean–>没有就创建1.3. 进行其他依赖注入1.4. 初始化前，初始化1.5. 初始化后1.6. 放入单例池创建BBean2.1. 实例化BBean–>得到一个对象。
java云his系统源码 一站式诊所SaaS系统Java+Spring+Angular+Nginx 云HIS系统八大特点
zmm201453的博客
05-15 1213
HIS系统采用面向技术架构的分析与设计方法，应用多层次应用体系架构设计，运用基于构件技术的系统搭建模式与基于组件模式的系统内核结构。通过建立统一接口标准，实现数据交换和集成共享，通过统一身份认证和授权控制，实现业务集成、界面集成。
黑马guli商城项目初始化-SpringCloud微服务项目初始化使用SpringCloudAlibaba快速搭建分布式系统
这个人很懒什么都没有留下
05-16 543
*** 1、如何使用Nacos作为配置中心统一管理配置* 1）、引入依赖，* 2）、创建一个bootstrap.properties。* 3）、需要给配置中心默认添加一个叫 数据集（Data Id）gulimall-coupon.properties。默认规则，应用名.properties* 4）、给 应用名.properties 添加任何配置* 5）、动态获取配置。* @RefreshScope：动态获取并刷新配置* @Value("${配置项的名}")：获取到配置。
Spring AI项目Open AI对话接口开发指导
缘友一世的博客
05-14 543
【代码】Spring AI项目Open AI对话接口开发指导。
SpringBoot事件发布与监听，观察者模式使用
小哇
05-16 215
可以发现，用户注册与信息推送强耦合，用户注册其实到存库成功，就已经算是完成了，后面的信息推送都是额外的操作，甚至信息推送失败报错，还会影响API接口的结果，如果在同一事务，报错信息不捕获，还会导致事务回滚，存库失败。本文记录springboot使用@EventListener监听事件、ApplicationEventPublisher.publishEvent发布事件实现业务解耦。
SpringBoot设置默认文件大小
如果相遇，那么你好哦~
05-14 221
修改SpringBoot项目的默认上传文件大小
基于springboot实现医药管理系统项目【项目源码+论文说明】
ybigbear2的博客
05-15 532
本课题对于医药信息的管理方面，开发一个医药管理系统，在信息管理方面不至于混乱，也能降低数据的出错率，数据安全方面也有了保证，该系统还有其他的优点，比如优化信息处理流程，降低信息泄露风险，减少资金投入，产出更高，让管理人员的工作更有效率等。程序开发中对于各种程序判定异常，必须有统一的处理模式，异常是程序开发中不可避免的，但是可以对出现的异常进行抛出，有助于程序异常处理的复盘，只要每个异常都能定位准确，那么代表程序设计是趋于完美的，维护起来会更加的方便，只要有助于程序维护的都必须给予支持。
spring 领域驱动模型
07-13
在Spring中，可以使用领域驱动设计（Domain-Driven Design，简称DDD）模型...通过使用上述技术和模式，结合Spring框架的依赖注入、AOP等特性，可以更好地实现领域驱动设计，并构建具有高内聚、低耦合的Spring应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值