Spring之IoC总结帖

Posted luoxn28

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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。

<bean id="msg" class="java.lang.String">
    <constructor-arg value="string"/>
</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 的属性值或依赖的对象,使用 <property> 元素, 使用 name 属性指定 Bean 的属性名称,value 属性或 <value> 子节点指定属性值,属性注入是实际应用中最常用的注入方式。属性注入Bean类须有一个默认的构造方法。

<!-- Hello类中有一个String类型的msg属性 -->
<bean id="hello" class="com.luoxn28.Hello">
    <property name="msg" value="luoxn28"/>
</bean>

构造方法注入

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

<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> 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用。也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean。

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

<!-- Hello类中有一个String类型的msg属性 -->
<bean id="hello" class="com.luoxn28.Hello">
    <property name="msg" ref="msg"/>
</bean>

内部Bean

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

<!-- Hello类中有一个String类型的msg属性 -->
<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 标签(例如: <list>, <set> 或 <map>) 来配置集合属性。
  • 配置 java.util.List 类型的属性, 需要指定 <list> 标签, 在标签里包含一些元素. 这些标签可以通过 <value> 指定简单的常量值, 通过 <ref> 指定对其他 Bean 的引用. 通过<bean> 指定内置 Bean 定义. 通过 <null/> 指定空元素. 甚至可以内嵌其他集合。
  • 数组的定义和 List 一样, 都使用 <list>
  • 配置 java.util.Set 需要使用 <set> 标签, 定义元素的方法与 List 一样.
  • Java.util.Map 通过 <map> 标签定义, <map> 标签里可以使用多个 <entry> 作为子标签. 每个条目包含一个键和一个值. 必须在 <key> 标签里定义键。因为键和值的类型没有限制, 所以可以自由地为它们指定 <value>, <ref>, <bean> 或 <null> 元素. 可以将 Map 的键和值作为 <entry> 的属性定义: 简单常量使用 key 和 value 来定义; Bean 引用通过 key-ref 和 value-ref 属性定义。

  • 使用 <props> 定义 java.util.Properties, 该标签使用多个 <prop> 作为子标签. 每个 <prop> 标签必须定义 key 属性。
<!-- CollectionClass类有3个属性,List<String> list、Set<String> set、Map<String, String> map-->
<bean id="collectionClass" class="com.luoxn28.CollectionClass">
    <property name="list">
        <list>
            <value>luoxn28</value>
            <value>luoxn29</value>
            <value>luoxn30</value>
        </list>
    </property>
    <property name="set">
        <set>
            <value>luoxn28</value>
            <value>luoxn29</value>
            <value>luoxn30</value>
        </set>
    </property>
    <property name="map">
        <map>
            <entry key="str1" value="luoxn28"/>
            <entry key="str2"><value>luoxn29</value></entry>
            <entry key="str3"><value>luoxn30</value></entry>
        </map>
    </property>
</bean>

1.6 使用p命名空间

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

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

<!-- Hello类中有一个String类型的msg属性 -->
<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. 需要做的仅仅是在 <bean> 的 autowire 属性里指定自动装配的模式

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

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

<!-- 这里为什么不会自动注入msg呢 -->
<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 作为模板, 可以设置 <bean> 的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean
  • 并不是 <bean> 元素里的所有属性都会被继承. 比如: autowire, abstract 等.
  • 也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true
<bean id="person" class="com.luoxn28.Person" p:name="luoxn28" p:age="23">
</bean>

<!-- 这里使用到了bean配置的继承,指定属性继承哪个bean。配置注意: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 中, 可以在 <bean> 元素的 scope 属性里设置 Bean 的作用域.。默认情况下, Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一个实例, 整个 IOC 容器范围内都能共享该实例:所有后续的 getBean() 调用和 Bean 引用都将返回这个唯一的 Bean 实例.该作用域被称为 singleton, 它是所有 Bean 的默认作用域。

<!-- Hello对象每次获取都会新建 -->
<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>

<!-- 引用其他对象的属性或方法,通过T()来调用一个类的静态方法,它将返回一个Class Object,然后在调用响应的方法或属性 -->
<bean id="hello2" class="com.luoxn28.Hello">
    <!-- <property name="msg" value="#{T(java.lang.String).valueOf(123)}"/>  使用spel为属性配置一个字面值 -->
    <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 属性里指定工厂方法的名称. 最后, 使用 <constrctor-arg> 元素为该方法传递方法参数.
比如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> {
    // 返回的实例
    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<Hello> {

    @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 的配置文件中声明 <context:component-scan> :base-package 属性指定一个需要扫描的基类包,Spring 容器将会扫描这个基类包里及其子包中的所有类。当需要扫描多个包时, 可以使用逗号分隔。如果仅希望扫描特定的类而非基包下的所有类,可使用 resource-pattern 属性过滤特定的类,示例:
<context:component-scan base-package="com.luoxn28.hello" resource-pattern="hi/*.class">
</context:component-scan>
  注意:<context:component-scan> 下可以拥有若干个 <context:include-filter> 和 <context:exclude-filter> 子节点,<context:include-filter> 子节点表示要包含的目标类,<context:exclude-filter> 子节点表示要排除在外的目标类。
比如Hello类源码如下:
@Component
public class Hello {
    private String name;
    private int age;
...
}

applicationContext.xml配置如下: