IOC[inversion Of Control 反转控制]

在传统的开发模式下，需要使用JdbcUtils / 反射，由程序员编写程序, 在程序中读取配置信息，然后创建对象, new Object???() // 反射方式，再使用对象完成任务。程序员不能够专注的实现对象对业务的处理。

IOC的开发模式很好的解决了这个问题。Spring 根据配置文件 xml/注解创建对象，并将对象放入到容器(ConcurrentHashMap)中, 可以完成对象之间的依赖。

当需要使用某个对象实例的时候, 可以直接从容器中获取。程序员就可以更加关注如何使用对象完成相应的业务, (以前需要 new … ==> 注解/配置方式)。

DI（Dependency Injection）依赖注入，可以理解成是 IOC 的另外叫法。Spring 最大的价值是通过配置，给程序提供需要使用的web 层[Servlet(Action/Controller)]/Service/Dao/[JavaBean/entity]对象, 这个是核心价值所在，也是 ioc 的具体体现,实现解耦。

Spring 快速入门实例

在开始之前我们需要下载spring5的开发包。

commons-logging-1.1.3.jar：spring日志需要的jar。

spring开发ioc基本包：

spring-beans-5.3.8.jar

spring-context-5.3.8.jar

spring-core-5.3.8.jar

spring-expression-5.3.8.jar

还要导入Dom4j.jar包

创建一个beans.xml存放bean。

<!--配置Monster对象-->
    <bean id="monster" class="com.spring.bean.Monster">
        <property name="monsterId" value="1"/>
        <property name="name" value="蜈蚣精"/>
        <property name="skill" value="蜇人"/>
    </bean>

获取对象并给对象属性赋值输出。

package com.spring.test;
import com.spring.beans.Monster;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
public class ApplicationContext {
    private ConcurrentHashMap<String, Object> ioc =
    new ConcurrentHashMap<>();
    public ApplicationContext(String iocBeanXmlFile) throws DocumentException,
    ClassNotFoundException, IllegalAccessException, InstantiationException {
        //反射的方式得到->使用dom4j
        //得到一个解析器
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File(iocBeanXmlFile));
        //1. 得到rootElement
        Element rootElement = document.getRootElement();
        //2. 获取第1 个bean, 如果有多个就遍历所有
        Element bean = (Element) rootElement.elements("bean").get(0);
        String id = bean.attributeValue("id");
        String classFullPath = bean.attributeValue("class");
        List<Element> property = bean.elements("property");
        Integer monsterId = Integer.parseInt(property.get(0).attributeValue("value"));
        String name = property.get(1).attributeValue("value");
        String skill = property.get(2).attributeValue("value");
        //3. 使用反射创建bean 实例，并放入到ioc 中
        Class cls = Class.forName(classFullPath);
            Monster instance = (Monster)cls.newInstance();
        instance.setMonsterId(monsterId);
        instance.setName(name);
        instance.setSkill(skill);
        ioc.put(id, instance);
        }
        public Object getBean(String id) {
        return ioc.get(id);
    }
}

创建一个测试类

package com.spring.test;
import com.spring.beans.Monster;
import org.dom4j.DocumentException;
public class SpringIOCTest {
    public static void main(String[] args) throws DocumentException,
    IllegalAccessException, InstantiationException, ClassNotFoundException {
        //得到beans.xml 文件.
        ApplicationContext ioc = new ApplicationContext("src/beans.xml");
        Monster monster01 = (Monster)ioc.getBean("monster01");
        System.out.println("ioc 的monster01= " + monster01);
    }
}

获取bean的方法

通过类型获取bean

//通过类型来获取容器的bean 对象
@Test
public void getMonsterByType() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    //创建容器
Monster monster = ioc.getBean(Monster.class);
    //获取容器中Monster类型的bean对象
System.out.println("monster=" + monster);
    Monster monster1 = ioc.getBean(Monster.class);
System.out.println("monster == monster1 的值= " + (monster == monster1));
}

按类型来获取bean, 要求ioc 容器中的同一个类的bean 只能有一个, 否则会抛出异常NoUniqueBeanDefinitionException。一般应用于在一个线程中只需要一个对象实例(单例)的情况。在容器配置文件(比如beans.xml)中给属性赋值, 底层是通过setter 方法完成的。

通过构造器配置bean

在spring的ioc容器,可以通过构造器来配置bean对象。

<bean id="monster02" class="com.spring.beans.Monster">
<constructor-arg value="2" index="0"/>
<constructor-arg value="蜘蛛精" index="1"/>
<constructor-arg value="蛛丝束缚" index="2"/>
     //1. 通过index 属性来区分是第几个参数
</bean>
<!--数据类型就是对应的Java 数据类型，按构造器参数顺序-->
<bean id="monster03" class="com.spring.beans.Monster">
<constructor-arg value="3" type="java.lang.Integer"/>
<constructor-arg value="白骨精" type="java.lang.String"/>
<constructor-arg value="白骨鞭" type="java.lang.String"/>
</bean>
//2. 通过type 属性来区分是什么类型(按照顺序)

通过p名称空间配置bean

<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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--在spring 的ioc 容器, 可以通过p 名称空间来配置bean 对象-->
<bean id="monster04" class="com.spring.beans.Monster"
p:monsterId="4"
p:name="红孩儿"
p:skill="吐火~"
/>

