1 定义 Bean

XML 或注解配置方式，都是表达 Bean 定义的载体，其实质都是为 Spring 容器提供 Bean 定义的信息 。 基于注解的配置方式，从 Spring2.0 开始引入， Spring2.5 完善， Spring4.0 得到了进一步的增强 。

Spring 容器成功启动的三大要件分别是：

• bean 的定义信息。
• bean 的实现类。
• Spring 本身。

如果采用 XML 的配置，则 Bean 的定义信息和 Bean 的实现类本身是分离的 。 而如果采用基于注解的配置方式，则 Bean 的定义信息是通过在 Bean 的实现类上标注注解来实现 。

@Component
public class BookDao {
  ...
}

使用 @Component 注解在 BookDao 类声明处对它进行标注，这样它就可以被 Spring 容器识别， 并把这个类转换为容器管理的 Bean。

它和下面的 XML 配置是等效的：

<bean id="bookDao " class=net.deniro.spring4.anno.BookDao ">

除了 @Component 注解外， Spring 还提供了 3 个功能与 @Component 等效的注解：

之所以提供了这 3 个特定的注解，是为了让标注类本身的用途更清晰，所以，推荐使用这些特定注解来标注功能类。

2 扫描 Bean

Spring 的 context 命名空间提供了通过扫描类包的 Bean 注解定义，来加载 Bean。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd
       ">

    <!-- 扫描包含注解定义的类包-->
    <context:component-scan base-package="net.deniro.spring4.anno"/>

</beans>

配置步骤：

1. 声明 context 命名空间和 schema 文件。
2. 通过 context 命名空间的 component-scan 的 base-package 属性指定一个需要扫描的基类包， Spring 容器会扫描这个基类包里的所有类，并从类的注解信息中获取 Bean 的定义信息 。

如果希望扫描特定的类，那么可以使用 resouce-pattern 属性过滤出特定的类：

<context:component-scan base-package="net.deniro.spring4"
                        resource-pattern="anno/*.class"/>

默认情况下 resource-pattern 属性的值为 **./*.class, 即基类包里所有的类 。 上面的设置，让它仅扫描基类包中的 anno 子包下的类。

resource-pattern 属性会按照资源名称对基类包中的类进行过滤。

<context:component-scan> 提供了 include-filter 与 exclude-filter 子元素，它们可以对需要过滤的包进行更精细的控制。

<context:component-scan base-package="net.deniro.spring4"
                        resource-pattern="anno/*.class">
    <!-- 需要包含的类-->
    <context:include-filter type="aspectj" expression="net.deniro.spring4..*Service+"/>
    <!-- 排除的类-->
    <context:exclude-filter type="regex" expression="net\.deniro\.spring4\.anno.*"/>
</context:component-scan>

• <context:include-filter> 表示要包含的目标类。指定的类路径必须在 base-package 所指定的基本路径下。
• <context:exclude-filter> 表示要排除的目标类。
• 一个 <context:component-scan> 下可以有多个 <context:include-filter> 和 <context:exclude-filter> 元素。

这两个过滤元素支持多种类型的过滤表达式：

这些过滤类型中，除了 custom 类型外， aspectj 的过滤表达能力是最强的，可以轻易地实现其他类型所表达的过滤规则 。

<context:component-scan> 元素有一个 use-default-filters 属性，它的默认值为 true, 表示会扫描标注了 @Component、@Controller、@Service、@Repository 的 Bean。

3 自动装载 Bean

3.1 @Autowired 自动注入

@Service
public class BookService {

    @Autowired
    private AuthorService authorService;

    public AuthorService getAuthorService() {
        return authorService;
    }
}

@Autowired 默认按类型（byType） 匹配的方式在容器中查找，如果有且仅有一个匹配的 Bean 时，Spring 会将其注入到标注了 @Autowired 的变量中。

配置：

<context:component-scan base-package="net.deniro.spring4.anno"/>

单元测试：

BookService bookService= (BookService) context.getBean("bookService");
Assert.assertNotNull(bookService);
Assert.assertNotNull(bookService.getAuthorService());

3.2 @Auotwired 的 required 属性

如果容器中没有一个和标注变量类型匹配的 Bean ，那么 Spring 启动时会抛出 NoSuchBeanDefinitionException 异常 。 如果希望 Spring 即使找不到匹配的 Bean 不需要抛出异常，那么就可以使用 @Autowired(required=false) 对变量进行标注 。 形如：

@Autowired(required = false)
private PressDao pressDao;

3.3 @Qualifier

如果容器中有一个以上匹配的 Bean 时，则可以通过 @Qualifier 注解限定 Bean 的名称 。

假设在 Spring容器中存在两个类型都为 AccountDao 的 Bean：

<bean id="accountDao1" class="net.deniro.spring4.anno.AccountDao" scope="prototype"/>
<bean id="accountDao2" class="net.deniro.spring4.anno.AccountDao" scope="prototype"/>

那么通过 @Qualifier 注解指定需要注入的 Bean：

@Autowired
@Qualifier("accountDao1")
private AccountDao accountDao;

3.4 标注类方法

@Autowired 即可以标注类成员变量，也可以标注方法的入参。

private LogDao logDao;

/**
 * 标注方法
 * @param logDao
 */
@Autowired
public void setLogDao(LogDao logDao) {
    this.logDao = logDao;
}

这里会自动将 LogDao 传给方法入参。

如果一个方法拥有多个入参，在默认情况下，Spring 将自动注入匹配入参类型的 Bean。可以对方法入参标注 @Qualifier 用于指定注入 Bean 的名称 。

@Autowired
public void init(@Qualifier("accountDao1") AccountDao accountDao) {
    System.out.println("accountDao1 被注入");
}

