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 的生命周期
- 通过构造器或工厂方法创建 Bean 实例
- 为 Bean 的属性设置值和对其他 Bean 的引用
- 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
- 调用 Bean 的初始化方法
- 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
- Bean 可以使用了
- 当容器关闭时, 调用 Bean 的销毁方法
2.7 通过静态工厂和实例工厂创建Bean
通过调用静态工厂方法创建 Bean
- 调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
- 要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 <constrctor-arg> 元素为该方法传递方法参数.
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 属性值标识组件的名称
<context:component-scan base-package="com.luoxn28.hello" resource-pattern="hi/*.class"> </context:component-scan>
@Component public class Hello { private String name; private int age; ... }
applicationContext.xml配置如下:
<context:component-scan base-pa以上是关于Spring之IoC总结帖的主要内容,如果未能解决你的问题,请参考以下文章