Spring 依赖注入详解

最新推荐文章于 2024-05-01 22:34:48 发布
最新推荐文章于 2024-05-01 22:34:48 发布
阅读量701 收藏 1
点赞数
分类专栏： spring进行maven开发 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48456383/article/details/125298276
版权

本章介绍了控制反转(IoC)原理的Spring框架实现。IoC也被称为依赖注入(DI)。在此过程中，对象仅通过构造函数参数、工厂方法的参数或在对象实例构造或从工厂方法返回后在对象实例上设置的属性来定义它们的依赖关系(即它们工作的其他对象)。然后容器在创建bean时注入这些依赖项。这个过程从根本上说是bean本身的逆过程(因此得名“控制反转”)

Spring使用控制反转容器IOC实现依赖注入，相比于传统依赖注入很大程度上解耦合程序。

Spring 依赖注入的方法大致有以下几种:

一.基于xml的spring配置: setter-based 依赖注入，constructor-based依赖注入，静态工厂方法注入（以后补充）

        1.引入maven依赖

        2.编写需要管理的类

        3.编写核心配置文件

                bean元素声明对象实例

                property指定要赋值的属性名

                value赋值的内容

二.基于注解：扫包依赖注入

参考：

Core Technologiesicon-default.png?t=M4ADhttps://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans

有关spring xml配置请看这篇文章

目录

场景说明:

准备工作：

1.setter-based 依赖注入（设值依赖注入）

A,B,C的java bean如下:

spring.xml 配置实体类

单元测试

2.constructor-based依赖注入

spring.xml 配置实体类

3.扫包依赖注入（个人比较偏好的一种方式）

spring.xml 配置实体类

A,B,C的java bean如下:

场景说明:

假设现有三个java bean，A,B,C。 A依赖于一个B对象，一个由C对象组成的list对象，使用spring IOC容器完成依赖注入。

准备工作：

Maven依赖

<dependencies>
    <!--spring依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.5.RELEASE</version>
    </dependency>
    <!--单元测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>
    <!--快速java bean-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

Spring 标准配置文件

<?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="..." class="...">  
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <!-- more bean definitions go here -->

</beans>

id属性是标识各个bean定义的字符串。
class属性定义bean的类型，并使用完全限定的类名。 

1.setter-based 依赖注入（设值依赖注入）

基于setter的DI是由容器在调用无参数构造函数或无参数静态工厂方法来实例化bean之后调用bean上的setter方法来完成的。

A,B,C的java bean如下:

package com.example.demo;

import java.util.List;

public class A {
    String Aname;
    B b;
    List<C> cs;


    @Override
    public String toString() {
        return "A{" +
                "Aname='" + Aname + '\'' +
                ", b=" + b +
                ", cs=" + cs +
                '}';
    }

    public String getAname() {
        return Aname;
    }

    public void setAname(String aname) {
        Aname = aname;
    }

    public B getB() {
        return b;
    }

    public void setB(B b) {
        this.b = b;
    }

    public List<C> getCs() {
        return cs;
    }

    public void setCs(List<C> cs) {
        this.cs = cs;
    }

    public A(String aname, B b, List<C> cs) {
        Aname = aname;
        this.b = b;
        this.cs = cs;
    }

    public A() {
    }
}

package com.example.demo;

public class B {
    String Bname;

    public B(String bname) {
        Bname = bname;
    }

    public B() {
    }


    @Override
    public String toString() {
        return "B{" +
                "Bname='" + Bname + '\'' +
                '}';
    }

    public String getBname() {
        return Bname;
    }

    public void setBname(String bname) {
        Bname = bname;
    }
}

package com.example.demo;

public class C {
    String Cname;


    public C() {
    }

    public C(String cname) {
        Cname = cname;
    }


    @Override
    public String toString() {
        return "C{" +
                "Cname='" + Cname + '\'' +
                '}';
    }

    public String getCname() {
        return Cname;
    }

    public void setCname(String cname) {
        Cname = cname;
    }
}

spring.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
        http://www.springframework.org/schema/beans/spring-beans.xsd">

   <!-- 1.配置实体类 -->
    <bean id="A" class="com.example.demo.A">
        <property name="Aname" value="Sb"></property>
        <property name="b" ref="B"></property>

        <property name="cs" >
            <list>
                <ref bean="C" ></ref>

                <ref bean="C" ></ref>
            </list>
        </property>
    </bean>

    <bean id="B" class="com.example.demo.B">
        <property name="Bname" value="Jack"></property>
    </bean>

    <bean id="C" class="com.example.demo.C">
        <property name="Cname" value="John"></property>
    </bean>
