SpringIOC随笔（六）-依赖注入（DI）

已于 2022-06-13 12:11:40 修改
阅读量117 收藏
点赞数
分类专栏： Spring 文章标签： spring springIOC SpringDI
于 2020-10-20 19:28:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37872792/article/details/109187428
版权

SpringIOC随笔（六）-依赖注入（DI）

  • DI(Dependency Injection)

  • 概念：对象之间的关系的装配交给容器来管理。

  • 注入的方式：

    1. 构造注入：

      1. 顾名思义，构造注入就是使用构造方法注入，所以使用构造注入肯定要写对应的构造方法。下面直接上例子：

      2.  public class User implements Serializable {
    private static final long serialVersionUID = 84601116866236075L;

    private String username;
    private String password;
    private Department department;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public User(String username, String password, Department department) {
        this.username = username;
        this.password = password;
        this.department = department;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", department=" + department +
                '}';
    }
}
public class Department implements Serializable {
    private static final long serialVersionUID = -7390074405145933835L;

    private Integer id;

    private String departmentName;

    private String address;

    public Department() {
    }

    public Department(Integer id, String departmentName, String address) {
        this.id = id;
        this.departmentName = departmentName;
        this.address = address;
    }

    public Integer getId() {
        return id;
    }

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

    public String getDepartmentName() {
        return departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Department{" +
                "id=" + id +
                ", departmentName='" + departmentName + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

      3. <?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">

    <bean id="user" class="com.fxyh.spring.di.User">
        <constructor-arg index="0" value="zhangsan"/>
        <constructor-arg index="1" value="123456"/>
        <!--ref方式-->
        <!--<constructor-arg index="2" ref="department"/>-->
        <constructor-arg index="2">
            <!--内部bean方式-->
            <bean class="com.fxyh.spring.di.Department">
                <constructor-arg index="0" value="2"/>
                <constructor-arg index="1" value="Ali"/>
                <constructor-arg index="2" value="hangzhou"/>
            </bean>
        </constructor-arg>
    </bean>

    <bean id="department" class="com.fxyh.spring.di.Department">
        <constructor-arg index="0" value="1"/>
        <constructor-arg index="1" value="Baidu"/>
        <constructor-arg index="2" value="shengzhen"/>
    </bean>

</beans>

      4. @ContextConfiguration("classpath*:applicationContext-di.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class UserTest {

    @Autowired
    private User user;

    @Test
    public void test() {
        System.out.println(this.user);
    }
}

      5. 这里使用的是Spring-test，然后省去了很多代码。

        • <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>4.3.21.RELEASE</version>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

    2. setter注入

      1. 使用setXxx方法注入的方式，这里不提了。

    3. 集合注入

      1. array，list，set，map，properties注入。

      2. <bean id="collectionDemo" class="com.fxyh.spring.di.CollectionDemo">
        <property name="arrayValue">
            <array>
                <value>zhangsan</value>
                <value>lisi</value>
                <value>wangwu</value>
            </array>
        </property>
        <property name="listValue">
            <list>
                <value>beijin</value>
                <value>shanghai</value>
                <value>hangzhou</value>
                <value>shenzhen</value>
            </list>
        </property>
        <property name="setValue">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
                <value>ddd</value>
            </set>
        </property>
        <property name="mapValue">
            <map>
                <entry key="key1" value="111"/>
                <entry key="key2" value="222"/>
                <entry key="key3" value="333"/>
                <entry key="key4" value="444"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="driverClassName">com.mysql.jdbc.Driver</prop>
                <prop key="url">jdbc:mysql:///fxyh</prop>
                <prop key="username">root</prop>
                <prop key="password">root</prop>
            </props>
        </property>
    </bean>

      3. public class CollectionDemo implements Serializable {
    private static final long serialVersionUID = -4477381744799533624L;

    private String[] arrayValue;
    private List<String> listValue;
    private Set<String> setValue;
    private Map<String, Object> mapValue;
    private Properties properties;

    public String[] getArrayValue() {
        return arrayValue;
    }

    public void setArrayValue(String[] arrayValue) {
        this.arrayValue = arrayValue;
    }

    public List<String> getListValue() {
        return listValue;
    }

    public void setListValue(List<String> listValue) {
        this.listValue = listValue;
    }

    public Set<String> getSetValue() {
        return setValue;
    }

    public void setSetValue(Set<String> setValue) {
        this.setValue = setValue;
    }

    public Map<String, Object> getMapValue() {
        return mapValue;
    }

    public void setMapValue(Map<String, Object> mapValue) {
        this.mapValue = mapValue;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "CollectionDemo{" +
                "arrayValue=" + Arrays.toString(arrayValue) +
                ", listValue=" + listValue +
                ", setValue=" + setValue +
                ", mapValue=" + mapValue +
                ", properties=" + properties +
                '}';
    }
}

    4. 抽象Bean

      1. 把公共的东西抽象出来，然后需要用到的使用parent。

      2. <bean id="abstractDemo" abstract="true">
  <property name="id" value="1"/>
  <property name="username" value="zhangsan"/>
</bean>
<bean id="abstractDemo1" class="com.fxyh.spring.di.AbstractDemo1" parent="abstractDemo">
  <property name="password" value="123456"/>
</bean>
<bean id="abstractDemo2" class="com.fxyh.spring.di.AbstractDemo2" parent="abstractDemo">
  <property name="age" value="22"/>
</bean>
<bean id="abstractDemo3" class="com.fxyh.spring.di.AbstractDemo3" parent="abstractDemo">
  <property name="address" value="jiangxi"/>
  <property name="id" value="2"/>
</bean>

      3. 这里abstractDemo是抽象Bean，然后使用parent对应这个则对应的属性就会被赋值，并且在自己的bean中重新给这个属性赋值了，那么这个属性将会把抽象bean中的属性的值给覆盖掉。

    5. 自定义属性编辑器

      1. no matching editors or conversion strategy found

      2. 比如我注入的时候注入时间，我直接写字符串的时间，然后这肯定是会报错的，就上面说的那个错误，无法注入。

      3. 所以我们需要自定义属性编辑器。

      4. import org.apache.commons.lang3.time.DateUtils;

import java.beans.PropertyEditorSupport;
import java.text.ParseException;
import java.util.Date;

public class CustomDatePropertyEditor extends PropertyEditorSupport {
    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        Date date = null;
        try {
            date = DateUtils.parseDate(text, "yyyy-MM-dd");
        } catch (ParseException e) {
            e.printStackTrace();
        }

        this.setValue(date);
    }
}

      5. <bean id="person" class="com.fxyh.spring.di.Person">
        <property name="id" value="1"/>
        <property name="username" value="zhangsan"/>
        <property name="salary" value="#{10*new java.util.Random().nextInt(10)}"/>
        <property name="createDate" value="2019-06-30"/>
    </bean>

    <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer">
        <property name="customEditors">
            <map>
                <entry key="java.util.Date" value="com.fxyh.spring.di.CustomDatePropertyEditor"/>
            </map>
        </property>
    </bean>

      6. 自定义属性编辑器我们需要继承PropertyEditorSupport类，然后重写它的setAsText方法。现在已经不推荐使用了，推荐使用自定义转换器。

    6. 自定义转换器

      1. 实现Converter接口，注意：org.springframework.core.convert.converter.Converter包路径。

      2. 然后实现convert方法，在里面写对应的逻辑。

      3. import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.util.Date;

public class CustomDateConverter implements Converter<String, Date> {

    private String[] parsePatterns;

    public void setParsePatterns(String[] parsePatterns) {
        this.parsePatterns = parsePatterns;
    }

    @Override
    public Date convert(String source) {
        Date date = null;
        if (StringUtils.isBlank(source)){
            throw new IllegalArgumentException("");
        }
        try {
            date = DateUtils.parseDate(source, this.parsePatterns);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

      4. <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.fxyh.spring.di.CustomDateConverter">
                    <property name="parsePatterns">
                        <array>
                            <value>yyyy-MM-dd</value>
                            <value>yyyy/MM/dd</value>
                        </array>
                    </property>
                </bean>
            </set>
        </property>
    </bean>

      5. 这里注意这个转换器bean的id，我用其他的试都是没用，只有把id改成conversionService才能使用。

  • ByName&ByType

    • ByName：根据名称匹配

    • ByType：根据类型匹配

    • 这里有个比较经典的异常Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.fxyh.spring.dao.UserDao' available: expected single matching bean but found 2: userDao111111,userDao

    • 这个接口有两个实现类，然后现在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 http://www.springframework.org/schema/beans/spring-beans.xsd"
       default-autowire="byType">

    <bean id="userService" class="com.fxyh.spring.service.impl.UserServiceImpl" autowire="byName"/>

    <bean id="userDao111111" class="com.fxyh.spring.dao.impl.UserDaoMyBatisImpl"/>
    <bean id="userDao" class="com.fxyh.spring.dao.impl.UserDaoHibernateImpl"/>
</beans>

    • 这里在beans上使用了default-autowire为byType，所以这个beans下的bean都会根据类型自动注入，而此时有userDao和userDao111111都是实现了UserDao接口，所以两个都符合要求，然后bean就不知道要注入哪一个了，而这里我们又在userService配置了autowire为byName，此时userService是根据名称来匹配的，则只有userDao一个匹配成功。（这里提供setter方法，然后把setter方法set去掉，然后第一个字母小写，就是名称）

    • 同时在配置中局部配置优先于全局配置！

  • 注解编程

    • @Autowired

      • 属于Spring框架的注解
      • 先按类型匹配，如果匹配不到再按名称匹配

    • @Resource

      • 属于JavaEE规范的注解
      • 先按名称匹配，如果匹配不到再按类型匹配

    • @Qualifier

      • 和@Autowired结合使用的时候，按照名称匹配，不按类型匹配。
      • @Resource原本就是按名称所以在它按名称找不到的时候，使用@Qualifier设置的名称匹配。

    • @Component

      • 把这个类注解为一个组件

    • @Repository

      • 数据库交互层使用的注解（Dao）

    • @Service

      • 服务层使用的注解

    • @Controller

      • 控制层使用的注解

    • @Configuration

      • 配置类注解

    • @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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- bean definitions here -->

  <!--<context:annotation-config/>-->
  <context:component-scan base-package="com.fxyh.spring"/>
</beans>

    • 这里不贴测试用例了，自己写写测试用例测一测就ok了。

StandByMeQuan
关注
专栏目录
SpringDI.rar
05-10
Spring依赖注入（DI）的例子，包括接口注入、构造注入、set注入的简单类型和复杂类型注入的例子。
Spring(DI)
xasasaa的博客
03-20 1240
DI（Dependency Injection）即依赖注入，对象之间的依赖由容器在运行期决定，即容器动态的将某个依赖注入到对象自重 基于XML配置注入依赖 有参构造函数注入依赖 bean类实现有参构造函数 public class Student { private Integer id; private String name; /** * 有参构造函数 */ public Student(Integer id, String name) {
SpringDI详解
最新发布
vV_Leon的博客
08-19 868
前面我们已经完成了bean相关操作的讲解，接下来就进入第二个大的模块`DI依赖注入`，首先来介绍下Spring中有哪些注入方式?
spring di
CherishL_的专栏
03-09 410
di dependency injection 依赖注入is a,是一个，继承 has a，有一个，成员变量，依赖 依赖，一个对象需要另一个对象 注入，通过setter方法进行另一个对象实例设置class B{ private A a;//B依赖A类 }class BookServiceImpl{ //之前开发：接口 = 实现类 （service和dao耦合）
spring DI
simatongming的博客
03-19 240
1.DI:依赖注入，给类的属性设置值，依赖注入不能单独存在，要在IOC的基础上 2.spring支持set注入和有参构造注入两种属性注入 3.DI的使用 1）有参构造注入 例子：创建的类：public class MyTestBean { private String name; public MyTestBean(String name) {
Spring DI
RXiaoYao0412的博客
09-10 95
IOC(DI) - 控制反转(依赖注入) 所谓的IOC称之为控制反转，简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不再需要关注对象的创建和生命周期的管理，而是在需要时由Spring框架提供，这个由spring框架管理对象创建和生命周期的机制称之为控制反转。而在 创建对象的过程中Spring可以依据配置对对象的属性进行设置，这个过称之为依赖注入,也即DI。 基于set方法注入 通常的javabean属性都会私有化，而对外暴露setXxx()getXxx(
Spring5 框架 ---- IOC容器 ---- 代码
09-10
Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- ...
Spring-IoC-DI-main
02-11
标题“Spring-IoC-DI-main”提示我们讨论的核心是Spring框架中的两个核心特性：控制反转（Inversion of Control, IoC）和依赖注入（Dependency Injection, DI）。这两个概念是Java开发中的重要基石，尤其在构建大型...
10-IoC配置-依赖注入概念（DI）
04-25
我相信很多朋友学习IOC概念的时候，查找了很多资料结果还是一头雾水，感觉高深难懂或者一知半解，而我这篇博客就是以通俗易懂的话语，用故事的方式，讲解IOC(控制反转)和DI(依赖注入)的概念，让大家不再晕，不再觉得...
浅谈Spring IoC容器的依赖注入原理
08-27
浅谈Spring IoC容器的依赖注入原理 Spring IoC容器的依赖注入原理是Spring框架的核心机制之一，负责将服务对象（Bean）实例化并将其提供给客户端使用。依赖注入原理可以分为两个阶段：IoC容器初始化和Bean实例化。 ...
spring-demo02-IOC-DI案例.zip
08-07
在这个名为“spring-demo02-IOC-DI案例”的压缩包中，我们将深入探讨这两个核心概念以及如何在实际项目中应用它们。 首先，让我们来理解什么是IOC，即控制反转。在传统的编程模式中，对象通常自行创建或管理其依赖...
Spring DI
zuozhiyoulaisam的专栏
02-20 326
参考文章:http://sishuok.com/forum/blogPost/list/2454.html#7084 Spring DI: 1.Bean属性: lazy-init(延迟初始化Bean): 延迟初始化也叫惰性初始化,并不提前初始化Bean,而是只有真正使用时才创建及初始化Bean 容器每个Bean只有一个实例 配置文件:lazy-init="true" 默认为fal
Spring-DI
aj
10-04 151
依赖注入(DI)，是spring容器实现的基础，在spring-core模块中实现的。所谓DI，就是指对象是被动接受依赖类而不是自己主动去找，换句话说就是指对象不是从容器中查找它依赖的类，而是在容器实例化对象的时候主动将它依赖的类注入给它。下面举一个形象的例子： class B{ private A a; public void setA(A a){ this.a=...
springDi
09-10 386
DI的定义：给配置文件中的bean对象赋值。方式：一种是利用其属性的setter方法，另外一种是利用构造函数 我们先来讨论第一种：利用属性的setter方法赋值：首先，先创建好类，并且配置到配置文件中：public class Person implements Serializable { //基本类型 private Long pid; //String pri
spring的DI
玩垃圾的人
12-05 707
前言 技术分析之依赖注入（DI） 1. IOC和DI的概念 * IOC -- Inverse of Control，控制反转，将对象的创建权反转给Spring！！ * DI -- Dependency Injection，依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中！！ 2. DI（依赖注入）
springDI
miracle
02-08 491
二.DI 1.spring的依赖注入方式 有三种方式： 1.使用构造函数注入 2.使用set方法注入 3.使用注解注入 2.注入的数据类型 有三类： 1.基本类型和String类型 2.其他bean类型(必须是在spring的配置文件中出现过的bean) 3.复杂类型(集合类型) eg 构造方法 + 基本类型注入 涉及的标签：constructor-arg 标签的属性： type：指定参数的类...
SpringDI
Kevin Huang的专栏
06-15 802
DI也就是依赖注入。在传统的程序设计过程中，调用者需要直接使用new关键字创建被调用者的实例，调用者和被调用者之间的耦合度很高，要由调用者亲自创建被调用者的实例对象，这样不利于软件的移植与维护。但在Spring中创建被调用者的工作不再由调用者来完成，SpringIOC容器系统运行时会动态的向某个对象提供它所需要的其他对象，不像以前需要new一个出来。那么如何提供呢？Spring的DI依赖注入实现了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值