Spring控制反转与依赖注入(IOCDI)

Posted 2020-08-21 光何

IOC: 反转控制   Inverse Of Control     

DI:依赖注入 Dependency Injection

目的：完成程序的解耦合 

解释：在应用系统的开发过程中，有spring负责对象的创建，对象依赖关系的组装，对象属性的初始化，程序员只需要在程序接收spring创建的对象即可。

 Object obj= new Object();

IOC :  Object obj;  等着接收spring容器创建好的对象，在程序中将对象的创建的权限交出，反转到spring容器中。

DI:  某个对象需要依赖的其他对象，由spring容器完成所需要依赖对象的赋值

1 使用IOC完成三层结构的解耦合

1.1 搭建三层结构

建立Dao层接口:

1 package org.guangsoft.dao;
2 /***
3  * 定义dao接口
4  * ***/
5 public interface UsersDao
6 {
7     public void saveUsers();
8 }

Dao层接口的实现类

 1 package org.guangsoft.dao.impl;
 2 import org.guangsoft.dao.UsersDao;
 3 //dao实现类
 4 public class UsersDaoImpl implements UsersDao
 5 {
 6     @Override
 7     public void saveUsers()
 8     {
 9         System.out.println("---------将对象保存到数据库--------");
10     }
11 }

建立service接口

1 package org.guangsoft.service;
2 /***
3  * 用户业务接口
4  * **/
5 public interface UsersService
6 {
7     public void addUsers();
8 } 

业务层接口的实现类

 1 package org.guangsoft.service.impl;
 2 import org.guangsoft.dao.UsersDao;
 3 import org.guangsoft.service.UsersService;
 4 /***
 5  * 用户业务接口实现类
 6  * ***/
 7 public class UsersServiceImpl implements UsersService
 8 {
 9     // 以前：创建Dao对象
10     private UsersDao usersDao;
11     @Override
12     public void addUsers()
13     {
14         System.out.println("-----------调用Dao层的方法--------------");
15         usersDao.saveUsers();
16     }
17 } 

建立Action

 1 package org.guangsoft.service.impl;
 2 import org.guangsoft.dao.UsersDao;
 3 import org.guangsoft.service.UsersService;
 4 /***
 5  * 用户业务接口实现类
 6  * ***/
 7 public class UsersServiceImpl implements UsersService
 8 {
 9     // 以前：创建Dao对象
10     private UsersDao usersDao;
11     @Override
12     public void addUsers()
13     {
14         System.out.println("-----------调用Dao层的方法--------------");
15         usersDao.saveUsers();
16     }
17 } 

1.2使用spring管理三层的依赖

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!-- 到入xml文件的约束 -->
 3 <beans xmlns="http://www.springframework.org/schema/beans"
 4     xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans
 6      http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">
 7     <!-- 1 实例化Dao对象 id:完成对象的引用 class:指定需要创建的对象对应的类的完全限定名 -->
 8     <bean id="usersDao" class="org.guangsoft.dao.impl.UsersDaoImpl">
 9     </bean>
10     <!-- 2实例化service -->
11     <bean id="usersService" class="org.guangsoft.service.impl.UsersServiceImpl">
12         <!-- property：完成对象属性的注入（赋值） value:如果是简单的类型使用value（String,基本类型对应的包装类型） ref:完成对应的引用 -->
13         <property name="usersDao" ref="usersDao"></property>
14     </bean>
15     <!-- 3实例化Action对象 -->
16     <bean id="usersAction" class="org.guangsoft.action.UsersAction">
17         <property name="usersService" ref="usersService"></property>
18     </bean>
19 </beans>

1.3三层结构的测试

 1 package org.guangsoft.test;
 2 import org.junit.Test;
 3 import org.springframework.context.ApplicationContext;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5 import org.guangsoft.action.UsersAction;
 6 public class TestSpring
 7 {
 8     @Test
 9     public void testHelloSpring()
10     {
11         // 加载spring的配置文件，获得spring的bean容器
12         ApplicationContext ac
13         = new ClassPathXmlApplicationContext("applicationContext.xml");
14         // 从bean容器中获得需要的对象
15         UsersAction usersAction = (UsersAction) ac.getBean("usersAction");
16         // 调用action的方法
17         usersAction.userReg();
18     }
19 } 

理解spring的IOC 或者 DI:完成对象依赖的解耦合

2 不同类型属性的注入

2.1简单类型属性

 1 <!-- 实例化Pet类的对象 -->
 2 <bean id="pet" class="org.guangsoft.test.Pet">
 3     <!-- 给属性赋值 简单类型的属性使用property标签的value属性赋值 javabean对象使用property标签的ref属性赋值 
 4         调用set方法赋值 1 必须生成属性对应的set方法 2 set注入 -->
 5     <property name="pid" value="100100"></property>
 6     <property name="pnames" value="旺财"></property>
 7 </bean>
 8 <!-- 使用构造注入 -->
 9 <bean id="pet2" class="org.guangsoft.test.Pet">
10     <!-- 使用构造方法给属性赋值 1 根据constructor-arg标签的个数，找对应的构造方法 2 默认constructor-arg的顺序和构造方法的参数顺序是一致的 
11         3 简单类型使用value，如果参数对象使用ref -->
12     <constructor-arg value="小强"></constructor-arg>
13     <constructor-arg value="120120"></constructor-arg>
14 </bean>
15  

2.2javabean类型

Set或者构造注入：注入的时候使用ref注入

2.3集合类型属性

 

 1 <!-- 实例化Pet对象，给集合属性注入值 -->
 2 <bean id="pet3" class="org.guangsoft.test.Pet">
 3     <!-- 给List属性赋值 -->
 4     <property name="lst">
 5         <!-- list标签产生List对象 -->
 6         <list>
 7             <value>list第一个元素</value>
 8             <ref bean="pt" /> <!-- list中的第二个元素 -->
 9         </list>
10     </property>
11     <!-- 给set属性注入值 -->
12     <property name="st">
13         <set>
14             <value>set第一个元素</value>
15             <bean class="org.guangsoft.test.Pet"></bean><!-- 创建匿名对象，作为set的元素 -->
16         </set>
17     </property>
18     <!-- Map集合属性注入 -->
19     <property name="mp">
20         <map>
21             <entry>
22                 <key>
23                     <value>k1</value>
24                 </key>
25                 <value>v1</value>
26             </entry><!-- map集合中第一个元素 -->
27             <entry>
28                 <key>
29                     <value>k2</value>
30                 </key>
31                 <!-- 创建匿名对象，作为set的元素 -->
32                 <bean class="org.guangsoft.test.Pet"></bean>
33             </entry><!-- map集合中第二个元素 -->
34         </map>
35     </property>
36     <!-- Properties集合属性注入（重点） Properties:处理.properties文件，该文件中的键值对象都是字符串 -->
37     <property name="pps">
38         <props>
39             <prop key="k1">v1</prop>
40             <prop key="k2">v2</prop>
41         </props>
42     </property>
43 </bean> 

3 注入方式的总结

      Set注入：调用属性对应的set方法

　　　　简单类型的属性使用property标签的value属性赋值

            javabean对象使用property标签的ref属性赋值

            调用set方法赋值

                 1   必须生成属性对应的set方法

                 2 set注入

     构造注入：调用构造方法给属性赋值

使用构造方法给属性赋值

        1 根据constructor-arg标签的个数，找对应的构造方法

        2 默认constructor-arg的顺序和构造方法的参数顺序是一致的

        3 简单类型使用value，如果参数对象使用ref