Spring中的DI（依赖注入）使用详解

最新推荐文章于 2025-03-13 22:45:52 发布
最新推荐文章于 2025-03-13 22:45:52 发布
阅读量3.3k 收藏 4
点赞数 2
分类专栏： Spring 文章标签： spring java ioc 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxy144/article/details/110358170
版权

Spring中的DI（依赖注入）

什么时候需要依赖注入：

当一个被Spring管理的对象，存在另一个对象（依赖于另一个对象）时，就需要使用依赖注入，来完成对象之间的依赖关系

我们的程序在编写时，通过控制反转把对象创建的任务交给了Spring， 对象之间一定会有相互调用的情况，既然不使用new对象的方式，我们就只能让Spring来帮我们来完成这个操作。

依赖注入其实就是属性注入的一种特殊类型，不同点就是：

  • 属性注入的是String、int、List、Set、Array···这种参数，使用value
  • 而依赖注入注入的是一个Bean，是一个同样在Spring管理中的Bean，需要使用ref

我们需要为Spring容器提供所有bean的定义以及bean之间的依赖关系，那么进行依赖注入可以使用两种方式实现，XML文件配置或者注解。

使用XML配置文件方式

实现依赖注入一定要有一个入口，才能让Spring帮我们把对象注入进去

使用构造方法注入

简单的属性注入

/**
 * 准备一个普通的pojo类，里面的属性都没有初始化
 * 提供一个有参的构造方法，供Spring进行注入
 */
public class Student {
    private Integer id;
    private String name;
    private Double score;

