Spring之IoC总结帖

　　Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

　　一般在Web应用中引入Spring的程序框架流程如下所示：

Spring模块框架图一览：

　　关于IoC更详细资料请点击：Spring学习之第一个hello world程序，IoC为控制反转，也成为DI(依赖注入)，为Spring的核心模块，另一个是AOP。

1 Spring中的Bean配置

1.1 IOC和DI

• IOC(Inversion of Control)：其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式
• DI(Dependency Injection) — IOC 的另一种表述方式：即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言，这种表述更直接

1.2 Spring容器

　　在Spring IoC容器读取Bean配置创建Bean实例之前，必须对其实例化，只有在容器实例化后，才可以从IOC中获取Bean实例并使用它。

Spring提供了2种类型的IOC容器实现：

• BeanFactory: IoC容器的基本实现
• ApplicationContext: 提供了更多的高级功能，是BeanFactory的实现类

　　BeanFactory是Spring框架的基石，主要被Spring自身程序调用；而ApplicationContext主要面向使用Spring的程序员，几乎所有的场合都可以直接使用ApplicationContext而非底层的BeanFactory。无论使用哪种方式，它们的配置文件是相同的。

如何在IOC容器中配置Bean？

　　在xml文件中通过bean节点来配置Bean。

　　id表示Bean名称，在IOC容器中需是唯一的，若id未指定，Spring自动将授权限定性名作为Bean的名字，若上图中Bean配置未设定id，则getBean()使用名字"java.lang.String"。id可以指定多个名字，名字之间可用逗号、分号、空号分割。

如何获取IOC容器中的Bean？

　　从IOC容器中获取Bean实例有如下方法：

1.3 ApplicationContext

　　ApplicationContext 的主要实现类有ClassPathXmlApplicationContext(从 类路径下加载配置文件)和FileSystemXmlApplicationContext( 从文件系统中加载配置文件)，ApplicationContext 默认在初始化上下文时就实例化所有单例的Bean，注意Bean配置模式是单例的。

　　ConfigurableApplicationContext 扩展于 ApplicationContext，新增加两个主要方法：refresh() 和 close()， 让 ApplicationContext 具有启动、刷新和关闭上下文的能力。

　　WebApplicationContext 是专门为 WEB 应用而准备的，它允许从相对于 WEB 根目录的路径中完成初始化工作。

1.4 依赖注入的方式

　　Spring支持3种依赖注入的方式：

• 属性注入
• 构造器注入
• 工厂方法注入（较少使用，不推荐）

属性注入

　　属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象，使用 元素, 使用 name 属性指定 Bean 的属性名称，value 属性或 子节点指定属性值，属性注入是实际应用中最常用的注入方式。属性注入Bean类须有一个默认的构造方法。

<bean id="hello" class="com.luoxn28.Hello">
    <property name="msg" value="luoxn28"/>
bean>

构造方法注入

　　通过构造方法注入Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用，构造器注入在 元素里声明属性。

<bean id="msg" class="java.lang.String">
    <constructor-arg value="string"/>
bean>

<bean id="car" class="com.luoxn28.Car">
    <constructor-arg value="比亚迪" index="0"/>
    <constructor-arg value="中国制造" index="1"/>
    <constructor-arg value="200000" index="2"/>
bean>

<bean id="car2" class="com.luoxn28.Car">
    <constructor-arg value="比亚迪" type="java.lang.String">
    <constructor-arg value="中国制造" type="java.lang.String"/>
    <constructor-arg value="200000" type="double"/>
bean>

1.4 引用Bean

引用其他Bean

　　组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能。要使 Bean 能够相互访问，就必须在 Bean 配置文件中指定对 Bean 的引用，在 Bean 的配置文件中，可以通过 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用。也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean。

<bean id="msg" class="java.lang.String">
    <constructor-arg value="luoxn28"/>
bean>


<bean id="hello" class="com.luoxn28.Hello">
    <property name="msg" ref="msg"/>
bean>

内部Bean

　　当 Bean 实例仅仅给一个特定的属性使用时，可以将其声明为内部 Bean，内部 Bean 声明直接包含在 或 元素里，不需要设置任何 id 或 name 属性。内部 Bean 不能使用在任何其他地方。

<bean id="hello" class="com.luoxn28.Hello">
    <property name="msg">
        <bean class="java.lang.String">
            <constructor-arg value="luoxn28"/>
        bean>
    property>
bean>

1.5 属性集合

