Spring控制反转与依赖注入(IOC、DI)

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层接口:

 package org.guangsoft.dao;
 /***
  * 定义dao接口
  * ***/
 public interface UsersDao
 {
     public void saveUsers();
 }

Dao层接口的实现类

 package org.guangsoft.dao.impl;
 import org.guangsoft.dao.UsersDao;
 //dao实现类
 public class UsersDaoImpl implements UsersDao
 {
     @Override
     public void saveUsers()
     {
         System.out.println("---------将对象保存到数据库--------");
     }
 }

建立service接口

 package org.guangsoft.service;
 /***
  * 用户业务接口
  * **/
 public interface UsersService
 {
     public void addUsers();
 } 

业务层接口的实现类

 package org.guangsoft.service.impl;
 import org.guangsoft.dao.UsersDao;
 import org.guangsoft.service.UsersService;
 /***
  * 用户业务接口实现类
  * ***/
 public class UsersServiceImpl implements UsersService
 {
     // 以前：创建Dao对象
     private UsersDao usersDao;
     @Override
     public void addUsers()
     {
         System.out.println("-----------调用Dao层的方法--------------");
         usersDao.saveUsers();
     }
 } 

建立Action

 package org.guangsoft.service.impl;
 import org.guangsoft.dao.UsersDao;
 import org.guangsoft.service.UsersService;
 /***
  * 用户业务接口实现类
  * ***/
 public class UsersServiceImpl implements UsersService
 {
     // 以前：创建Dao对象
     private UsersDao usersDao;
     @Override
     public void addUsers()
     {
         System.out.println("-----------调用Dao层的方法--------------");
         usersDao.saveUsers();
     }
 } 

1.2使用spring管理三层的依赖

 <?xml version="1.0" encoding="UTF-8"?>
 <!-- 到入xml文件的约束 -->
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:p="http://www.springframework.org/schema/p" 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-4.1.xsd">
     <!-- 1 实例化Dao对象 id:完成对象的引用 class:指定需要创建的对象对应的类的完全限定名 -->
     <bean id="usersDao" class="org.guangsoft.dao.impl.UsersDaoImpl">
     </bean>
     <!-- 2实例化service -->
     <bean id="usersService" class="org.guangsoft.service.impl.UsersServiceImpl">
         <!-- property：完成对象属性的注入（赋值） value:如果是简单的类型使用value（String,基本类型对应的包装类型） ref:完成对应的引用 -->
         <property name="usersDao" ref="usersDao"></property>
     </bean>
     <!-- 3实例化Action对象 -->
     <bean id="usersAction" class="org.guangsoft.action.UsersAction">
         <property name="usersService" ref="usersService"></property>
     </bean>
 </beans>

1.3三层结构的测试

 package org.guangsoft.test;
 import org.junit.Test;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 import org.guangsoft.action.UsersAction;
 public class TestSpring
 {
     @Test
     public void testHelloSpring()
     {
         // 加载spring的配置文件，获得spring的bean容器
         ApplicationContext ac
         = new ClassPathXmlApplicationContext("applicationContext.xml");
         // 从bean容器中获得需要的对象
         UsersAction usersAction = (UsersAction) ac.getBean("usersAction");
         // 调用action的方法
         usersAction.userReg();
     }
 } 

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

2 不同类型属性的注入

2.1简单类型属性

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

2.2javabean类型

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

2.3集合类型属性

 <!-- 实例化Pet对象，给集合属性注入值 -->
 <bean id="pet3" class="org.guangsoft.test.Pet">
     <!-- 给List属性赋值 -->
     <property name="lst">
         <!-- list标签产生List对象 -->
         <list>
             <value>list第一个元素</value>
             <ref bean="pt" /> <!-- list中的第二个元素 -->
         </list>
     </property>
     <!-- 给set属性注入值 -->
     <property name="st">
         <set>
             <value>set第一个元素</value>
             <bean class="org.guangsoft.test.Pet"></bean><!-- 创建匿名对象，作为set的元素 -->
         </set>
     </property>
     <!-- Map集合属性注入 -->
     <property name="mp">
         <map>
             <entry>
                 <key>
                     <value>k1</value>
                 </key>
                 <value>v1</value>
             </entry><!-- map集合中第一个元素 -->
             <entry>
                 <key>
                     <value>k2</value>
                 </key>
                 <!-- 创建匿名对象，作为set的元素 -->
                 <bean class="org.guangsoft.test.Pet"></bean>
             </entry><!-- map集合中第二个元素 -->
         </map>
     </property>
     <!-- Properties集合属性注入（重点） Properties:处理.properties文件，该文件中的键值对象都是字符串 -->
     <property name="pps">
         <props>
             <prop key="k1">v1</prop>
             <prop key="k2">v2</prop>
         </props>
     </property>
 </bean> 

3 注入方式的总结

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

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

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

调用set方法赋值

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

2 set注入

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

使用构造方法给属性赋值

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

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

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