</beans>

很明显这里是通过设值的方式去实现依赖注入的初始化，要么用的name-value赋值，要么用的是name-ref赋值，要么用的是name-list赋值。

单元测试

    @Test
    public void junitTest1() {
        //指定spring配置文件的位置和名称
        String resource = "spring.xml";
        //创建spring容器对象
        ApplicationContext container = new ClassPathXmlApplicationContext(resource);
        //通过id从spring容器中获取对象
        A a = (A) container.getBean(A.class);
        System.out.println(a);

    }

结果

 

2.constructor-based依赖注入

基于构造函数的DI是由容器调用带有许多参数的构造函数来完成的，每个参数代表一个依赖项。调用带有特定参数的静态工厂方法来构造bean几乎是等价的，本文将以类似的方式处理构造函数和静态工厂方法的参数。

构造函数参数解析匹配通过使用参数的类型发生。如果bean定义的构造函数参数中不存在潜在的歧义，那么在bean定义中定义构造函数参数的顺序就是在实例化bean时将这些参数提供给适当的构造函数的顺序。但是如果你定义了name属性那么name属性的值一定要与构造函数的参数列表对应。

这里值得注意的是java bean的构造函数要实现全

这里对之前的A,B,C 3个java bean，单元测试代码都不做修改

spring.xml 配置实体类

<bean id="A" class="com.example.demo.A">
        <constructor-arg name="aname" value="Sb"></constructor-arg>
        <constructor-arg name="b" ref="B"></constructor-arg>
        <constructor-arg name="cs" >
            <list>
                <ref bean="C" ></ref>
                <ref bean="C" ></ref>
            </list>
        </constructor-arg>
    </bean>

    <bean id="B" class="com.example.demo.B">
        <constructor-arg  name="bname" value="Jack"></constructor-arg >
    </bean>

    <bean id="C" class="com.example.demo.C">
        <constructor-arg name="cname" value="John"></constructor-arg>
    </bean>

结果

 

关于基于构造函数依赖补充:

你可以使用index属性来显式指定构造函数参数的索引,也可以使用type属性显式指定构造函数参数的类型，容器可以使用简单类型匹配。这里可以去参考官方文档。

3.扫包依赖注入（个人比较偏好的一种方式）

XML设置的另一种选择是基于注释的配置，它依赖字节码元数据来连接组件，而不是尖括号声明。开发人员不使用XML来描述bean连接，而是通过使用相关类、方法或字段声明上的注释，将配置转移到组件类本身。

如果使用注解的方式进行依赖注入则通常需要使用如下注解:

@Component

         标注一个类为Spring容器的Bean，（把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/>）

        value 指定java bean的 bean id。

@Qualifier

        使用 @Autowired 注解是 Spring 依赖注入的绝好方法。但是有些场景下仅仅靠这个注解不足以让Spring知道到底要注入哪个 bean。默认情况下，@Autowired 按类型装配 Spring Bean。如果容器中有多个相同类型的 bean，则框架将抛出 NoUniqueBeanDefinitionException， 以提示有多个满足条件的 bean 进行自动装配。（其实就是解决接口有多个实现类，框架不知道如何选择实现类的情况）

        value 指定 注入的java bean 的 bean id。

        Spring 注解 @Qualifier 详细解析 - 知乎

@Autowired

        自动注入依赖类

         自动匹配 属性名 类型 id

         required=false 没找到bean返回null

         required=true (默认值)没找到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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="org.example"/>

</beans>

<context:component-scan>的使用隐式启用了<context:annotation-config>的功能。当使用<context:component-scan>时，通常不需要包含<context:annotation-config>元素。同时base-package应改为需要扫描的java bean所在的全限定包名。

实例中除了单元测试代码不需要更改，其他都需要改

spring.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

<context:component-scan base-package="com.example.demo"/>

</beans>

A,B,C的java bean如下:

值得注意的是，以为是通过扫包依赖注入，默认是优先调取对应的 java bean的无参构造函数，所以这里我修改了无参构造函数，使得依赖注入时有默认值。

package com.example.demo;

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

import java.util.ArrayList;
import java.util.List;
@Component
public class A {
    String Aname;
    @Autowired
    B b;
    @Autowired
    List<C> cs;


    @Override
    public String toString() {
        return "A{" +
                "Aname='" + Aname + '\'' +
                ", b=" + b +
                ", cs=" + cs +
                '}';
    }

