Spring 自动扫描与装配

通常你可以在 xml 配置文件中，声明一个 bean 或者 component，然后 Spring 容器会检查和注册你的 bean 或 component。

实际上，Spring 支持自动扫描 bean 或 component，你可以不必再在 xml 文件中繁琐的声明 bean，Spring 会自动扫描并检查你指定包的 bean 或 component。以下列举一个简单的 Spring Project，包含了 Controller、Service、DAO 层，由此分析下手动配置和自动扫描的不同。

首先创建一个新的 maven 工程 SpringAuto，打开 Terminal，选择 File->Open New Terminal，在终端中输入：

mvn archetype:generate -DgroupId=com.shiyanlou.spring -DartifactId=SpringAuto -DarchetypeArtifactId=maven-archetype-quickstart

选择 File->Open Workspace 切换工作空间，选择 SpringAuto 目录，必须切换到该目录下，否则识别不了项目。

修改 pom.xml 文件，添加 Spring 的依赖：

<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.shiyanlou.spring</groupId>
    <artifactId>SpringAuto</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>SpringAuto</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.1.1.RELEASE</spring.version>

    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
</project>

手动配置 component

先看一下正常手动配置一个 bean。

DAO 层，创建包 com.shiyanlou.spring.dao，创建 CustomerDAO.java。

内容如下：

package com.shiyanlou.spring.dao;

public class CustomerDAO {
    @Override
    public String toString(){
        return "Hello , This is CustomerDAO";
    }
}

Service 层，创建包 com.shiyanlou.spring.services，创建 CustomerService.java 内容如下：

package com.shiyanlou.spring.services;

import com.shiyanlou.spring.dao.CustomerDAO;

public class CustomerService {
    CustomerDAO customerDAO;

    public void setCustomerDAO(CustomerDAO customerDAO) {
        this.customerDAO = customerDAO;
    }

    @Override
    public String toString() {
        return "CustomerService [customerDAO = " + customerDAO + "]";
    }
}

在目录 src/main/resources 创建并配置 SpringCustomer.xml 文件：

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

    <bean id = "customerService" class = "com.shiyanlou.spring.services.CustomerService">
        <property name = "customerDAO" ref = "customerDAO" />
    </bean>

    <bean id = "customerDAO" class = "com.shiyanlou.spring.dao.CustomerDAO" />

</beans>

最后，创建 App.java 文件，在包路径 com.shiyanlou.spring.common 下。内容如下：

package com.shiyanlou.spring.common;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.shiyanlou.spring.services.CustomerService;

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

        CustomerService cust = (CustomerService)context.getBean("customerService");
        System.out.println(cust);

    }
}

运行

mvn compile
mvn exec:java -Dexec.mainClass="com.shiyanlou.spring.common.App"

实验结果如下：

自动扫描组件

用注释 @Component 来表示这个 Class 是一个自动扫描组件。CustomerDAO.java 的内容如下：

package com.shiyanlou.spring.dao;

import org.springframework.stereotype.Component;

@Component
public class CustomerDAO
{
    @Override
    public String toString() {
        return "Hello , This is CustomerDAO";
    }
}

CustomerService.java 的内容如下：

package com.shiyanlou.spring.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.shiyanlou.spring.dao.CustomerDAO;

@Component
public class CustomerService
{
    @Autowired
    CustomerDAO customerDAO;

    @Override
    public String toString() {
        return "CustomerService [customerDAO=" + customerDAO + "]";
    }
}

配置文件 SpringCustomer.xml 如下

<?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/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

    <context:component-scan base-package = "com.shiyanlou.spring"/>

</beans>

注意：以上 xml 文件中，加入了 context:component-scan 标签，beans 中也加入了标签，这样就将 Spring 的自动扫描特性引入，base-package 表示组件的存放位置，Spring 将扫描对应文件夹下的 bean（用 @Component 注释过的），将这些 bean 注册到容器中。

最后运行结果与手动配置的结果一致。

自定义扫描组件名称