• 在 Spring中可以通过一组内置的 xml 标签(例如: , 或
• 配置 java.util.List 类型的属性, 需要指定 标签, 在标签里包含一些元素. 这些标签可以通过 指定简单的常量值, 通过 指定对其他 Bean 的引用. 通过 指定内置 Bean 定义. 通过 指定空元素. 甚至可以内嵌其他集合。
• 数组的定义和 List 一样, 都使用
• 配置 java.util.Set 需要使用 标签, 定义元素的方法与 List 一样.

• Java.util.Map 通过

• 使用 定义 java.util.Properties, 该标签使用多个 作为子标签. 每个 标签必须定义 key 属性。

<bean id="collectionClass" class="com.luoxn28.CollectionClass">
    <property name="list">
        <list>
            <value>luoxn28value>
            <value>luoxn29value>
            <value>luoxn30value>
        list>
    property>
    <property name="set">
        <set>
            <value>luoxn28value>
            <value>luoxn29value>
            <value>luoxn30value>
        set>
    property>
    <property name="map">
        <map>
            <entry key="str1" value="luoxn28"/>
            <entry key="str2"><value>luoxn29value>entry>
            <entry key="str3"><value>luoxn30value>entry>
        map>
    property>
bean>

1.6 使用p命名空间

　　为了简化 XML 文件的配置，越来越多的 XML 文件采用属性而非子元素配置信息。Spring 从 2.5 版本开始引入了一个新的 p 命名空间，可以通过 元素属性的方式配置 Bean 的属性。使用 p 命名空间后，基于 XML 的配置方式将进一步简化，使用示例如下所示：

<bean id="msg" class="java.lang.String">
    <constructor-arg value="luoxn28"/>
bean>


<bean id="hello" class="com.luoxn28.Hello" p:msg="luoxn28">
bean>
<bean id="hello1" class="com.luoxn28.Hello" p:msg-ref="msg">
bean>

　　使用p命名空间需要引入 xmlns:p="http://www.springframework.org/schema/p" 。

 

2  Bean配置高级特性

2.1 XML配置中Bean的自动装配

　　Spring IOC 容器可以自动装配 Bean. 需要做的仅仅是在 的 autowire 属性里指定自动装配的模式

• byType(根据类型自动装配): 若 IOC 容器中有多个与目标 Bean 类型一致的 Bean. 在这种情况下, Spring 将无法判定哪个 Bean 最合适该属性, 所以不能执行自动装配.
• byName(根据名称自动装配): 必须将目标 Bean 的名称和属性名设置的完全相同.
• constructor(通过构造器自动装配): 当 Bean 中存在多个构造器时, 此种自动装配方式将会很复杂. 不推荐使用

　　注意：自动装配中如果被注入对象如果是Java基本类型的话，自动注入是不成功的，自定义的类是没问题的，如下所示。具体为什么我也不知道，还请知道原因的小伙伴在评论中告知我，谢谢^_^。

<bean id="hello" class="com.luoxn28.Hello" autowire="byName">
bean>

<bean id="msg" class="java.lang.String">
    <constructor-arg value="110"/>
bean>

XML配置Bean自动装配的缺点

• 在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性. 然而, 若只希望装配个别属性时, autowire 属性就不够灵活了.
• autowire 属性要么根据类型自动装配, 要么根据名称自动装配, 不能两者兼而有之.
• 一般情况下，在实际的项目中很少使用自动装配功能，因为和自动装配功能所带来的好处比起来，明确清晰的配置文档更有说服力一些

2.2 继承Bean配置

• Spring 允许继承 bean 的配置, 被继承的 bean 称为父 bean. 继承这个父 Bean 的 Bean 称为子 Bean
• 子 Bean 从父 Bean 中继承配置, 包括 Bean 的属性配置
• 子 Bean 也可以覆盖从父 Bean 继承过来的配置
• 父 Bean 可以作为配置模板, 也可以作为 Bean 实例. 若只想把父 Bean 作为模板, 可以设置 的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean
• 并不是 元素里的所有属性都会被继承. 比如: autowire, abstract 等.
• 也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true

<bean id="person" class="com.luoxn28.Person" p:name="luoxn28" p:age="23">
bean>


<bean id="person2" parent="person" p:name="luoxn29">
bean>

Bean依赖配置

• Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的Bean，前置依赖的 Bean 会在本 Bean 实例化之前创建好
• 如果前置依赖于多个 Bean，则可以通过逗号，空格或的方式配置 Bean 的名称

<bean id="msg" class="java.lang.String">
    <constructor-arg value="luoxn28"/>
bean>

<bean id="hello" class="com.luoxn28.Hello" depends-on="msg">
    <property name="msg" ref="msg"/>
bean>

2.3 Bean作用域

　　在 Spring 中, 可以在 元素的 scope 属性里设置 Bean 的作用域.。默认情况下, Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一个实例, 整个 IOC 容器范围内都能共享该实例：所有后续的 getBean() 调用和 Bean 引用都将返回这个唯一的 Bean 实例.该作用域被称为 singleton, 它是所有 Bean 的默认作用域。

<bean id="hello" class="com.luoxn28.Hello" scope="prototype">
    <property name="msg" value="luoxn28"/>
bean>

2.3 使用外部属性文件

• 在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离
• Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为 ${var} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.
• Spring 还允许在属性文件中使用 ${propName}，以实现属性之间的相互引用。

比如，程序中有一个db.properties的配置文件：

user=luoxn28
password=123456
driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://192.168.1.150/test

程序中Spring的applicationContext.xml配置增加内容如下：

<context:property-placeholder location="classpath:db.properties"/>

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="user" value="${user}"/>
    <property name="password" value="${password}"/>
    <property name="driverClass" value="${driverClass}"/>
    <property name="jdbcUrl" value="${jdbcUrl}"/>
bean>

程序中就可以使用了：

public static void main(String[] args) throws SQLException {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

    // 获取外部文件
    DataSource dataSource = context.getBean("dataSource", DataSource.class);
    System.out.println(dataSource.getConnection());
}

2.4 Spring的表达式语言：SpEL

• Spring 表达式语言（简称SpEL）：是一个支持运行时查询和操作对象图的强大的表达式语言。
• 语法类似于 EL：SpEL 使用 #{…} 作为定界符，所有在大框号中的字符都将被认为是 SpEL
• SpEL 为 bean 的属性进行动态赋值提供了便利

通过 SpEL 可以实现：

• 通过 bean 的 id 对 bean 进行引用
• 调用方法以及引用对象中的属性
• 计算表达式的值
• 正则表达式的匹配

SpELl 字面量

整数：<property name="count" value="#{5}"/>
小数：<property name="frequency" value="#{89.7}"/>
科学计数法：<property name="capacity" value="#{1e4}"/>
String可以使用单引号或者双引号作为字符串的定界符号：<property name=“name” value="#{'Chuck'}"/> 或 <property name='name' value='#{"Chuck"}'/>
Boolean：<property name="enabled" value="#{false}"/>

SpELl 引用Bean、属性和方法

<bean id="hello" class="com.luoxn28.Hello">
    <property name="msg" value="#{msg}"/>
bean>


<bean id="hello2" class="com.luoxn28.Hello">
    
    <property name="msg" value="#{hello.msg}"/>
bean>

SpELl 支持的运算符

<property name="xxx" value="#{1 + 1}"/>
<property name="xxx" value="#{1 - 1}"/>
<property name="xxx" value="#{1 * 1}"/>
<property name="xxx" value="#{1 / 1}"/>
<property name="xxx" value="#{'luoxn' + '28'}"/>
<property name="xxx" value="#{1 == 1}"/>
<property name="xxx" value="#{1 < 1}"/>
<property name="xxx" value="#{1 > 1}"/>
<property name="xxx" value="#{true ? 'true' : 'false'}"/>
<property name="xxx" value="#{email matches '[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[com|cn]'}"/>

2.5 IoC容器中Bean的生命周期方法

• Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.
• Spring IOC 容器对 Bean 的生命周期进行管理的过程:
  • 通过构造器或工厂方法创建 Bean 实例
  • 为 Bean 的属性设置值和对其他 Bean 的引用
  • 调用 Bean 的初始化方法
  • Bean 可以使用了
  • 当容器关闭时, 调用 Bean 的销毁方法
• 在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.

2.6 创建Bean后置处理器

• Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
• Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
• 对Bean 后置处理器而言, 需要实现 接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口中的两个方法.该接口源码如下：

public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;

    Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;
}

