关于java:Java开发学习六DI依赖注入之setter及构造器注入解析

一、DI 依赖注入
首先来介绍下 Spring 中有哪些注入形式?

咱们先来思考

向一个类中传递数据的形式有几种?

一般办法(set 办法)

构造方法

依赖注入形容了在容器中建设 bean 与 bean 之间的依赖关系的过程，如果 bean 运行须要的是数字或字符串呢?

援用类型

简略类型(根本数据类型与 String)

Spring 就是基于下面这些知识点，为咱们提供了两种注入形式，别离是:

setter 注入

简略类型

援用类型

结构器注入

简略类型

援用类型

依赖注入的形式曾经介绍完，接下来挨个看下:

二、setter 注入
对于 setter 形式注入援用类型的形式之前曾经介绍过，简略看下:

在 bean 中定义援用类型属性，并提供可拜访的 set 办法

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}
}

配置中应用 property 标签 ref 属性注入援用类型对象

<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <property name="bookDao" ref="bookDao"/>
</bean>
​
<bean id="bookDao" class="com.itheima.dao.imipl.BookDaoImpl"/>

2.1 环境筹备
环境筹备:

创立一个 Maven 我的项目

pom.xml 增加依赖

resources 下增加 spring 的配置文件

最终我的项目的构造如下:

(1)我的项目中增加 BookDao、BookDaoImpl、UserDao、UserDaoImpl、BookService 和 BookServiceImpl 类

public interface BookDao {public void save();
}
​
public class BookDaoImpl implements BookDao {public void save() {System.out.println("book dao save ...");
    }
}
public interface UserDao {public void save();
}
public class UserDaoImpl implements UserDao {public void save() {System.out.println("user dao save ...");
    }
}
​
public interface BookService {public void save();
}
​
public class BookServiceImpl implements BookService{
    private BookDao bookDao;
​
    public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}
​
    public void save() {System.out.println("book service save ...");
        bookDao.save();}
}

(2)resources 下提供 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">
​
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

(3)编写 AppForDISet 运行类，加载 Spring 的 IOC 容器，并从中获取对应的 bean 对象

public class AppForDISet {public static void main( String[] args ) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();}
}

2.2 注入援用数据类型

需要: 在 bookServiceImpl 对象中注入 userDao

1. 在 BookServiceImpl 中申明 userDao 属性

2. 为 userDao 属性提供 setter 办法

3. 在配置文件中应用 property 标签注入

步骤 1: 申明属性并提供 setter 办法
在 BookServiceImpl 中申明 userDao 属性，并提供 setter 办法

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private UserDao userDao;
    
    public void setUserDao(UserDao userDao) {this.userDao = userDao;}
    public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}
​
    public void save() {System.out.println("book service save ...");
        bookDao.save();
        userDao.save();}
}

步骤 2: 配置文件中进行注入配置
在 applicationContext.xml 配置文件中应用 property 标签注入

<?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="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

步骤 3: 运行程序
运行 AppForDISet 类，查看后果，阐明 userDao 曾经胜利注入。

2.3 注入简略数据类型
需要：给 BookDaoImpl 注入一些简略数据类型的数据

参考援用数据类型的注入，咱们能够推出具体的步骤为:

1. 在 BookDaoImpl 类中申明对应的简略数据类型的属性

2. 为这些属性提供对应的 setter 办法

3. 在 applicationContext.xml 中配置

思考:

援用类型应用的是 <property name=”” ref=””/>, 简略数据类型还是应用 ref 么?

ref 是指向 Spring 的 IOC 容器中的另一个 bean 对象的，对于简略数据类型，没有对应的 bean 对象，该如何配置?

步骤 1: 申明属性并提供 setter 办法
在 BookDaoImpl 类中申明对应的简略数据类型的属性, 并提供对应的 setter 办法