    public String getAname() {
        return Aname;
    }

    public void setAname(String aname) {
        Aname = aname;
    }

    public B getB() {
        return b;
    }

    public void setB(B b) {
        this.b = b;
    }

    public List<C> getCs() {
        return cs;
    }

    public void setCs(List<C> cs) {
        this.cs = cs;
    }

    public A(String aname, B b, List<C> cs) {
        Aname = aname;
        this.b = b;
        this.cs = cs;
    }

    public A() {
        this.Aname="Sb";
        this.b=new B();
        this.cs=new ArrayList<C>();
        this.cs.add(new C());
    }
}

package com.example.demo;

import org.springframework.stereotype.Component;

@Component
public class B {
    String Bname;

    public B(String bname) {
        Bname = bname;
    }

    public B() {
        this.Bname="Jack";
    }


    @Override
    public String toString() {
        return "B{" +
                "Bname='" + Bname + '\'' +
                '}';
    }

    public String getBname() {
        return Bname;
    }

    public void setBname(String bname) {
        Bname = bname;
    }
}

package com.example.demo;

import org.springframework.stereotype.Component;

@Component
public class C {
    String Cname;


    public C() {
        this.Cname="John";
    }

    public C(String cname) {
        Cname = cname;
    }


    @Override
    public String toString() {
        return "C{" +
                "Cname='" + Cname + '\'' +
                '}';
    }

    public String getCname() {
        return Cname;
    }

    public void setCname(String cname) {
        Cname = cname;
    }
}

结果 

 