添加 Bean 后置处理器后 Bean 的生命周期

Spring IOC 容器对 Bean 的生命周期进行管理的过程:

• 通过构造器或工厂方法创建 Bean 实例
• 为 Bean 的属性设置值和对其他 Bean 的引用
• 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
• 调用 Bean 的初始化方法
• 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
• Bean 可以使用了
• 当容器关闭时, 调用 Bean 的销毁方法

2.7 通过静态工厂和实例工厂创建Bean

通过调用静态工厂方法创建 Bean

• 调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
• 要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 元素为该方法传递方法参数.

比如Hello类静态工厂方法如下：

public static Hello createHello() {
    Hello hello = new Hello();
    hello.setMsg("static");
    return hello;
}

Spring的applicationContext.xml增加配置如下：

<bean id="hello" class="com.luoxn28.Hello" factory-method="createHello">
bean>

通过调用实例工厂方法创建 Bean

• 实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
• 要声明通过实例工厂方法创建的 Bean
  • 在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
  • 在 factory-method 属性里指定该工厂方法的名称
  • 使用 construtor-arg 元素为工厂方法传递方法参数

2.8 实现 FactoryBean 接口在 Spring IOC 容器中配置 Bean

• Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean.
• 工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象 

FactoryBean接口源码如下所示：

