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开发中使用，对应的就是这三类作用域。


如有错误，欢迎大佬指正!

posted @ 2020-08-10 21:21  想拥有两颗❤  阅读(126)  评论(0)  编辑  收藏  举报