引用/注入其它bean 对象

在spring 的ioc 容器, 可以通过ref 来实现bean 对象的相互引用。

<!-- bean 对象的相互引用
        1. 其它含义和前面一样
        2. ref 表示memberDAO 这个属性将引用/指向id = memberDAOImpl 对象
-->
<bean id="memberServiceImpl" class="com.spring.service.MemberServiceImpl">
<property name="memberDAO" ref="memberDAOImpl"/>
</bean>
<bean id="memberDAOImpl" class="com.spring.dao.MemberDAOImpl"/>

引用/注入内部bean 对象

<bean id="memberServiceImpl02"
class="com.spring.service.MemberServiceImpl">
    <property name="memberDAO">
      <bean class="com.spring.dao.MemberDAOImpl"/>
    </property>
</bean>

引用/注入集合/数组类型

<bean id="master01" class="com.spring.beans.Master">
    <property name="name" value="太上老君"/>
    <!-- 给bean 对象的list 集合赋值-->
    <property name="monsterList">
        <list>
            <ref bean="monster03"/>
            <ref bean="monster02"/>
        </list>
    </property>
    <!-- 给bean 对象的map 集合赋值-->
    <property name="monsterMap">
        <map>
            <entry>
            <key>
              <value>monsterKey01</value>
            </key>
            <ref bean="monster01"/>
            </entry>
            <entry>
                <key>
              <value>monsterKey02</value>
                </key>
               <ref bean="monster02"/>
            </entry>
        </map>
    </property>
    <!-- 给bean 对象的properties 集合赋值-->
    <property name="pros">
        <props>
            <prop key="k1">Java 工程师</prop>
            <prop key="k2">前端工程师</prop>
            <prop key="k3">大数据工程师</prop>
        </props>
    </property>
    <!-- 给bean 对象的数组属性注入值-->
    <property name="monsterName">
        <array>
            <value>银角大王</value>
            <value>金角大王</value>
        </array>
    </property>
        <!-- 给bean 对象的set 属性注入值-->
    <property name="monsterSet">
        <set>
            <ref bean="monster01"/>
            <bean class="com.spring.beans.Monster">
                <property name="monsterId" value="10"/>
                <property name="name" value="玉兔"/>
                <property name="skill" value="钻地洞"/>
            </bean>
        </set>
    </property>
</bean>

测试

@Test
public void setCollectionByPro() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Master master01 = ioc.getBean("master01", Master.class);
    //获取list 集合
    System.out.println("======list=======");
    List<Monster> monster_list = master01.getMonsterList();
    for (Monster monster : monster_list) {
      System.out.println(monster);
    }
    //获取map 集合
    System.out.println("======map=======");
    Map<String, Monster> monster_map = master01.getMonsterMap();
    Set<Map.Entry<String, Monster>> entrySet = monster_map.entrySet();
    for (Map.Entry<String, Monster> entry : entrySet) {
       System.out.println(entry);
    }
    //获取properties 集合
    System.out.println("======properties=======");
    Properties pros = master01.getPros();
    String property1 = pros.getProperty("k1");
    String property2 = pros.getProperty("k2");
    String property3 = pros.getProperty("k3");
    System.out.println(property1 + "\t" + property2 + "\t" + property3);
    //获取数组
    System.out.println("======数组=======");
    String[] monsterName = master01.getMonsterName();
    for (String s : monsterName) {
      System.out.println("妖怪名= " + s);
    }
    //获取set
    System.out.println("======set=======");
    Set<Monster> monsterSet = master01.getMonsterSet();
    for (Monster monster : monsterSet) {
      System.out.println(monster);
    }
}

细节

1.主要掌握List/Map/Properties 三种集合的使用。
2.Properties 集合的特点。

1.这个Properties 是Hashtable 的子类, 是key-value 的形式。
2.key 是string 而value 也是string。

通过util 名称空间创建list

<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"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/util
    http://www.springframework.org/schema/util/spring-util.xsd">
    <!--通过util 名称空间来创建list 集合,可以当做创建bean 对象的工具来使用-->
    <util:list id="myListBook">
            <value>三国演义</value>
            <value>西游记</value>
            <value>红楼梦</value>
            <value>水浒传</value>
    </util:list>
    <bean id="bookStore" class="com.spring.beans.BookStore">
      <property name="bookList" ref="myListBook"/>
    </bean>

级联属性赋值

spring 的ioc 容器, 可以直接给对象属性的属性赋值，即级联属性赋值。

<bean id="emp" class="com.spring.beans.Emp">
        <property name="name" value="jack"/>
        <property name="dept" ref="dept"/>
        <property name="dept.name" value="Java 开发部"/> 
</bean>
<bean id="dept" class="com.spring.beans.Dept"/>

package com.spring.beans;
public class Dept {
        private String name;
        public Dept() {
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
}

package com.spring.beans;
public class Emp {
    private String name;
    private Dept dept;
    public Emp() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
      this.name = name;
    }
    public Dept getDept() {
       return dept;
    }
    public void setDept(Dept dept) {
      this.dept = dept;
    }
}

IOC[inversion Of Control 反转控制]（上）