public interface FactoryBean {
    // 返回的实例
    T getObject() throws Exception;
    // 返回的类型
    Class getObjectType();
    // 是否为单例
    boolean isSingleton();
}

比如有一个Hello类如下：

public class Hello {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

定义Hello类的FactoryBean类：

public class HelloBeanFactory implements FactoryBean {

    @Override
    public Hello getObject() throws Exception {
        Hello hello = new Hello();

        hello.setName("luoxn28");
        hello.setAge(23);
        return hello;
    }

    @Override
    public Class getObjectType() {
        return Hello.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

然后在applicationContext.xml中配置如下，就可以获取Hello类实例了。

<bean id="helloBean" class="com.luoxn28.hello.HelloBeanFactory">
bean>

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

    Hello hello = context.getBean("helloBean", Hello.class);
    System.out.println(hello);
}

 

3 基于注解的Bean配置

• 组件扫描(component scanning):  Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件.
• 特定组件包括:
  • @Component: 基本注解, 标识了一个受 Spring 管理的组件
  • @Respository: 标识持久层组件
  • @Service: 标识服务层(业务层)组件
  • @Controller: 标识表现层组件
• 对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称

　　当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 ：base-package 属性指定一个需要扫描的基类包，Spring 容器将会扫描这个基类包里及其子包中的所有类。当需要扫描多个包时, 可以使用逗号分隔。如果仅希望扫描特定的类而非基包下的所有类，可使用 resource-pattern 属性过滤特定的类，示例：

<context:component-scan base-package="com.luoxn28.hello" resource-pattern="hi/*.class">
context:component-scan>

　　注意： 下可以拥有若干个 和 子节点， 子节点表示要包含的目标类， 子节点表示要排除在外的目标类。

比如Hello类源码如下：

@Component
public class Hello {
    private String name;
    private int age;
...
}

applicationContext.xml配置如下：

<context:component-scan base-package="com.luoxn28.hello">
context:component-scan>

这样就可以在程序中按照如下方式获取了，注意，基于@Component方式时，该Bean实例的id为第一个字母为小写的类名。

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

    Hello hello = context.getBean("hello", Hello.class);
    System.out.println(hello);
}

3.1 组件装配

　　 元素还会自动注册 AutowiredAnnotationBeanPostProcessor 实例, 该实例可以自动装配具有 @Autowired 和 @Resource 、@Inject注解的属性。

使用 @Autowired 自动装配 Bean

　　@Autowired 注解自动装配具有兼容类型的单个 Bean属性

• 构造器, 普通字段(即使是非 public), 一切具有参数的方法都可以应用@Authwired 注解
• 默认情况下, 所有使用 @Authwired 注解的属性都需要被设置. 当 Spring 找不到匹配的 Bean 装配属性时, 会抛出异常, 若某一属性允许不被设置, 可以设置 @Authwired 注解的 required 属性为 false
• 默认情况下, 当 IOC 容器里存在多个类型兼容的 Bean 时, 通过类型的自动装配将无法工作. 此时可以在 @Qualifier 注解里提供 Bean 的名称. Spring 允许对方法的入参标注 @Qualifiter 已指定注入 Bean 的名称
• @Authwired 注解也可以应用在数组类型的属性上, 此时 Spring 将会把所有匹配的 Bean 进行自动装配.
• @Authwired 注解也可以应用在集合属性上, 此时 Spring 读取该集合的类型信息, 然后自动装配所有与之兼容的 Bean.
• @Authwired 注解用在 java.util.Map 上时, 若该 Map 的键值为 String, 那么 Spring 将自动装配与之 Map 值类型兼容的 Bean, 此时 Bean 的名称作为键值

Hello类与源码如下：

@Component
public class Hello {

    @Autowired
    private String name;

    private int age;

    public void test() {
        System.out.println(name.toString() + ": " + age);
    }
...
}

applicationContext.xml配置如下：

class="java.lang.String">
    


package="com.luoxn28.hello">
    
    

程序中就可以按照如下方式获取了:

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

    Hello hello = context.getBean("hello", Hello.class);
    System.out.println(hello);
    hello.test();
}

　　当属性被设置为@Autowired时，注解自动装配具有兼容类型的单个 Bean属性，这里Hello实例装配的就是String实例。

3.2 使用 @Resource 或 @Inject 自动装配 Bean

• Spring 还支持 @Resource 和 @Inject 注解，这两个注解和 @Autowired 注解的功用类似
• @Resource 注解要求提供一个 Bean 名称的属性，若该属性为空，则自动采用标注处的变量或方法名作为 Bean 的名称
• @Inject 和 @Autowired 注解一样也是按类型匹配注入的 Bean， 但没有 reqired 属性
• 建议使用 @Autowired 注解

 

参考资料：

　　1、Spring4.0从入门到精通视频教程（没有答疑服务）

　　2、Spring学习之第一个hello world程序