public class BookDaoImpl implements BookDao {
​
    private String databaseName;
    private int connectionNum;
​
    public void setConnectionNum(int connectionNum) {this.connectionNum = connectionNum;}
​
    public void setDatabaseName(String databaseName) {this.databaseName = databaseName;}
​
    public void save() {System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

步骤 2: 配置文件中进行注入配置
在 applicationContext.xml 配置文件中应用 property 标签注入

<?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="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <property name="databaseName" value="mysql"/>
        <property name="connectionNum" value="10"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

阐明:

value: 前面跟的是简略数据类型，对于参数类型，Spring 在注入的时候会主动转换，然而不能写成

<property name="connectionNum" value="abc"/>

这样的话，spring 在将 abc 转换成 int 类型的时候就会报错。

步骤 3: 运行程序
运行 AppForDISet 类，查看后果，阐明 userDao 曾经胜利注入。

留神: 两个 property 注入标签的程序能够任意。

对于 setter 注入形式的根本应用就曾经介绍完了，

对于援用数据类型应用的是 <property name=”” ref=””/>

对于简略数据类型应用的是 <property name=”” value=””/>

三、结构器注入
3.1 环境筹备
结构器注入也就是构造方法注入，还是先筹备下环境:

创立一个 Maven 我的项目

pom.xml 增加依赖

resources 下增加 spring 的配置文件

这些步骤和后面的都统一，大家能够疾速的拷贝即可，最终我的项目的构造如下:

(1)我的项目中增加 BookDao、BookDaoImpl、UserDao、UserDaoImpl、BookService 和 BookServiceImpl 类

public interface BookDao {public void save();
}
​
public class BookDaoImpl implements BookDao {
    
    private String databaseName;
    private int connectionNum;
    
    public void save() {System.out.println("book dao save ...");
    }
}
public interface UserDao {public void save();
}
public class UserDaoImpl implements UserDao {public void save() {System.out.println("user dao save ...");
    }
}
​
public interface BookService {public void save();
}
​
public class BookServiceImpl implements BookService{
    private BookDao bookDao;
​
    public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}
​
    public void save() {System.out.println("book service save ...");
        bookDao.save();}
}

(2)resources 下提供 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">
​
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

(3)编写 AppForDIConstructor 运行类，加载 Spring 的 IOC 容器，并从中获取对应的 bean 对象

public class AppForDIConstructor {public static void main( String[] args ) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();}
}

3.2 结构器注入援用数据类型
接下来，在下面这个环境中来实现结构器注入:

需要：将 BookServiceImpl 类中的 bookDao 批改成应用结构器的形式注入。

1. 将 bookDao 的 setter 办法删除掉

2. 增加带有 bookDao 参数的构造方法

3. 在 applicationContext.xml 中配置

步骤 1: 删除 setter 办法并提供构造方法
在 BookServiceImpl 类中将 bookDao 的 setter 办法删除掉, 并增加带有 bookDao 参数的构造方法

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
​
    public BookServiceImpl(BookDao bookDao) {this.bookDao = bookDao;}
​
    public void save() {System.out.println("book service save ...");
        bookDao.save();}
}

步骤 2: 配置文件中进行配置结构形式注入
在 applicationContext.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">
​
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>
</beans>

阐明:

标签 <constructor-arg> 中

name 属性对应的值为构造函数中办法形参的参数名，必须要保持一致。

ref 属性指向的是 spring 的 IOC 容器中其余 bean 对象。

步骤 3：运行程序
运行 AppForDIConstructor 类，查看后果，阐明 bookDao 曾经胜利注入。

3.3 结构器注入多个援用数据类型
需要: 在 BookServiceImpl 应用构造函数注入多个援用数据类型，比方 userDao

1. 申明 userDao 属性

2. 生成一个带有 bookDao 和 userDao 参数的构造函数

3. 在 applicationContext.xml 中配置注入

步骤 1: 提供多个属性的构造函数
在 BookServiceImpl 申明 userDao 并提供多个参数的构造函数

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private UserDao userDao;
​
    public BookServiceImpl(BookDao bookDao,UserDao userDao) {
        this.bookDao = bookDao;
        this.userDao = userDao;
    }
​
    public void save() {System.out.println("book service save ...");
        bookDao.save();
        userDao.save();}
}

