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配置如下：

<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 组件装配

　　<context:component-scan> 元素还会自动注册 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配置如下：

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

<context:component-scan base-package="com.luoxn28.hello">
<!-- context:exclude-filter type="" expression="" : 子节点指定排除哪些指定的组件 -->
<!-- context:include-filter type="" expression="" : 子节点指定包含哪些指定的组件 -->
</context:component-scan>

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

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程序