本教程先通过xml配置方式，引渡到使用注解的方式，重点讲注解的使用

通过xml配置文件配置包扫描的方式

创建xml配置文件

创建文件：src/main/resources/scan.xml
代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  6.     <context:component-scan base-package="com.tonyliu"/>
  7. </beans>

节点<context:component-scan>指定包扫描，base-package指定要扫描的包范围
在base-package指定的包内的类，只要但不限于使用以下下注解，都会被扫描到并注册到IOC容器中
@Controller、@Component、@Service、@Repository

创建需要扫描的类文件

将使用@Controller、@Service、@Repository这三个注解，创建3个类，用于测试扫描包的配置
创建文件：src/main/java/com/tonyliu/controller/BookController.java，代码如下

  1. package com.tonyliu.controller;
  3. import org.springframework.stereotype.Controller;
  5. @Controller
  6. public class BookController {
  7. }

创建文件：src/main/java/com/tonyliu/service/BookService.java，代码如下

  1. package com.tonyliu.service;
  3. import org.springframework.stereotype.Service;
  5. @Service
  6. public class BookService {
  7. }

创建文件：src/main/java/com/tonyliu/dao/BookDao.java，代码如下

  1. package com.tonyliu.dao;
  3. import org.springframework.stereotype.Repository;
  5. @Repository
  6. public class BookDao {
  7. }

引入单元测试依赖

接下来我们来做个测试，将使用单元测试的方式运行程序进行测试
引入单元测试依赖

  1. <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
  2. <dependency>
  3.     <groupId>org.junit.jupiter</groupId>
  4.     <artifactId>junit-jupiter-api</artifactId>
  5.     <version>5.6.2</version>
  6.     <scope>test</scope>
  7. </dependency>

书写单元测试方法

书写单元测试方法，打印IOC容器中注册组件的名字，代码如下

  1. @Test
  2. public void test01() {
  3.     ApplicationContext applicationContext = new ClassPathXmlApplicationContext("scan.xml");
  4.     String[] names = applicationContext.getBeanDefinitionNames();
  5.     for (String name : names) {
  6.         System.out.println(name);
  7.     }
  8. }

结果如下，会打印出扫描到的组件名字，忽略其他打印的内容
image.png
变更测试，将xml配置文件中的base-package的值变更为base-package=”com.tonyliu.controller”之后，在运行一下测试程序，结果如下
image.png

通过注解配置包扫描方式

涉及注解 @Configuration @ComponentScan @ComponentScans

主要讲解@ComponentScan注解

@ComponentScan注解说明

  • 将添加特定注解的类注册到IOC容器中
  • @ComponentScan注解和@Configuration注解一同使用
  • 和xml配置文件中的<context:component-scan>元素功能相同
  • 该注解可以设置需要扫描的类、包等和需要排除扫描的类、包等

@ComponentScan注解的定义

  1. package org.springframework.context.annotation;
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Repeatable;
  6. import java.lang.annotation.Retention;
  7. import java.lang.annotation.RetentionPolicy;
  8. import java.lang.annotation.Target;
  10. import org.springframework.beans.factory.support.BeanNameGenerator;
  11. import org.springframework.core.annotation.AliasFor;
  12. import org.springframework.core.type.filter.TypeFilter;
  14. @Retention(RetentionPolicy.RUNTIME)
  15. @Target(ElementType.TYPE)
  16. @Documented
  17. @Repeatable(ComponentScans.class)
  18. public @interface ComponentScan {
  20.     @AliasFor("basePackages")
  21.     String[] value() default {};
  23.     @AliasFor("value")
  24.     String[] basePackages() default {};
  26.     Class<?>[] basePackageClasses() default {};
  28.     Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
  30.     Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
  32.     ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
  34.     String resourcePattern() default ClassPathScanningCandidateComponentProvider.DEFAULT_RESOURCE_PATTERN;
  36.     boolean useDefaultFilters() default true;
  38.     Filter[] includeFilters() default {};
  40.     Filter[] excludeFilters() default {};
  42.     boolean lazyInit() default false;
  44.     @Retention(RetentionPolicy.RUNTIME)
  45.     @Target({})
  46.     @interface Filter {
  48.         FilterType type() default FilterType.ANNOTATION;
  50.         @AliasFor("classes")
  51.         Class<?>[] value() default {};
  53.         @AliasFor("value")
  54.         Class<?>[] classes() default {};
  56.         String[] pattern() default {};
  57.     }
  58. }

@ComponentScan注解的使用

创建一个配置类文件
创建文件：src\main\java\com\tonyliu\config\ScanConfig.java

  1. package com.tonyliu.config;
  3. import org.springframework.context.annotation.Configuration;
  5. @Configuration
  6. public class ScanConfig {
  7. }

测试代码

  1. @Test
  2. public void test02(){
  3.     ApplicationContext applicationContext = new AnnotationConfigApplicationContext(ScanConfig.class);
  4.     String[] names = applicationContext.getBeanDefinitionNames();
  5.     for (String name : names) {
  6.         System.out.println(name);
  7.     }
  8. }

扫描指定包下可以注册的组件

  1. package com.tonyliu.config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  6. @Configuration
  7. @ComponentScan(value = "com.tonyliu")
  8. public class ScanConfig {
  9. }

