Spring 基于 XML 的 IOC配置

一、 spring基于 XML 的IOC入门

Inverse of Control 反转控制，把创建对象的权利交给框架，包括依赖注入和依赖查找。
以前对象的创建时由我们开发人员自己维护，包括依赖关系也是自己注入。
使用了Spring之后，对象的创建及依赖关系可以由Spring完成创建以及注入。
反转控制就是反转了对象的创建方式，从我们自己创建反转给了程序（Spring）。

//User对象
import java.util.*;

public class User {

    private Integer id;
    private String username;
    private Character sex;
    private Date birthday;
	
	public User() {
    }
	
	public User(Integer id, String username, Character sex, Date birthday) {
        this.id = id;
        this.username = username;
        this.sex = sex;
        this.birthday = birthday;
    }
	
	//getter and setter此处省略
}

1. 引入依赖
  <!--引入spring 的最核心依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        
2.创建UserDao接口和UserDaoImpl实现类。

3. 创建beans.xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!--
http://www.springframework.org/schema/beans: 引入bean的名称空间
约束：现在xml的书写
    dtd:mybatis
    schema:spring

http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd 引入约束
-->
<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
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userDao" class="com.testfan.dao.impl.UserDaoImpl"></bean>

</beans>

4. 创建容器对象，根据id获取对象
 //创建spring的IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        //获取对象
        Object userDao = ac.getBean("userDao");
        System.out.println(userDao);

二、IOC 中 bean 标签和管理对象细节

2.1 bean 标签

作用：用于配置对象让 spring 来创建的。默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性：

• id： 给对象在容器中提供一个唯一标识。用于获取对象。
• class： 指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
• scope： 指定对象的作用范围。
  • singleton :默认值，单例的.
  • prototype :多例的.
  • request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
  • session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
  • global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.
• init-method： 指定类中的初始化方法名称。
• destroy-method： 指定类中销毁方法名称

2.2 bean 的作用范围和生命周期

• 单例对象： scope="singleton"

  一个应用只有一个对象的实例。它的作用范围就是整个引用。
  生命周期：
     对象出生：当应用加载，创建容器时，对象就被创建了。
     对象活着：只要容器在，对象一直活着。
     对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

• 多例对象： scope="prototype"

  每次访问对象时，都会重新创建对象实例。
  生命周期：
     对象出生：当使用对象时，创建新的对象实例。
     对象活着：只要对象在使用中，就一直活着。
     对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

2.3 实例化 Bean 的三种方式

第一种方式：使用默认无参构造函数

<!--在默认情况下：
它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。
-->
<bean id="accountService" class="com.testfan.service.impl.AccountServiceImpl"/>

第二种方式： spring 管理静态工厂-使用静态工厂的方法创建对象

/**
* 模拟一个静态工厂，创建业务层实现类
*/
public class StaticFactory {
	public static IAccountService createAccountService(){
		return new AccountServiceImpl();
	}
}

<!-- 此种方式是:
使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
id 属性：指定 bean 的 id，用于从容器中获取
class 属性：指定静态工厂的全限定类名
factory-method 属性：指定生产对象的静态方法
-->
<bean id="accountService" class="com.testfan.factory.StaticFactory"
factory-method="createAccountService"></bean>

第三种方式： spring 管理实例工厂-使用实例工厂的方法创建对象

/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
	public IAccountService createAccountService(){
		return new AccountServiceImpl();
	}
}

<!-- 此种方式是：
先把工厂的创建交给 spring 来管理。然后在使用工厂的 bean 来调用里面的方法
factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
<bean id="instancFactory" class="com.testfan.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instancFactory"
factory-method="createAccountService"></bean>

三、DI

Dependency Injection依赖注入，实现IoC思想需要DI做支持。 它是 spring 框架核心 IoC的具体实现。
我们的程序在编写时， 通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。IoC解耦只是降低他们的依赖关系，但不会消除。 例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系， 在使用 spring 之后， 就让 spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

3.1 注入方式

• set方法注入【常用推荐】

	<bean id="birthday" class="java.util.Date"></bean>
    <!--通过set方法注入-->
    <bean id="user" class="com.testfan.domain.User">
        <!--property ：属性注入 , 先找到setter方法，才能最终找到属性-->
        <property name="username" value="张三"></property>
        <property name="birthday" ref="birthday"></property>
        <property name="sex" value="男"></property>
        <property name="id" value="5"></property>
    </bean>