步骤 2: 配置文件中配置多参数注入
在 applicationContext.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">
​
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
</beans>

阐明: 这两个 <contructor-arg> 的配置程序能够任意

步骤 3: 运行程序
运行 AppForDIConstructor 类，查看后果，阐明 userDao 曾经胜利注入。

3.4 结构器注入多个简略数据类型
需要: 在 BookDaoImpl 中，应用构造函数注入 databaseName 和 connectionNum 两个参数。

参考援用数据类型的注入，咱们能够推出具体的步骤为:

1. 提供一个蕴含这两个参数的构造方法

2. 在 applicationContext.xml 中进行注入配置

步骤 1: 增加多个简略属性并提供构造方法
批改 BookDaoImpl 类，增加构造方法

public class BookDaoImpl implements BookDao {
    private String databaseName;
    private int connectionNum;
​
    public BookDaoImpl(String databaseName, int connectionNum) {
        this.databaseName = databaseName;
        this.connectionNum = connectionNum;
    }
​
    public void save() {System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

步骤 2: 配置实现多个属性结构器注入
在 applicationContext.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">
​
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg name="databaseName" value="mysql"/>
        <constructor-arg name="connectionNum" value="666"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
</beans>

阐明: 这两个 <contructor-arg> 的配置程序能够任意

步骤 3: 运行程序
运行 AppForDIConstructor 类，查看后果

下面曾经实现了构造函数注入的根本应用，然而会存在一些问题:

当构造函数中办法的参数名发生变化后，配置文件中的 name 属性也须要跟着变，因为是形参的名字。

这两块存在紧耦合，具体该如何解决?

在解决这个问题之前，须要提前阐明的是，这个参数名发生变化的状况并不多，所以下面的还是比拟支流的配置形式，上面介绍的，大家都以理解为主。

形式一: 删除 name 属性，增加 type 属性，依照类型注入

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <constructor-arg type="int" value="10"/>
    <constructor-arg type="java.lang.String" value="mysql"/>
</bean>

这种形式能够解决构造函数形参名发生变化带来的耦合问题

然而如果构造方法参数中有类型雷同的参数，这种形式就不太好实现了

形式二: 删除 type 属性，增加 index 属性，依照索引下标注入，下标从 0 开始

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <constructor-arg index="1" value="100"/>
    <constructor-arg index="0" value="mysql"/>
</bean>

这种形式能够解决参数类型反复问题

然而如果构造方法参数程序发生变化后，这种形式又带来了耦合问题

介绍完两种参数的注入形式，具体咱们该如何抉择呢?

强制依赖应用结构器进行，应用 setter 注入有概率不进行注入导致 null 对象呈现

强制依赖指对象在创立的过程中必须要注入指定的参数

可选依赖应用 setter 注入进行，灵活性强

可选依赖指对象在创立过程中注入的参数可有可无

Spring 框架提倡应用结构器，第三方框架外部大多数采纳结构器注入的模式进行数据初始化，绝对谨严

如果有必要能够两者同时应用，应用结构器注入实现强制依赖的注入，应用 setter 注入实现可选依赖的注入

理论开发过程中还要依据理论状况剖析，如果受控对象没有提供 setter 办法就必须应用结构器注入

本人开发的模块举荐应用 setter 注入

四、总结
这里次要讲的是 Spring 的依赖注入的实现形式:

setter 注入

简略数据类型

<bean ...>
    <property name=""value=""/>
</bean>

援用数据类型

<bean ...>
    <property name=""ref=""/>
</bean>

结构器注入

简略数据类型

<bean ...>
    <constructor-arg name=""index="" type=""value=""/>
</bean>

援用数据类型

<bean ...>
    <constructor-arg name=""index="" type=""ref=""/>
</bean>

依赖注入的形式抉择上

倡议应用 setter 注入

第三方技术依据状况抉择

如果您感觉浏览本文对您有帮忙，请点一下“举荐”按钮，您的“举荐”将是我最大的写作能源！欢送各位转载，然而未经作者自己批准，转载文章之后必须在文章页面显著地位给出作者和原文连贯，否则保留查究法律责任的权力。