value：指定要扫描的包范围com.tonyliu

测试代码运行结果
image.png

排除需要扫描注册的组件

  1. package com.tonyliu.config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.FilterType;
  6. import org.springframework.stereotype.Controller;
  7. import org.springframework.stereotype.Repository;
  9. @Configuration
  10. @ComponentScan(value = "com.tonyliu",excludeFilters = {
  11.         @ComponentScan.Filter(type=FilterType.ANNOTATION,value = {Controller.class, Repository.class})
  12. })
  13. public class ScanConfig {
  14. }

使用属性excludeFilters排除需要扫描注册的类型：Filter[] excludeFilters() default {};
该属性是一个Filter类型的数组形式，Filter类型在@ComponentScan注解中被定义
Filter中的属性type指定需要按照哪种规则进行筛选
上面是我们示例要排除添加了@Controller、@Repository这两个注解的类
tip：直接中的数组类型使用{}包裹，中间用逗号分隔

只包含需要注册的组件

  1. package com.tonyliu.config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.FilterType;
  6. import org.springframework.stereotype.Controller;
  7. import org.springframework.stereotype.Repository;
  9. @Configuration
  10. @ComponentScan(value = "com.tonyliu", includeFilters = {
  11.         @ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class, Repository.class})
  12. }, useDefaultFilters = false)
  13. public class ScanConfig {
  14. }

includeFilters：只包含需要注册的组件规则
注：使用该规则需要将useDefaultFilters设置为false，筛选规则时才是只包含的关系，对应xml配置文件的use-default-filters熟悉，示例

  1. <context:component-scan base-package="com.tonyliu.controller" use-default-filters="false"/>

组合注解的使用

可以设置@ComponentScan的组合模式，详见代码

  1. package com.tonyliu.config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.ComponentScans;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.context.annotation.FilterType;
  7. import org.springframework.stereotype.Controller;
  8. import org.springframework.stereotype.Repository;
  10. @Configuration
  11. @ComponentScans(
  12.         value = {
  13.                 @ComponentScan(value = "com.tonyliu", includeFilters = {
  14.                         @ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class})
  15.                 }, useDefaultFilters = false),
  16.                 @ComponentScan(value = "com.tonyliu", includeFilters = {
  17.                         @ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Repository.class})
  18.                 }, useDefaultFilters = false)
  19.         }
  20. )
  21. public class ScanConfig {
  22. }

FilterType讲解

  1. public enum FilterType {
  3.     /**
  4.      * 按照注解规则筛选
  5.      */
  6.     ANNOTATION,
  8.     /**
  9.      * 按照类型筛选
  10.      */
  11.     ASSIGNABLE_TYPE,
  13.     /**
  14.      * 按照ASPECTJ表达式筛选
  15.      */
  16.     ASPECTJ,
  18.     /**
  19.      * 按照正则表达式筛选
  20.      */
  21.     REGEX,
  23.     /** Filter candidates using a given custom
  24.      * {@link org.springframework.core.type.filter.TypeFilter} implementation.
  25.      * 自定义筛选规则
  26.      */
  27.     CUSTOM
  29. }

CUSTOM自定义筛选规则的使用

根据文档可知，使用该方式需要实现org.springframework.core.type.filter.TypeFilter这个接口
org.springframework.core.type.filter.TypeFilter接口的定义如下

  1. package org.springframework.core.type.filter;
  3. import java.io.IOException;
  5. import org.springframework.core.type.classreading.MetadataReader;
  6. import org.springframework.core.type.classreading.MetadataReaderFactory;
  8. @FunctionalInterface
  9. public interface TypeFilter {
  11.     /**
  12.      * Determine whether this filter matches for the class described by
  13.      * the given metadata.
  14.      * @param metadataReader 读取到的当前的正在扫描的类的信息
  15.      * @param metadataReaderFactory 可以获取到其他任何类的信息
  16.      * @return whether this filter matches
  17.      * @throws IOException in case of I/O failure when reading metadata
  18.      */
  19.     boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
  20.             throws IOException;
  21. }

创建文件实现该接口：

  1. package com.tonyliu.config;
  3. import org.springframework.core.io.Resource;
  4. import org.springframework.core.type.AnnotationMetadata;
  5. import org.springframework.core.type.ClassMetadata;
  6. import org.springframework.core.type.classreading.MetadataReader;
  7. import org.springframework.core.type.classreading.MetadataReaderFactory;
  8. import org.springframework.core.type.filter.TypeFilter;
  10. import java.io.IOException;
  12. public class MyTypeFilter implements TypeFilter {
  13.     public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
  14.         // 获取当前类注解的信息
  15.         AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
  16.         // 获取当前正在扫描类的类的信息
  17.         ClassMetadata classMetadata = metadataReader.getClassMetadata();
  18.         // 获取当前类的资源信息（类的路径等）
  19.         Resource resource = metadataReader.getResource();
  21.         String className = classMetadata.getClassName();
  23.         if (className.equals("com.tonyliu.controller.BookController")) {
  24.             return true;
  25.         }
  27.         return false;
  28.     }
  29. }

测试代码运行结果
image.png