Spring 中的依赖查找和依赖注入

已于 2022-10-23 18:59:55 修改
阅读量897 收藏 2
点赞数 1
分类专栏： Spring 文章标签： Spring
于 2021-11-13 15:02:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hotonyhui/article/details/121304694
版权

Spring 中的依赖查找和依赖注入

作者：Grey

原文地址：

博客园：Spring 中的依赖查找和依赖注入

CSDN：Spring 中的依赖查找和依赖注入

依赖查找

Spring IoC 依赖查找分为以下几种方式

  • 根据 Bean 名称查找

    • 实时查找
    • 延迟查找

  • 根据 Bean 类型查找

    • 单个 Bean 对象
    • 集合 Bean 对象

  • 根据 Bean 名称 + 类型查找

  • 根据 Java 注解查找

    • 单个 Bean 对象
    • 集合 Bean 对象

以下示例基于spring-framework 5.2.13.RELEASE 版本, 通过Maven管理项目

根据Bean名称实时查找

pom.xml 文件引入如下依赖


<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
</dependency>

定义一个User作为Domain

public class User {
    private Long id;
    private String name;
    // set / get / toString方法略
}

在resources目录下建立META—INF目录，同时新建一个dependency-lookup.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

在xml文件中配置如下内容

<?xml version="1.0"encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="org.snippets.spring.ioc.overview.dependency.domain.User">
        <property name="id" value="1"/>
        <property name="name" value="张三"/>
    </bean>

</beans>

新建测试类

package org.snippets.spring.ioc.overview.dependency.lookup;

/**
 * 通过名称查找
 */
public class DependencyLookup {
    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup.xml");
        lookupRealtime(beanFactory);
    }

    // 实时查找（按Bean名称）
    private static void lookupRealtime(BeanFactory beanFactory) {
        User user = (User) beanFactory.getBean("user");
        System.out.println(user);
    }
}

输出结果

User{id=1, name='张三'}

根据Bean名称延迟查找

在上例中的xml文件中配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="org.snippets.spring.ioc.overview.dependency.domain.User">
        <property name="id" value="1"/>
        <property name="name" value="张三"/>
    </bean>
    <bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
        <property name="targetBeanName" value="user"/>
    </bean>
</beans>

新建测试类


public class DependencyLookup {
    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup.xml");
        lookupLazy(beanFactory);
    }

    // 延迟查找（按Bean名称）
    private static void lookupLazy(BeanFactory beanFactory) {
        ObjectFactory<User> objectFactory = (ObjectFactory<User>) beanFactory.getBean("objectFactory");
        User user = objectFactory.getObject();
        System.out.println(user);
    }
}

运行结果

User{id=1, name='张三'}

根据Bean类型查找单个对象


private static void lookupByTypeSingle(BeanFactory beanFactory){
        User user=beanFactory.getBean(User.class);
        System.out.println(user);
        }

根据Bean类型查询集合对象

private static void lookupByTypeCollection(BeanFactory beanFactory){
      if(beanFactory instanceof ListableBeanFactory){
        ListableBeanFactory beanFactory1=(ListableBeanFactory)beanFactory;
        Map<String, User> users=beanFactory1.getBeansOfType(User.class);
        System.out.println(users);
      }
}

根据Java注解来查询多个对象

首先我们定义一个注解@Super

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Super { }

然后我们定义一个User的子类SuperUser，并标注@Super注解

@Super
public class SuperUser extends User {
    private String address;
    // set / get / toString方法忽略
}

我们在xml中做如下配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="org.snippets.spring.ioc.overview.dependency.domain.User">
        <property name="id" value="1"/>
        <property name="name" value="张三"/>
    </bean>
    <bean id="superUser" class="org.snippets.spring.ioc.overview.dependency.domain.SuperUser" parent="user"
          primary="true">
        <property name="address" value="广州"/>
    </bean>
    <bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
        <property name="targetBeanName" value="user"/>
    </bean>
</beans>

如果通过User.class类型来找Bean，可能会找到SuperUser和User两个，但是加了Primary="true"这个配置，则只会找superUser这个Bean

接下来就是通过注解来找到Bean的代码

    private static void lookupByAnnotations(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory beanFactory1 = (ListableBeanFactory) beanFactory;
            Map<String, User> users = (Map) beanFactory1.getBeansWithAnnotation(Super.class);
            System.out.println(users);
        }
    }

打印结果：

{superUser=SuperUser{address='广州'} User{id=1, name='张三'}}

依赖注入

