Spring——IOC（控制反转）与DI（依赖注入）

IOC与DI的理解及使用

控制反转IOC（Inversion of Control）是一种设计思想，DI（依赖注入）是实现IOC的一种方法。在没有IOC的程序中，我们使用面向对象编程，对象的创建于对象间的依赖完全硬编码在程序中，对象的创建有程序自己控制；控制反转后将对象的创建转移给第三方；

控制反转是一种通过描述XML（或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（Dependency Injection，DI）

IOC演示：

1. UserDao接口

   public interface UserDao {
       void getUser();
   }
   

2. UserDaoImpl实现类

   public class UserDaoImpl implements UserDao{
       public void getUser() {
           System.out.println("默认获取用户");
       }
   }
   

3. UserService业务接口

   public interface UserService {
       void getUser();
   
       void setUserDao(UserDao userDao);
   }
   

4. UserServiceImpl业务实现类

   public class UserServiceImpl implements UserService {
   
       private UserDao userDao ;
   
       //利用set进行动态实现值的注入
       public void setUserDao(UserDao userDao){
           this.userDao = userDao;
       }
   
       public void getUser() {
           userDao.getUser();
       }
   }
   

这里使用一个Set方法实现

      private UserDao userDao ;

      //利用set进行动态实现值的注入
      public void setUserDao(UserDao userDao){
          this.userDao = userDao;
      }

      //代替了原先主动在该类中穿创建对象:
      //userDao = new UserDao();

• 之前，程序是主动创建对象，控制权在开发者手上！
• 使用set注入后，程序不再具有主动性，而是变成了被动的接收对象！
• 这种对象的控制权的转变思想就是IOC（控制反转）

这种思想，从本质上解决了问题，程序员不用再去管理对象的创建了，系统的耦合性大大降低，可以更加专注在业务的实现上。这就是IOC的原型。

1、第一个spring

Spring的核心就是基于IOC容器，将对象的创建以及依赖的注入全部交由Spring容器来完成。

首先基于如上接口和业务创建两个接口实现类：

public class UserDaoMysqlImpl implements UserDao{
    public void getUser() {
        System.out.println("mysql获取用户");
    }
}

public class UserOracleImpl implements UserDao{
    public void getUser() {
        System.out.println("oracle获取用户");
    }
}

创建applicationContext.xml文件

基于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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

   	<!--一个bean就对应一个实例化一个对象，在Spring中管理-->
    <bean id="mysqlImpl" class="com.spong.dao.UserDaoMysqlmpl"/>
    <bean id="oracleImpl" class="com.spong.dao.UserOracleImpl"/>

    <!--userServiceImpl实例注入ioc容器-->
    <bean id="userServiceImpl" class="com.spong.service.UserServiceImpl">
        <!--
            ref:引用Spring容器中创建好的对象
            value:具体的值，基本数据类型
        -->
        <!--给实例化对象中的属性赋值，自动调用类中的setUserDao()方法，没有或者方法名不规范则会出错-->
        <!--ref传入哪个实现类的id，就调用userServiceImpl的set方法注入这个实现类-->
        <property name="userDao" ref="mysqlImpl"/>
    </bean>

</beans>

测试：

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象ApplicationContext
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //对象已经在Spring中管理了，使用时直接根据bean id取即可
        UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("userServiceImpl");
        serviceImpl.getUser();

    }
}

现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在XML中进行修改；

这个过程就叫控制反转：

• 控制：谁来控制对象的创建，传统的应用程序是由程序本身控制创建的，使用Spring后，对象由Spring来创建；
• 反转：程序本身不创建对象，而变成被动的接受对象；
• 依赖注入：就是利用set、构造方法等进行属性的注入；
  • 依赖：bean对象的创建依赖于容器！
  • 注入：bean对象中的所有属性，由容器来注入！

IOC是一种编程思想，由主动的编程变为被动的接收。

总结为一句话：对象由Spring来创建，管理，装配。

2、IOC创建对象的方法

1. 默认使用无参构造创建对象

2. 自定义使用有参构造创建对象

   1. 下标赋值

      <bean id="exampleBean" class="examples.ExampleBean">
          <constructor-arg index="0" value="7500000"/>
          <constructor-arg index="1" value="42"/>
      </bean>
      

   2. 参数名赋值

      <bean id="exampleBean" class="examples.ExampleBean">
          <constructor-arg name="years" value="7500000"/>
          <constructor-arg name="ultimateAnswer" value="42"/>
      </bean>
      

   3. 根据类型赋值（有同类型参数时则会有问题）

      <bean id="exampleBean" class="examples.ExampleBean">
          <constructor-arg type="int" value="7500000"/>
          <constructor-arg type="java.lang.String" value="42"/>
      </bean>
      

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了。

3、DI(依赖注入)

IOC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。

DI的实现原理是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，Spring就是通过反射来实现注入的。

理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

• 谁依赖于谁：是应用程序依赖于IoC容器；

• 为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；

• 谁注入谁：是IOC容器注入应用程序依赖的某个对象；

• 注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

1、构造器注入

1. 默认使用无参构造创建对象