奶奶滴,为什么不学java
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring系列之依赖注入的方式
weixin_34319999的博客
09-26 1547
一、依赖注入方式       对于spring配置一个bean时，如果需要给该bean提供一些初始化参数，则需要通过依赖注入方式，所谓的依赖注入就是通过spring将bean所需要的一些参数传递到bean实例对象的过程，spring的依赖注入有3种方式： ·使用属性的setter方法注入 ，这是最常用的方式；·使用构造器注入；·使用Filed注入（用于注解方式）。 1.使用属性注入    ...
Spring依赖注入
m0_62356365的博客
04-21 3217
一、什么是依赖注入 DI (Dependency Injection)：依赖注入是指在 Spring IOC 容器创建对象的过程中，将所依赖的对象通过配置进行注入。我们可以通过依赖注入的方式来降低对象间的耦合度。 在软件工程中，对象之间的耦合度就是对象之间的依赖性。对象之间的耦合越高，维护成本越高，因此对象的设计应使对象之间的耦合越小越好。 1 类的关系 继承、实现、依赖、关联、聚合、组合。 2 关系强度 继承 = 实现 > 组合 > 聚合 > 关联 > 依赖 二、为什
Spring 的依赖注入
南淮北安的博客
05-14 6174
文章目录一、依赖注入的概念二、构造函数注入三、set 方法注入（更常用的方式）四、注入集合属性 一、依赖注入的概念 依赖注入： Dependency Injection，它是 spring 框架核心 IOC 的具体实现，具体点就是依赖关系的维护称之为依赖注入 我们的程序在编写时， 通过控制反转， 把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。 IOC 解耦只是降低他们的依赖关系，但不会消除。 例如：我们的业务层仍会调用持久层的方法。 那这种业务层和持久层的依赖关系， 在使用 spri
Spring中依赖注入原理解析
最新发布
dzend的专栏
05-01 479
依赖注入是Spring框架的核心功能之一，通过依赖注入可以实现组件之间的解耦，使得代码更加灵活和可维护。在Spring中，依赖注入是通过容器来实现的，容器负责管理组件之间的依赖关系，将依赖关系注入到组件中。依赖注入的原理主要是通过反射和动态代理来实现的，通过这两种技术，Spring可以实现自动注入依赖对象，从而实现依赖注入的功能。希望本文对大家理解Spring中的依赖注入原理有所帮助，欢迎大家多多交流和探讨。
Spring依赖注入的三种方式
欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
12-01 6706
还是与属性注入的解释是一样的,原因就是JDK是我们最底层的框架,Spring作为上层,要基于JDK/Java的,所以要满足Java的规范,java规定,被final修饰的属性1.在定义的时候进行赋值2.在构造方法内部进行赋值。原因还是一样的,因为满足Java的规范,被final修饰的属性 一个是定义的时候就进行赋值,一个是在构造方法内部进行赋值.满足第二条,所以可以注入final修饰的属性.将Bean对象更加简单地从Spring中取出来,有三种方式,分别为 属性注入, setter注入,构造方法注入。
Spring Bean常用依赖注入方式详解
08-18
Spring Bean依赖注入方式详解 Spring Bean依赖注入是Spring框架中的一种重要...构造器注入和Setter注入都是Spring依赖注入的重要方式，它们可以帮助开发者更好地管理对象之间的依赖关系，提高系统的灵活性和可维护性。
spring依赖注入底层详解
08-28
Spring依赖注入是Spring框架的核心特性之一，它极大地简化了Java应用程序的开发，使得对象之间的依赖关系得以解耦，提高了代码的可测试性和可维护性。本文将深入探讨Spring依赖注入的底层实现机制。 首先，我们要...
Spring quartz Job依赖注入使用详解
10-19
主要介绍了Spring quartz Job依赖注入使用详解的相关资料,Spring quartz Job不能依赖注入，Spring整合quartz Job任务不能注入Spring4整合quartz2.2.3中Job任务使用@Autowired不能注入，需要的朋友可以参考下
Spring依赖注入的三种方式实例详解
10-19
Spring依赖注入（Dependency Injection, DI）是Spring框架的核心特性之一，它允许我们解耦组件间的依赖关系，使得代码更加灵活和可测试。本篇将详细解释Spring中的三种依赖注入方式：接口注入、Setter方法注入和构造...
spring3.0依赖注入详解
03-05
基于spring3.0依赖注入详解，体验新特性。
【Spring（六）】彻底搞懂Spring的依赖注入
hihielite的博客
01-13 1169
在核心容器这一部分bean相关的操作，我们已经学完了，接下来我们就要进入到第二个大的模块，与我们的DI,也就是依赖注入相关知识的学习了，那我们先来学习第一个内容，依赖注入应该怎么去做，也就是依赖注入有哪些方式呢❓❓以上就是我们依赖注入的全部内容，最后，如果有什么错误的话，大家可以私信我📬📬，！！
spring——依赖注入原理及注入方式
yangqiqi1997的博客
05-17 3815
总结来说，依赖注入的原理是通过将对象的依赖关系由外部容器来管理和注入，从而解耦组件之间的依赖关系，提高代码的灵活性、可维护性和可测试性。是通过在对象的构造函数、属性或方法中注入所依赖的对象，而不是在对象内部创建或获取依赖对象。这样，对象的依赖关系由外部容器来管理，对象只需要关注自身的核心功能，而不需要关心如何获取依赖对象。（6）使用目标对象：完成依赖注入后，可以通过目标对象的其他方法或属性来使用注入的依赖对象。🟠（1）定义对象的依赖属性：在目标对象中定义一个或多个私有属性，用于存储依赖对象的引用。
Spring源码剖析——依赖注入实现原理
weixin_38367817的博客
06-16 1109
文章目录引言依赖注入介绍源码剖析getBean触发的依赖注入getBean方法doGetBean方法创建完整Bean的流程creaBean方法doCreateBean方法createBeanInstance方法instantiateBean依赖关系的处理populateBean方法applyPropertyValues方法resolveValueIfNecessary方法setPropertyValue方法 引言 在之前的 Spring源码剖析——核心IOC容器原理这篇文章中，已经详细介绍了在Spring当
JavaSpring框架常用依赖
weixin_61263533的博客
03-25 179
自用
spring注入原理
心态决定一切
05-19 480
      IOC（Inverse of Control）可翻译为“控制反转”，但大多数人都习惯将它称为“依赖注入”。在Spring中，通过IOC可以将实现类 、参数信息等配置在其对应的配置文件中 ，那么当需要更改实现类或参数信息时，只需要修改配置文件即可，这种方法在上例的基础上更进一步的降低了类与类之间的耦合。我们还可以对某对象所需要的其它对象进行注入 ，这种注入都是在配置文件中做的，Sprin...
Spring 依赖注入
weixin_46356818的博客
02-02 485
文章目录1、java注解2、Spring Bean3、Spring Resource4、Spring Bean的生命周期 1、java注解 2、Spring Bean 3、Spring Resource 4、Spring Bean的生命周期
spring依赖注入详解
03-12
作为一个 AI，我可以回答你关于 Spring 依赖注入的问题。Spring 依赖注入是一种设计模式，它通过将对象之间的依赖关系从代码中移除，使得代码更加灵活、可维护和可测试。Spring 通过使用反射和配置文件来实现依赖...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值