Spring IoC 依赖注入分为以下几种方式

  • 根据 Bean 名称注入

  • 根据 Bean 类型注入

    • 单个 Bean 对象
    • 集合 Bean 对象

  • 注入容器內建 Bean 对象

  • 注入非 Bean 对象

  • 注入类型

    • 实时注入
    • 延迟注入

增加UserRepository


public class UserRepository {
    private Collection<User> users; // 自定义Bean
    private BeanFactory beanFactory; // 内建非 Bean(依赖）
    private ObjectFactory<ApplicationContext> objectFactory;
    // 省略 set/get/toString方法
}

首先我们新建一个配置文件dependency-injection.xml

引入上一例中的dependency-lookup.xml，并增加一个Bean的配置, 并且配置手动注入这个Bean中属性信息

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">

    <import resource="dependency-lookup.xml"/>
    <bean id="userRepository"
          class="org.snippets.spring.ioc.overview.dependency.repo.UserRepository"
          > 
        <!-- 手动注入 -->
        <property name="users">
             <util:list>
                 <ref bean="user"/>
                 <ref bean="superUser"/>
             </util:list>
         </property>
    </bean>
</beans>

测试

public class DependencyInjection {
    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-injection.xml");
        UserRepository userRepository = beanFactory.getBean("userRepository", UserRepository.class);
        System.out.println(userRepository.getUsers()); 
    }
}

可以打印出注入的user信息

也可以实现自动注入，我们以按类型自动注入为例，修改xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">

    <import resource="dependency-lookup.xml"/>
    <bean id="userRepository"
          class="org.snippets.spring.ioc.overview.dependency.repo.UserRepository"
          autowire="byType"> <!-- 自动注入-->
    </bean>
</beans>

增加autowire=“byType” 即可

完整代码

Github

参考资料

小马哥讲Spring核心编程思想