2. 自定义使用有参构造创建对象：

   1. 下标赋值

   <bean id="exampleBean" class="examples.ExampleBean">
       <constructor-arg index="0" value="7500000"/>
       <constructor-arg index="1" value="42"/>
   </bean>
   

   1. 参数名赋值

   <bean id="exampleBean" class="examples.ExampleBean">
       <constructor-arg name="years" value="7500000"/>
       <constructor-arg name="ultimateAnswer" value="42"/>
   </bean>
   

   1. 根据类型赋值（有同类型参数时则会有问题）

   <bean id="exampleBean" class="examples.ExampleBean">
       <constructor-arg type="int" value="7500000"/>
       <constructor-arg type="java.lang.String" value="42"/>
   </bean>
   

*2、set方式注入

【环境搭建】

1. 复杂类型

   public class Address {
       private String address;
   
       public String getAddress() {
           return address;
       }
   
       public void setAddress(String address) {
           this.address = address;
       }
   
       @Override
       public String toString() {
           return "Address{" +
                   "address='" + address + '\'' +
                   '}';
       }
   }
   

2. 测试对象

   @Data
   public class Student {
       private String name;
       private Address address;
       private String[] books;
       private List<String> hobbies;
       private Map<String,String> card;
       private Set<String> games;
       private String wife;    //null
       private Properties info;
   }
   

3. beans.xml

   	<bean id="address" class="com.spong.pojo.Address">
           <property name="address" value="zhejiang"/>
       </bean>
   
       <bean id="student" class="com.spong.pojo.Student">
           <!--基本类型注入 value-->
           <property name="name" value="ps"/>
   
           <!--bean对象注入 ref-->
           <property name="address" ref="address"/>
   
           <!--数组-->
           <property name="books">
               <array>
                   <value>西游记</value>
                   <value>三国演义</value>
                   <value>红楼梦</value>
                   <value>水浒传</value>
               </array>
           </property>
   
           <!--list-->
           <property name="hobbies">
               <list>
                   <value>唱歌</value>
                   <value>打游戏</value>
               </list>
           </property>
   
           <!--map-->
           <property name="card">
               <map>
                   <entry key="学生证" value="147596654"/>
                   <entry key="身份证" value="33216541236542512"/>
               </map>
           </property>
   
           <!--set-->
           <property name="games">
               <set>
                   <value>LOL</value>
                   <value>CS</value>
               </set>
           </property>
   
           <!--properties-->
           <property name="info">
               <props>
                   <prop key="性别">男</prop>
                   <prop key="年龄">18</prop>
               </props>
           </property>
   
           <!--null-->
           <property name="wife">
               <null/>
           </property>
       </bean>
   

4. 测试类

   public class MyTest2 {
       public static void main(String[] args) {
           ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
           Student student = (Student) context.getBean("student");
           System.out.println();
       }
   }
   

• 测试结果

  Student{
  	name='ps',
  	address=Address{address='address'},
      books=[西游记, 三国演义, 红楼梦, 水浒传],
      hobbies=[唱歌, 打游戏],
      card={学生证=147596654, 身份证=33216541236542512},
      games=[LOL, CS],
      wife='null',
      info={性别=男, 年龄=18}
  }
  

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了。

3、拓展

可以使用p命名空间和c命名空间进行注入：

p命名（properties）

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
	<!--带可选参数名称的传统声明-->
    <bean name="classic" class="com.example.ExampleBean">
        <property name="email" value="someone@somewhere.com"/>
    </bean>

	<!--带参数名称的p-名称空间声明-->
    <bean name="p-namespace" class="com.example.ExampleBean"
        p:email="someone@somewhere.com"/>
</beans>

c命名（constructor）

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:c="http://www.springframework.org/schema/c"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="beanTwo" class="x.y.ThingTwo"/>
    <bean id="beanThree" class="x.y.ThingThree"/>

    <!-- 带可选参数名称的传统声明 -->
    <bean id="beanOne" class="x.y.ThingOne">
        <constructor-arg name="thingTwo" ref="beanTwo"/>
        <constructor-arg name="thingThree" ref="beanThree"/>
        <constructor-arg name="email" value="something@somewhere.com"/>
    </bean>

    <!-- 带有参数名称的c-名称空间声明 -->
    <bean id="beanOne" class="x.y.ThingOne"
        c:thingTwo-ref="beanTwo"
        c:thingThree-ref="beanThree"
        c:email="something@somewhere.com"/>

</beans>

注意：p命名和c命名空间不能直接使用，需要导入xml约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

4、bean的作用域

Scope	Description
singleton	(Default) Scopes a single bean definition to a single object instance for each Spring IoC container.
prototype	Scopes a single bean definition to any number of object instances.
request	Scopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.
session	Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
application	Scopes a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.
websocket	Scopes a single bean definition to the lifecycle of a WebSocket. Only valid in the context of a web-aware Spring ApplicationContext.

1. 单例模式（Spring默认机制）

   bean的一个共享实例，并且所有对具有ID或与该bean定义相匹配的ID的bean的请求都会导致该特定的bean实例由Spring容器返回

   <!--scope标签修改作用域-->
   <bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>
   

2. 原型模式：

   每次对特定bean提出请求时，bean部署的非单一原型范围都会创建一个新的bean实例

   <bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>
   

3. 其余的request、session、application等只能在web开发中使用，对应的就是这三类作用域。