一般情况下， Spring 容器中大部分的 Bean 是单实例的，所以一般无需通过 @Repository、@Service 等注解的 value 属性指定 Bean 的名称，也无须使用 @Qualifier 注解指定名称进行注入 。

虽然 Spring 支持在属性和方法上标注自动注入注解 @Autowired, 但在实践中建议采用在方法上标注 @Autowired 的方式，因为这样更加 “ 面向对象 ” ，也方便编写单元测试， 如果把注解标注在私有属性上，则在单元测试阶段就很难用编程的方式来设置属性值 。

3.5 标注集合类

如果使用 @Autowired 标注了类中的集合类型的变量或者方法入参，那么 Spring 会将容器中所有类型匹配的 Bean 都注入进来 。

public interface Plugin {
}

它有两个实现类：

@Component
public class Plugin1 implements Plugin {
}

@Component
public class Plugin2 implements Plugin {
}

把所有实现了 Plugin 接口的类都注入到下面的 CustomComponent 类的变量中：

@Component
public class CustomComponent {

    /**
     * 把所有类型为 Plugin 的 Bean 都注入这个 List
     */
    @Autowired(required = false)
    private List<Plugin> plugins;

    /**
     * 把所有类型为 Plugin 的 Bean 都注入这个 Map
     * key：Bean 名称；value：所有实现了 Plugin 接口的 Bean
     */
    @Autowired
    private Map<String, Plugin> pluginMap;

    public List<Plugin> getPlugins() {
        return plugins;
    }

    public Map<String, Plugin> getPluginMap() {
        return pluginMap;
    }
}

注入 Map 集合，是 Spring 4 提供的新特性。

单元测试：

CustomComponent component = (CustomComponent) context.getBean("customComponent");
System.out.println("getPluginMap:"+component.getPluginMap());
System.out.println("getPlugins:"+component.getPlugins());
assertFalse(component.getPluginMap().isEmpty());
assertFalse(component.getPlugins().isEmpty());

输出结果：

在默认情况下，这两个 bean 的加载顺序是不确定，在 Spring4 中可以通过 @Order 注解或者实现 Ordered 接口来决定 Bean 加载的顺序，值越小，表示优先级越高 （只对有序的集合类型有效）。

@Component
@Order(value = 1)
public class Plugin2 implements Plugin {
}

测试结果：

可以发现，Plugin2 已经被优先加载。

实践中，系统的插件体系完成可以利用 Spring 的集合注入功能，完成插件的识别与注入工作。

3.6 延迟依赖注入

Spring4 支持延迟依赖注入，即在 Spring 容器时，对标注了 @Lazy 和 @Autowired 注解的 Bean 属性，不会立即注入， 而是到调用该属性时才会注入 。

@Lazy
@Repository
public class LazyDao {
}

LazyDao lazyDao;

@Lazy
@Autowired
public void setLazyDao(LazyDao lazyDao) {
    this.lazyDao = lazyDao;
}

注意：对 Bean 实施延迟依赖注入，@Lazy 注解必须同时标注在属性及目标的 Bean 上 。

3.7 标准注解

Spring 还支持 JSR-250 中定义的 @Resource 和 JSR-330 中定义的 @Inject 注解，这两个标准注解和 @Autowired 注解的功能相似，都能对类的变更及方法入参提供自动注入功能 。

@Resource 注解要求提供一个 Bean 名称的属性，如果属性为空，则自动采用标注处的变量名或者方法名作为 Bean 的名称 。

private ResourceDao resourceDao;

@Resource(name = "resourceDao")
public void setResourceDao(ResourceDao resourceDao) {
    this.resourceDao = resourceDao;
}

如果 @Resource 未指定 name 属性，则会根据属性方法得到需要注入的 Bean 名称 。 @Autowired 默认按照类型匹配注入 bean ， @Resource 默认按照名称匹配注入 Bean。 而 @Inject 和 @Autowired 一样也是按照类型匹配注入 Bean 的，只不过它没有 required 属性 。

可见不管是 @Resource 或者 @Inject 注解，它们的功能都没有 @Autowired 来的丰富，因此除非必要，否则可以忽略这两个注解。

4 @Scope 注解

通过注解配置的 Bean 和通过 <bean> 配置的 Bean 是一样的，默认的作用范围都是 singleton。 Spring 为注解配置提供了一个 @Scope 注解，可以通过它显式地指定 Bean 的作用范围 。

@Scope("prototype")
@Component
public class Press {

}

@Scope 注解通过入参指定 Bean 的作用范围 。

在使用 <bean> 进行配置时，可以通过 init-method 和 destory-method 属性指定 Bean 的初始化及容器销毁前执行的方法 。Spring 从 2.5 开始支持 JSR-250 中定义的 @PostConstruct 和 PreDestory 注解 。 在 Spring 中它们相当于 init-method 和 destroy-method 属性的功能 。不过注解方式更强大，我们可以在一个 bean 中定义多个 @PostConstruct 和 @PreDestory 方法 。

@Component
public class Book {

    @PostConstruct
    private void init1(){
        System.out.println("init1");
    }

    @PostConstruct
    private void init2(){
        System.out.println("init2");
    }

    @PreDestroy
    private void destroy1(){
        System.out.println("destroy1");
    }

    @PreDestroy
    private void destroy2(){
        System.out.println("destroy2");
    }
}

单元测试：

Book book = (Book) context.getBean("book");
((ClassPathXmlApplicationContext) context).destroy();

测试结果：

init1
init2
destroy1
destroy2

可以看出，Spring 先调用了类的构造函数实例化了 Bean ，然后再执行 @Autowired 进行自动注入，接着执行标注了 @PostConstruct 的方法，最后在容器关闭时，执行标注了 @PreDestroy 的方法 。