GreyZeng
关注
专栏目录
Spring 依赖查找、依赖注入
小白
03-20 284
依赖查找 根据Bean名称查找 public class User { private Integer id; private String name; } 实时查找 @Configuration public class UserConfig { @Bean public User user() { User user = new User(1, "wangrui"); return user; } } AnnotationConfigApplicationCont
spring依赖查找和依赖注入
weixin_45594127的博客
12-10 289
依赖查找 查找对象就是spring 容器管理的各种Bean， 包括 xml bean definition java annotation and configuration spring内建Bean, eg：AutowiredAnnotationBeanPostProcessor 手动注册BeanDefinition 依赖注入 可以通过依赖查找获取的所有Bean 外部化配置： @Value 特殊对象：BeanFactory, ApplicationContext 可以看到依赖注入的范围更广 ..
spring全家桶使用教程
最新发布
alankuo的专栏
09-30 675
Spring全家桶包含了多个用于企业级Java开发的框架和工具。还可以配置Hystrix的相关参数，如熔断器的阈值、线程池大小等。以Hystrix为例，在服务调用方项目中添加。在需要进行容错处理的方法上添加。
深入理解Spring的依赖查找和依赖注入【建议收藏】
Linn的博客
06-26 1075
如果你觉得内容对你有帮助的话，不如给个赞，鼓励一下更新????。 本文内容来自《小马哥讲Spring核心编程思想》，看完之后总结的笔记，适合闲暇时候看看 依赖注入的模式和类型 依赖注入的模式 手动模式 - 配置或者编程的方式，提前安排注入规则 XML 资源配置元信息 Java 注解配置元信息，比如@Autowired、@Resource API 配置元信息 自动模式 - 实现方提供依赖自动关联的方式，按照內建的注入规则 Autowiring（自动绑定） 依赖注入的类型 依赖注入类型 配
依赖查找 和 依赖注入
dying 搁浅
12-05 3978
依赖查找 和 依赖注入 这两个词看起来很相似，一到了学术上大家就喜欢玩这种概念性的文字游戏，很无奈，但也没有办法。 首先我们不带任何概念和基础的来看这两个词，仅仅分析词意。 他们文字上的区别就是一个是 查找 一个是 注入 查找： 我们通常理解为是一个主动的行为，主动地去查找什么？ 注入： 通常是被动的行为，被三方注入些什么？ 了解到了这两个区别，那下一个问题就很明显了，我们要 查找什么？ 注入什么？ 答案在词语中已经给出：依赖 那么该如何理解这个依赖？ 说实际点的，以 Java 为例子，以个普通类的成员变量
Spring-IoC：依赖查找和依赖注入
一只青年痴呆
09-04 994
IoC 依赖查找 根据Bean名称查找 实时查找 延迟查找 根据Bean类型查找 单个Bean对象 集合Bean对象 根据Bean名称 + 类型查找 根据Java注解查找 单个Bean对象 集合Bean对象 private static void lookupByAnnotation(BeanFactory beanFactory) { if (beanFactory instanceof ListableBeanFactory) {
spring依赖注入知识点分享
08-25
在本篇文章中，我们将详细介绍 Spring 依赖注入的知识点，并提供相关的代码内容。 什么是 IoC IoC（Inversion of Control），即控制反转，是一种软件设计模式。它将对象之间的依赖关系管理方式，称作 IoC。IoC 是...
实例讲解Java的Spring框架中的控制反转和依赖注入
09-02
在Java的Spring框架中，控制反转（IoC，Inversion of Control）和依赖注入（DI，Dependency Injection）是核心设计理念，它们旨在降低组件之间的耦合度，提高代码的可测试性和可维护性。Spring框架通过IoC容器来管理...
Spring Boot依赖注入
03-04
当一个类被声明为Spring Bean时，Spring容器会负责它的生命周期，包括初始化、实例化、依赖注入和销毁等阶段。 1. **创建Bean**: 在Spring Boot中，我们可以通过以下几种方式声明Bean： - 使用@Component、@...
详解Spring依赖注入：@Autowired，@Resource和@Inject区别与实现原理
08-25
@Autowired 是 Spring 框架提供的依赖注入注解，主要支持在 set 方法、field 和构造函数中完成 bean 注入。其注入方式是通过类型查找 bean，即 byType 的，如果存在多个同一类型的 bean，则使用 @Qualifier 来指定...
4. 依赖查找&依赖注入
干脆面la的博客
04-11 1066
1. 依赖查找和依赖注入的区别；2. 分别通过xml文件配置和注解配置两种方式实现依赖注入；3. 配置文件的两种依赖注入和注解依赖注入的三种方式以及优缺点。
Spring系列：IOC依赖查找和IOC依赖注入区别对比
NIO4444
11-08 634
依赖查找 实现初始化bean到map的value中，使用时根据bean名字作为key从map中获取。 通过beanFactory或者context的getBean()方法是依赖查找 依赖注入 比如 @Autowired @Resource是依赖注入
依赖查找和依赖注入的区别
qq_26680555的博客
05-22 281
java控制反转的实现，依赖查找和依赖注入的区别是什么，今天我们来说道说道！
Spring学习笔记1-依赖查找、依赖注入、Bean初始化、销毁、垃圾回收GC、层次依赖查找、provider查找
u014516009的博客
04-23 882
依赖查找和依赖注入 依赖查找和依赖注入，是在Spring环境下获取实际对象的方式（基于IoC容器）。依赖查找偏主动，依赖注入偏被动。 依赖查找 依赖查找可以通过名称、类型和注解等三种方式实现查找。 依赖注入 依赖注入主要通过注解实现对象自动获取，不需要显示编码实现，常用语SpringBoot的框架中。此方式方便快速，理解上也相对简单。 配置Bean对象及信息 在配置对象信息时，可以通过设置Bean...
依赖查找VS依赖注入
查理的博客
05-17 317
依赖查找：通过API去主动查找。spring中的依赖查找、JNDI也是依赖查找 依赖注入：容器自动注入依赖 对比
String Bean 依赖查找 依赖注入 自动装配
美妙_perfect
02-28 1609
1. Spring Bean 依赖管理 1.1 依赖查找 实际项目中会存在很多个 Bean 对象，这些对象之间会存在一定依赖关系，当某个 Bean 对象依赖于其他 Bean 对象，可以通过 Spring 按照一定的规则（例如按类或者按名字），进行依赖查找然后进行值的注入 思考： 1）对象与对象之间可能存在什么关系？（is a，has a，use a） 例如： a) is a 关系...
控制反转(IoC)与依赖注入(DI)
weixin_34233679的博客
01-14 169
1.控制反转(Inversion of Control)与依赖注入(Dependency Injection) 控制反转即IoC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。 IoC是一个...
Spring-控制反转、依赖注入、依赖查找
孤竹彧的根据地
04-24 359
原网址：https://blog.csdn.net/lisulong1/article/details/51420078 IoC——Inversion of Control 控制反转 DI——Dependency Injection 依赖注入 要想理解上面两个概念，就必须搞清楚如下的问题： 参与者都有谁？ 依赖：谁依赖于谁？为什么需要依赖？ 注入：谁注入于谁？到底注入什么？ 控制反转：谁控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GreyZeng

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值