    public Student(Integer id, String name, Double score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

    <!-- 1、通过构造方法中参数列表的参数位置进行注入值-->
<!--    <bean id="student" class="com.zxy.pojo.Student">-->
<!--        <constructor-arg index="0" value="1001"/>-->
<!--        <constructor-arg index="1" value="张三"/>-->
<!--        <constructor-arg index="2" value="99.9"/>-->
<!--    </bean>-->

    <!-- 2、通过构造方法参数的类型进行注入值-->
<!--    <bean id="student" class="com.zxy.pojo.Student">-->
<!--        <constructor-arg type="java.lang.Integer" value="1001"/>-->
<!--        <constructor-arg type="java.lang.String" value="张三"/>-->
<!--        <constructor-arg type="java.lang.Double" value="99.8"/>-->
<!--    </bean>-->

    <!-- 3、通过构造方法中参数列表的中参数名进行注入值  推荐使用这种写法-->
    <bean id="student" class="com.zxy.pojo.Student">
        <constructor-arg name="id" value="1001"/>
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="score" value="99.7"/>
    </bean>

依赖注入（Bean）

/**
 * 准备一个业务类，他需要调用dao层来完成数据的持久化操作
 * 准备一个构造方法，让Spring把dao对象注入进来
 */
public class UserServiceImpl implements IUserService {

    private IUserDao userDao;

    public UserServiceImpl(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}

	<!-- 准备一个userDao的对象，因为Service需要用到，将其注入进去-->
    <bean name="userDao" class="com.zxy.dao.impl.UserDaoImpl"/>
	<!-- 根据构造方法，创建Service时，就需要将userDao对象给它-->
    <bean name="userService" class="com.zxy.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>

使用set方法注入

简单的属性注入

/**
 * 为每个属性提供set方法，在xml文件中使用property标签进行赋值
 */
public class Student {
    private Integer id;
    private String name;
    private Double score;

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

    <bean name="student" class="com.zxy.pojo.Student">
        <property name="id" value="1001"/>
        <property name="name" value="张三"/>
        <property name="score" value="99.5"/>
    </bean>

依赖注入（Bean）

/**
 * 提供set方法
 */
public class UserServiceImpl implements IUserService {

    private IUserDao userDao;
    
    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}

    <!-- 使用property标签注入-->
	<bean name="userService" class="com.zxy.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

注入集合属性

/**
 * 准备一个类，其中它的属性分别有数组、list、set、map、properties
 * 我们将为这些集合注入值
 */
public class DataList {

    private String[] myArray;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProperties;

    public void setMyArray(String[] myArray) {
        this.myArray = myArray;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyProperties(Properties myProperties) {
        this.myProperties = myProperties;
    }

    @Override
    public String toString() {
        return "DataList{" +
                "myArray=" + Arrays.toString(myArray) +
                ", myList=" + myList +
                ", mySet=" + mySet +
                ", myMap=" + myMap +
                ", myProperties=" + myProperties +
                '}';
    }
}

    <bean name="dataList" class="com.zxy.pojo.DataList">
        <property name="myArray" >
            <array>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </array>
        </property>
        <property name="myList">
            <list>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </list>
        </property>
        <property name="mySet">
            <set>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </set>
        </property>
        <property name="myMap">
            <map>
                <entry key="姓名" value="张三"/>
                <entry key="性别" value="男"/>
                <entry key="年龄" value="20"/>
            </map>
        </property>
        <property name="myProperties">
            <props>
                <prop key="姓名">张三</prop>
                <prop key="性别">男</prop>
                <prop key="年龄">20</prop>
            </props>
        </property>
    </bean>

注意：

  • array、list、set这三个标签之间可以通用
  • 使用value可以直接赋值，也可以使用ref引入一个配置好的bean给集合
  • map标签下的子标签是entry标签，可以使用key和value属性直接赋值，也可以使用value-ref进行赋值

使用注解方式

我们将配置都使用注解写在这个类上，当Spring通过反射得到这个类时，就可以获得它上面的注解信息，根据注解信息判断这个类是否需要spring容器管理，如何实现实例化对象等，从而不需要读取XML文件进行解析了。

注解中有三种依赖注入的方式：构造方法、setter方法都和上面配置文件方式相似，还有一种直接给对应的对象进行依赖注入，没有使用构造方法和setter方法，那就是接口注入

注解说明：

@Autowired

  • 自动装配，将在Spring容器中管理的对应对象注入给该对象（自动装配时，先byType，然后byName）

@Qualifier(“id”)

  • 根据指定的id（对应bean标签的id属性）进行注入（byName），一个接口中有多个实现类，而且和byName不一致时使用

@Resource

  • JDK提供的注解，不能使用在构造方法上，此时类中也不要提供有参的构造方法，
  • 属性name：配置bean的id，属性type：配置类的class实例

注解中寻找Bean 的过程（自动装配），首先通过byType类型寻找相应的实现类，如果实现类有一个相匹配直接使用，如果该接口有两个实现类它会根据byName进行匹配实现类的类名，如果匹配则使用该实现类。如果两个实现类的类名都和byName不匹配就会报错没有找到实现类！

示例：

模拟dao：

@Component//表示这个类交给Spring管理
public class UserDaoImpl implements IUserDao {
    
    @Override
    public void save() {
        System.out.println("向数据库中添加一条用户信息");
    }
}

service（需要用到dao）:

@Service("userService")//指定id
public class UserServiceImpl implements IUserService {

    @Autowired//自动装配完成依赖注入
    private IUserDao userDao;

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}

beans.xml（入口还是使用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.zxy"/>
</beans>

测试：

    @Test
    public void test3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IUserService service = context.getBean("userService",IUserService.class);
        service.add();
    }

上面使用的是我们最常用的接口注入的方式，下面还有构造器注入和setter方法注入两种方式：

构造器注入：

@Service("userService")
public class UserServiceImpl implements IUserService {

    private IUserDao userDao;

    @Autowired//用在构造方法上
    public UserServiceImpl(IUserDao userDao){
        this.userDao=userDao;
    }

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}

set方法

@Service("userService")
public class UserServiceImpl implements IUserService {

    private IUserDao userDao;

    @Autowired//使用在set方法上
    @Resource(name = "userDaoImpl")//多加一个注解，指定去寻找Bean的name
    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void add() {
        System.out.println("处理业务，准备存储数据");
        //调用dao层完成持久化的操作
        userDao.save();
    }
}
【Spring框架】Spring中的DI介绍
Sampson_S的博客
06-18 5724
Spring中的DI介绍 DI（Dependency Injection），即“依赖注入”，组件之间依赖关系由容器在运行期决定，即容器动态的将某个依赖关系注入到组件当中。它是是 Spring 框架核心IOC技术的具体实现。 依赖注入是控制反转最常用的方式，通过控制反转可以减低计算机代码之间的耦合度。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。 DI理解的关键点“谁依赖谁，为什么需要依赖” 谁依赖谁：应用程序依赖IOC容器
Spring DI
qq_40811939的博客
10-16 783
1.DI-依赖注入   创建对象的过程中Spring可以依据配置对对象的属性 进行设置，这个过程称之为依赖注入，即DI 2.set方法注入   通常javabean的属性都会私有化，而对外暴露setXx()getXx()方法，此时spring可以通过这样的setXx()方法将属性的值注入对象。 1)spring内置的可直接注入类型的注入 在&lt;bean&gt;标签下添加&l...
Spring(DI)
xasasaa的博客
03-20 1329
DI（Dependency Injection）即依赖注入，对象之间的依赖由容器在运行期决定，即容器动态的将某个依赖注入到对象自重 基于XML配置注入依赖 有参构造函数注入依赖 bean类实现有参构造函数 public class Student { private Integer id; private String name; /** * 有参构造函数 */ public Student(Integer id, String name) {
Spring Ioc和DI（常用注解及释意）
最新发布
no_rt_h_se_v_en的博客
03-13 549
Spring IOC 和DI 及其各种常见注解及
spring的DI
玩垃圾的人
12-05 753
前言 技术分析之依赖注入（DI） 1. IOC和DI的概念 * IOC -- Inverse of Control，控制反转，将对象的创建权反转给Spring！！ * DI -- Dependency Injection，依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中！！ 2. DI（依赖注入）
springDi
09-10 420
DI的定义：给配置文件中的bean对象赋值。方式：一种是利用其属性的setter方法，另外一种是利用构造函数 我们先来讨论第一种：利用属性的setter方法赋值：首先，先创建好类，并且配置到配置文件中：public class Person implements Serializable { //基本类型 private Long pid; //String pri
Spring中的DI和AOP
z_x_1000的专栏
08-24 741
来源：http://blog.sina.com.cn/s/blog_51721d970100ak21.html Spring同Struts和Hibernate一样,也是一个轻量级框架。他使现在有的技术更加易用，来推进编码最佳 实践。他的主要内容有：依赖注入容器，AOP(声明式事务)，DAO/ORM，WEB集成等技术。 一:DI-->依赖注入 旨在解决复杂的软件系统。他引入了组件化的思想来解
springDI
miracle
02-08 522
二.DI 1.spring的依赖注入方式 有三种方式： 1.使用构造函数注入 2.使用set方法注入 3.使用注解注入 2.注入的数据类型 有三类： 1.基本类型和String类型 2.其他bean类型(必须是在spring的配置文件中出现过的bean) 3.复杂类型(集合类型) eg 构造方法 + 基本类型注入 涉及的标签：constructor-arg 标签的属性： type：指定参数的类...
Spring 依赖注入（DI）的注解
weixin_34248849的博客
05-25 96
Spring中想要使用注解进行依赖注入，需要进行如下配置： &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframewor...
Spring 之 DI 详解
岁月安然
05-30 2747
概念 DI(Dependency Injection)依赖注入：依赖注入是指在程序运行期间,由外部容器动态地将依赖对象注入到组件中如：一般，通过构造函数注入、Setter注入、注解注入。 Setter注入与注解注入类似，区别在于：Setter 注入是通过 Set 方法对属性进行赋值，而注解注入是通过反射为属性赋值。 时机 当 Spring IOC 容器完成了 Bean 定义资源的定位、载入、解析和注册以后，IOC 容器中已经管理类 BeanDefinition 的相关数据，但是此时 IOC 容器还没有对所管
Spring之DI
coderidea
08-26 1810
Spring是一个开源框架，Spring是为了解决企业级应用开发的复杂性而创建的，使用Spring可以让简单的JavaBean实现只有EJB才能完成的简单性。简单来说Spring最根本的使命：简化Java开发。Spring的目标是致力于全方位的简化Java开发。那么Spring是如何简化Java开发的呢？ 1. 基于POJO的轻量级和最小侵入性编程 2.通过依赖注入（DI）和面向接口实现松耦合......
spring di
CherishL_的专栏
03-09 444
di dependency injection 依赖注入is a,是一个，继承 has a，有一个，成员变量，依赖 依赖，一个对象需要另一个对象 注入，通过setter方法进行另一个对象实例设置class B{ private A a;//B依赖A类 }class BookServiceImpl{ //之前开发：接口 = 实现类 （service和dao耦合）
spring DI
simatongming的博客
03-19 271
1.DI:依赖注入，给类的属性设置值，依赖注入不能单独存在，要在IOC的基础上 2.spring支持set注入和有参构造注入两种属性注入 3.DI的使用 1）有参构造注入 例子：创建的类：public class MyTestBean { private String name; public MyTestBean(String name) {
Spring DI
RXiaoYao0412的博客
09-10 122
IOC(DI) - 控制反转(依赖注入) 所谓的IOC称之为控制反转，简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不再需要关注对象的创建和生命周期的管理，而是在需要时由Spring框架提供，这个由spring框架管理对象创建和生命周期的机制称之为控制反转。而在 创建对象的过程中Spring可以依据配置对对象的属性进行设置，这个过称之为依赖注入,也即DI。 基于set方法注入 通常的javabean属性都会私有化，而对外暴露setXxx()getXxx(
Spring-DI
aj
10-04 180
依赖注入(DI)，是spring容器实现的基础，在spring-core模块中实现的。所谓DI，就是指对象是被动接受依赖类而不是自己主动去找，换句话说就是指对象不是从容器中查找它依赖的类，而是在容器实例化对象的时候主动将它依赖的类注入给它。下面举一个形象的例子： class B{ private A a; public void setA(A a){ this.a=...
Spring中的 DI 原理及源码解析
一名Java语言狂热分子。
05-17 1578
Spring是一个强大的应用程序开发框架，它为企业应用程序提供了许多好处。其中一个主要特性就是IoC（控制反转）和DI（依赖注入）。本文将重点介绍Spring中的DI原理以及相关源码解析。依赖注入（Dependency Injection），简称DI，是指向对象实例的变量（即所依赖的对象）在程序运行过程中动态地被注入到对象中去。核心思想是：在程序运行时通过信息反转将某些依赖关系交给专门的容器去管理，在需要调用的时候由容器来主动地注入其依赖对象。Spring中的DI是将这个原理应用到实际编程中的一种方法。
Spring DI详解
热门推荐
qq_42603060的博客
01-23 1万+
1.IOC（DI）-控制反转（依赖注入） 所谓的IOC称之为控制反转，简单来说就是将对象 的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理,而是在需要的时候由Spring框架提供，这个由Spring框架管理对象创建和生命周期的机制称之为控制反转。而在创建对象的过程中Spring可以依据配置对象的属性进行设置，这个过程称之为依...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值