• 构造方法注入

    <!--默认创建对象方式，使用默认的空的构造方法创建对象-->
    <bean id="user" class="com.testfan.domain.User">
        <!--3.通过构造方法参数的索引赋值-->
        <!--<constructor-arg index="0" value="1"></constructor-arg>-->
        <!--<constructor-arg index="1" value="张三"></constructor-arg>-->
        <!--2.通过构造方法参数类型赋值-->
        <!--<constructor-arg type="java.lang.Integer" value="2"></constructor-arg>-->
        <!--<constructor-arg type="java.lang.String" value="李四"></constructor-arg>-->
        <!--1.通过构造方法参数名字赋值【重要】-->
        <constructor-arg name="id" value="3"></constructor-arg>
        <constructor-arg name="username" value="王五"></constructor-arg>
   		<constructor-arg name="sex" value="男"></constructor-arg>
        <constructor-arg name="birthday" ref="birthday"></constructor-arg>
    </bean>

	<bean id="birthday" class="java.util.Date"></bean>

• 字段注入
• 注入集合属性【常用】

import java.util.*;

public class User {

    private List<String> list;
    private Set<String > set;
    private String[] strs;

    private Map<String ,String> map;
    private Properties properties;
	
	public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }
	
	public Set<String> getSet() {
        return set;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }
	
	public String[] getStrs() {
        return strs;
    }

    public void setStrs(String[] strs) {
        this.strs = strs;
    }
	
    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
 
}

<!--注入集合属性-->
    <bean id="user4" class="com.testfan.domain.User">
        <!--array ,list ,set 结构相同，标签可以混用-->
        <property name="list">
            <set>
                <value>javaSE</value>
                <value>javaEE</value>
                <value>javaME</value>
            </set>
        </property>

        <property name="set">
            <array>
                <value>javaSE</value>
                <value>javaEE</value>
                <value>javaME</value>
            </array>
        </property>
        <property name="strs">
            <list>
                <value>javaSE</value>
                <value>javaEE</value>
                <value>javaME</value>
            </list>
        </property>
        
        <!--map集合properties结构相同，可以通用-->
        <property name="map">
           <props>
            <prop key="五" >five</prop>
            <prop key="六" >six</prop>
            <prop key="七" >seven</prop>
        </props>
        </property>

        <property name="properties">
            <map>
                <!--键值对配置-->
                <entry key="一" value="one"></entry>
                <entry key="二" value="two"></entry>
                <entry key="三" value="three"></entry>
                <entry key="四" value="four"></entry>
            </map>
        </property>
    </bean>

3.2 注入类型

• 值类型注入：8大基本数据类型使用此注入类型
• 引用类型注入：将依赖对象注入使用此注入类型

    <!--
        value 属性只能赋值简单的类型:基本数据类型和String类型
        ref:  pojo类型，复杂类型, 关联创建好的对象
    -->
    <bean id="birthday" class="java.util.Date"></bean>
    <!--通过set方法注入-->
    <bean id="user" class="com.testfan.domain.User">
        <!--property ：属性注入 , 先找到setter方法，才能最终找到属性-->
        <property name="username" value="张三"></property>
        <property name="birthday" ref="birthday"></property>
        <property name="sex" value="男"></property>
        <property name="id" value="5"></property>
    </bean>

四、applicationContext&BeanFactory

Spring中的工厂类

• applicationContext（现在使用）
• BeanFactory（早年使用）

4.1 spring 中工厂的类结构图

spring 中工厂的类结构图

4.2 BeanFactory接口

BeanFactory接口是 Spring 容器中的顶层接口，针对原始接口的实现类功能较为单一。
BeanFactory接口实现类的容器，特点是每次在获得对象时才会创建对象，即什么时候使用什么时候创建
这主要是因为，BeanFactory是早年使用的接口，当时硬件资源比较匮乏，内存配置低，所以当时设计的框架资源使用比较节约。

4.3 ApplicationContext接口

ApplicationContext 是BeanFactory接口的子接口。
ApplicationContext接口实现类的容器，特点是每次容器启动时就会创建容器中配置的所有对象，并提供更多功能

典型的实现类

• ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件 推荐使用这种
• FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
• AnnotationConfigApplicationContext:当我们使用注解配置容器对象时，需要使用此类来创建 spring容器。它用来读取注解。

4.4 BeanFactory 和 ApplicationContext 的区别

创建对象的时间点不一样。
ApplicationContext：只要一读取配置文件， 默认情况下就会创建对象。
BeanFactory：什么使用什么时候创建对象。

结论：web开发中,使用applicationContext. 在资源匮乏的环境可以使用BeanFactory.