目录
1、什么是依赖注入
DI (Dependency Injection):依赖注入是指在 Spring IOC 容器创建对象的过程中,将所依赖的对象通过配置进行注入。我们可以通过依赖注入的方式来降低对象间的耦合度。
在软件工程中,对象之间的耦合度就是对象之间的依赖性。对象之间的耦合越高,维护成本越高,因此对象的设计应使对象之间的耦合越小越好。
1.1类的关系
继承 实现 依赖 关联 聚合 组合
1.1.1 依赖关系(Dependency)
【依赖关系】:是一种使用的关系
,
即一个类的实现需要另一个类的协助
, 所以要尽量不使用双向的互相依赖
【代码表现】:局部变量、方法的参数或者对静态方法的调用
【箭头及指向】:带箭头的虚线,指向被使用者
1.1.2 聚合(Aggregation)
【聚合关系】:是整体与部分的关系
.
如车和轮胎是整体和部分的关系.聚合关系是关联关系的一种,是强的关联关系;关联和聚合在语法上无法区分, 必须考察具体的逻辑关系。
【代码体现】:成员变量
【箭头及指向】:带空心菱形的实心线,菱形指向整体
1.2关系强度
继承 = 实现 > 组合 > 聚合 > 关联 > 依赖
2 为什么使用依赖注入
2.1开闭原则
2.1.1 定义
OCP (Open Close Principle): 软件本身应该是可扩展的,而不可修改的。也就是,对扩展开放,对修改封闭的。
2.1.2 开闭原则优点
- 易扩展。开闭原则的定义就要求对扩展开放。
- 易维护。软件开发中,对现有代码的修改是一件很有风险的事情,符合开闭原则的设计
- 在扩展时无需修改现有代码,规避了这个风险,大大提交了可维护性。
2.2高内聚,低耦合
高内聚是指相关度比较高的部分尽可能的集中,不要分散。
低耦合就是说两个相关的模块尽可以能把依赖的部分降低到最小,不要产生强依赖。
3 依赖注入的方式
在使用依赖注入时,如果注入的是
Bean
对象,那么要求注入的
Bean 对象与被注入的 Bean
对象都需要
Spring IOC
容器来实例化。
依赖注入的方式有通过set方式注入、通过构造方法注入、自动注入。
持久层的代码比较少,后面的多个注入方式比较多,持久层代码就不重复写,后面的set注入方式、构造方法注入方式、自动注入方式的所有的持久层代码都使用下面的这一个。
持久层userDao接口
public interface UserDao {
void InitUserDao();
}
持久层userDaoIml实现
public class UserDaoImpl implements UserDao {
@Override
public void InitUserDao() {
System.out.println("InitUserDao......");
}
}
3.1通过 Set 方法注入
持久层的UserDao使用上面的内容。
业务层UserService接口
public interface UserService {
public void addUser();
}
业务层UserServiceImpl实现
使用set方法进行依赖注入的时候必须给需要注入的对象创建set方法
public class UserServiceImpl implements UserService {
private UserDao userDao;
//使用set方法实现依赖注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void addUser() {
userDao.InitUserDao();
System.out.println("UserService........addUser");
}
}
配置文件(配置UserServiceImpl对象)
<?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">
<!--配置UserServiceImpl对象-->
<!--bean中的name属性可以有多个值,多个值可以使用逗号分隔开.(name属性不是必须的)-->
<bean id="userService" name="name1,name2,name3" class="com.xjx.service.impl.UserServiceImpl"/>
</beans>
测试依赖注入(测试UserDao是否注入成功)
public class UserServiceTest {
public static void main(String[] args) {
//启动IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//从容器中获取 userService对象 使用getBean("");来获取容器中存在的对象
//在IOC容器中除了可以用bean的id来获取对象还可以使用bean的name属性来获取对象
//(1)可以通过bean的id属性值来获取IOC容器中的对象
UserService userService = (UserService) applicationContext.getBean("userService");
userService.addUser();
//(2)可以通过bean的name属性值来获取IOC容器中的对象
UserService name1 = (UserService) applicationContext.getBean("name1");
System.out.println("调用name1");
name1.addUser();
UserService name2 = (UserService) applicationContext.getBean("name2");
System.out.println("调用name2");
name2.addUser();
UserService name3 = (UserService) applicationContext.getBean("name3");
System.out.println("调用name3");
name3.addUser();
}
}
3.2通过构造方法注入
持久层
使用构造方法进行注入的时候Bean对象必须有一个带参的构造方法
public class UserServiceImpl implements UserService {
private UserDao userDao;
//使用构造方法实现依赖注入
public UserServiceImpl(UserDao userDao){
this.userDao = userDao;
}
@Override
public void addUser() {
userDao.InitUserDao();
System.out.println("UserService........addUser");
}
}
配置文件
使用构造方法进行注入的时候参数对象要使用 constructor-arg 一个constructor-arg注入一个参数
<!--通过 构造方法方法注入 (需要为注入的成员变量提供 Set 方法。)-->
<bean id="userDao2" class="com.xjx.dao.impl.UserDaoImpl"/>
<bean id="userService2" class="com.xjx.service.impl.UserServiceImpl">
<!--constructor-arg用来通过构造方法注入参数时使用,一个constructor-arg注入一个参数
构造方法中有几个需要注入的参数就需要几个constructor-arg
与构造方法中的参数进行匹配注入的时候使用name 或 index 或 type属性来进行指定参数注入-->
<!--name属性表示的是参数中要注入的参数名称(name:根据参数名称识别参数)-->
<constructor-arg name="userDao">
<ref bean="userDao2"/>
</constructor-arg>
<!--(index:根据参数位置识别参数)-->
<!--<constructor-arg index="0" ref="userDao2"/>-->
<!--(name:根据参数类型识别参数)-->
<!--<constructor-arg type="com.xjx.dao.UserDao" ref="userDao2"/>-->
</bean>
测试构造方法注入
public class UserServiceTest {
public static void main(String[] args) {
//启动IOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//从容器中获取 userService对象 使用getBean("");来获取容器中存在的对象
UserService userService = (UserService) applicationContext.getBean("userService");
userService.addUser();
}
}
3.3自动注入
自动注入的方式有两种,一种是全局配置自动注入,另一种是局部配置自动注入。 无论全局配置或局部单独配置,都有
5 个值可以选择:no或byName或byType或 constructor或 default
局部自动注入 : 通过 bean 标签中的 autowier 属性配置自动注入。有效范围:仅针对当前 bean 标签生效。 全局自动注入 :通过 beans 标签中的 default-autowire 属性配置自动注入。有效范围:配置文件中的所有 bean 标签都生效。 no:当 autowire 设置为 no 的时候,Spring 就不会进行自动注入。 byName:在 Spring 容器中查找 id 与(需要注入的bean)属性名相同的 bean,并进行注入。需要提供 set 方 法。 byType:在 Spring 容器中查找类型与属性名的类型相同的 bean,并进行注入。需要提供 set 方法。 constructor:仍旧是使用 byName 方式,只不过注入的时候,使用构造方式进行注入。 default:全局配置的 default 相当于 no,局部的 default 表示使用全局配置设置。
局部自动注入
通过
bean
标签中的
autowier
属性配置自动注入。
<bean id="usersDaoMybatis" class="com.bjsxt.dao.impl.UsersDaoMybatisImpl"/>
<bean id="usersService" name="name1,name2,name3" class="com.bjsxt.service.impl.UsersServiceImpl" autowire="byType"> </bean>
全局自动注入(default-autowire="byName")
<?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="byName">
4 依赖注入的数据类型
依赖注入的数据类型: 1.注入bean对象 2.注入基本数据类型和字符串 3.注入list集合 4.注入Set集合 5.注入Map集合 6.注入properties
业务层userServiceImp实现
所有的Bean对象都需要set方法
public class UserServiceImpl implements UserService {
private UserDao userDao;
private String name;
private int age;
private List<String> list;
private Set<String> set;
private Set<Users> users;
private Map<String,String> map;
private Map<String,Users> mapUser;
private Properties properties;
//使用构造方法实现依赖注入
public UserServiceImpl(UserDao userDao){
this.userDao = userDao;
}
//使用set方法实现依赖注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setList(List<String> list) {
this.list = list;
}
public void setSet(Set<String> set) {
this.set = set;
}
public void setUsers(Set<Users> users) {
this.users = users;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public void setMapUser(Map<String, Users> mapUser) {
this.mapUser = mapUser;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
@Override
public void addUser() {
userDao.InitUserDao();
System.out.println("注入基本数据类型"+name+age);
System.out.println("注入list");
for (int i = 0 ; i <list.size(); i++){
System.out.println(list.get(i));
}
System.out.println("UserService........addUser");
}
}
配置文件
<!--
依赖注入的数据类型:
1.注入bean对象
2.注入基本数据类型和字符串
3.注入list集合
4.注入Set集合
5.注入Map集合
6.注入properties
-->
<bean id="userServiceData" class="com.xjx.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"/>
<!--注入的是基本数据类型或字符串的时候,注入的值不使用ref而是使用value来赋值-->
<property name="name" value="lance"/>
<property name="age" value="24"/>
<property name="list">
<list>
<value>javaSE</value>
<value>javaEE</value>
<!--如果list中注入的是IOC中的对象时不使用value而使用ref来向list中注入对象
例:向list中注入一个IOC容器中存在的id属性为userService对象
<ref>要注入的IOC中已经存在的对象id</ref>
如果list中注入的是IOC中不存在的对象时不使用value而使用bean创建对象来向list中注入对象
例:向list中注入一个UserDaoImpl对象(这个时候是可以不添加id属性的)
<bean class="com.xjx.dao.impl.UserDaoImpl"/>-->
</list>
</property>
<!--注入Set集合(Set集合为String类型)-->
<property name="set">
<set>
<value>lance</value>
<value>admin</value>
</set>
</property>
<!--注入Set集合(Set集合为引用数据类型Users对象)-->
<property name="users">
<set>
<bean class="com.xjx.pojo.Users">
<property name="name" value="admin"/>
<property name="age" value="18"/>
</bean>
</set>
</property>
<!--注入Map集合(Map集合value为String类型)-->
<property name="map">
<map>
<entry key="name" value="lance"/>
<entry key="age" value="24"/>
</map>
</property>
<!--注入Map集合(Map集合value为引用数据类型Users对象)-->
<property name="mapUser">
<map>
<entry key="user1" value-ref="user1"/><!--注入值是IOC容器中已经存在的对象-->
<entry key="user2"><!--注入的值不是IOC中存在的对象,需要用bean创建-->
<bean class="com.xjx.pojo.Users"/>
</entry>
</map>
</property>
<!--注入properties-->
<property name="properties">
<props>
<prop key="name">lance</prop>
<prop key="age">24</prop>
</props>
</property>
</bean>
<bean id="user1" class="com.xjx.pojo.Users"/>
<bean id="user2" class="com.xjx.pojo.Users"/>
测试依赖注入的数据类型:
/**依赖注入
* 在使用依赖注入时,如果注入的是 Bean 对象,
* 那么要求注入的 Bean 对象与被注入的 Bean 对象都需要 Spring IOC 容器来实例化。
* 注入方式:
* 1.使用set方式注入:需要为注入的成员变量提供 Set 方法。
* 2.使用构造方法注入:Bean 对象中需要提供有参的构造方法
*/
public class DependencyInjectionTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext_dependency_injection.xml");
UserService userService = (UserService) applicationContext.getBean("userServiceData");
userService.addUser();
}
}