上例中，默认情况下，Spring 将把组件 Class 的第一个字母变成小写，来作为自动扫描组件的名称，例如将 CustomerService 转变为 customerService，你可以用 customerService 这个名字调用组件，如下：

CustomerService cust = (CustomerService)context.getBean("customerService");

也可以像下面这样，创建自定义的组件名称：

@Service("AAA")
public class CustomerService
...

但是得添加下面的代码：

import org.springframework.stereotype.Service;

可以调用自己定义的组件了，如下：

CustomerService cust = (CustomerService)context.getBean("AAA");

自动扫描组件的注释类型

有 4 种注释类型，分别是：

1、@Component —— 表示一个自动扫描 component。
2、@Repository —— 表示持久化层的 DAO component。
3、@Service —— 表示业务逻辑层的 Service component。
4、@Controller —— 表示表示层的 Controller component。

在项目中，我们可以将所有自动扫描组件都用 @Component 注释，Spring 将会扫描所有用 @Component 注释过得组件。实际上，@Repository 、@Service 、@Controller 三种注释是为了加强代码的阅读性而创造的，可以在不同的应用层中，用不同的注释，我们可以在上一个项目的基础上改一下注释，如下：
DAO 层：

package com.shiyanlou.spring.dao;

import org.springframework.stereotype.Repository;

@Repository
public class CustomerDAO
{
    @Override
    public String toString() {
        return "Hello , This is CustomerDAO";
    }
}

Service 层：

package com.shiyanlou.spring.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.shiyanlou.spring.dao.CustomerDAO;

@Service
public class CustomerService
{
    @Autowired
    CustomerDAO customerDAO;

    @Override
    public String toString() {
        return "CustomerService [customerDAO=" + customerDAO + "]";
    }
}

自动扫描中过滤组件

1). Filter Component - include

下例演示了用 “filter” 自动扫描注册组件，这些组件只要匹配定义的 “regex” 的命名规则，Class 前就不需要用 @Component 进行注释。

DAO 层，CustomerDAO.java 如下:

package com.shiyanlou.spring.dao;

public class CustomerDAO
{
    @Override
    public String toString() {
        return "Hello , This is CustomerDAO";
    }
}

Service 层，CustomerService.java 如下：

package com.shiyanlou.spring.services;

import org.springframework.beans.factory.annotation.Autowired;
import com.shiyanlou.spring.dao.CustomerDAO;

public class CustomerService
{
    @Autowired
    CustomerDAO customerDAO;

    @Override
    public String toString() {
        return "CustomerService [customerDAO=" + customerDAO + "]";
    }

}

SpringFiltering.xml 配置如下：

 <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/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

    <context:component-scan base-package = "com.shiyanlou.spring" >

        <context:include-filter type = "regex"
                       expression = "com.shiyanlou.spring.dao.*DAO.*" />

        <context:include-filter type = "regex"
                       expression = "com.shiyanlou.spring.services.*Service.*" />

    </context:component-scan>

</beans>

以上 xml 文件中，所有文件名字，只要包含 DAO 和 Service（ DAO._，_Service. ）关键字的，都将被检查注册到 Spring 容器中。

创建 App.java 并运行如下：

package com.shiyanlou.spring.common;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.lei.customer.services.CustomerService;

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

        CustomerService cust = (CustomerService)context.getBean("customerService");
        System.out.println(cust);

    }
}

运行结果与之前相同。

2). Filter Component——exclude
也可以用 exclude，制定组件避免被 Spring 发现并被注册到容器中。以下配置排除用 @Service 注释过的组件：

<context:component-scan base-package = "com.shiyanlou.spring" >
        <context:exclude-filter type = "annotation"
            expression = "org.springframework.stereotype.Service" />
</context:component-scan>

以下配置排除包含 DAO 关键字的组件：

<context:component-scan base-package = "com.shiyanlou.spring" >
        <context:exclude-filter type = "regex"
            expression = "com.shiyanlou.spring.dao.*DAO.*" />
</context:component-scan>

excludeFilters 是指明哪些类不被扫描到
相应地
includeFilters 是指明只扫描哪些类