@ComponentScan注解 -【Spring底层原理】

最新推荐文章于 2024-07-12 12:44:48 发布

2401_85767310

最新推荐文章于 2024-07-12 12:44:48 发布

阅读量670

点赞数 24

文章标签： spring java 后端

本文链接：https://blog.csdn.net/2401_85767310/article/details/139744948

版权

@ComponentScan注解 -【Spring底层原理】

一、注解用法

1. 背景知识

2. @ComponentScan注解作用

二、实例分析

1. excludeFilters=Filter[ ]

2. includeFilters=filter[ ]

3. `FilterType.CUSTOM`

三、源码追踪

@ComponentScan注解 -【Spring底层原理】

案例已上传GitHub，欢迎star：https://github.com/oneStarLR/spring-annotation

一、注解用法

1. 背景知识

什么是组件？

组件也是抽象的概念，可以理解为一些符合某种规范的类组合在一起就构成了组件，他可以提供某些特定的功能，但实际他们都是类，只不过有他们特殊的规定。组件和类的关系:符合某种规范的类的组合构成组件。

2. @ComponentScan注解作用

1. 将组件自动加载到容器

加了包扫描@ComponentScan注解后，只要标注了@Controller、@Service、@Repository、@Component注解中的任何一个，其组件都会被自动扫描，加入到容器中。

2. 通过属性指定扫描

【1】value：指定要扫描的包

【2】excludeFilters=Filter[ ]：设置排除的过滤条件，指定扫描的时候按照什么规则排除哪些组件，不扫描哪些包

【3】includeFilters=filter[ ]：设置扫描过滤条件，指定扫描的时候按照什么规则包含哪些组件，满足该条件才进行扫描

【4】自定义过滤规则：通过实现TypeFilter接口，自定义过滤规则

下面咱们通过实例来分析一下@ComponentScan注解的作用

二、实例分析

以maven项目为例，通过@ComponentScan、@Controller、@Service、@Repository注解获取容器中的对象：

// 启动类

@Test

public void TestMain(){

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

String[] beanNames = applicationContext.getBeanDefinitionNames();

for(String beanName : beanNames){

System.out.println(“容器中对象名称：”+beanName);

}

// 配置类

@Configuration

@ComponentScan(value = “com.onestar”)

public class AppConfig {

}

// 控制层

@Controller

public class UserController {

}

// 业务层

@Service

public class UserService {

}

// 持久层

@Repository

public class UserDao {

}

运行测
试类，可以看到如下打印信息，除了spring启动时注入到容器的对象外，还有我们自己加了注解，被spring扫描，加入到容器中

@ComponentScan(value = "com.onestar")：value表示指定要扫描的包

点进@ComponentScan注解源码，我们可以看到，使用value可以指定要扫描的包，我们还可以排除要扫描的包，包含要扫描的包，甚至还可以自定义过滤规则

excludeFilters=Filter[ ]：指定扫描的时候按照什么规则排除哪些包
includeFilters=filter[ ]：指定扫描的时候是需要包含哪些包

【@ComponentScan源码】

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.TYPE})

@Documented

@Repeatable(ComponentScans.class)

public @interface ComponentScan {

// 扫描路径

@AliasFor(“basePackages”)

String[] value() default {};

// 扫描路径

@AliasFor(“value”)

String[] basePackages() default {};

// 指定扫描类

Class<?>[] basePackageClasses() default {};

/**

* 命名注册的Bean，可以自定义实现命名Bean，

* 1、@ComponentScan(value = “spring.annotation.componentscan”,nameGenerator = MyBeanNameGenerator.class)

* MyBeanNameGenerator.class 需要实现 BeanNameGenerator 接口，所有实现BeanNameGenerator 接口的实现类都会被调用

* 2、使用 AnnotationConfigApplicationContext 的 setBeanNameGenerator方法注入一个BeanNameGenerator

* BeanNameGenerator beanNameGenerator = (definition,registry)-> String.valueOf(new Random().nextInt(1000));

* AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();

* annotationConfigApplicationContext.setBeanNameGenerator(beanNameGenerator);

* annotationConfigApplicationContext.register(MainConfig2.class);

* annotationConfigApplicationContext.refresh();

* 第一种方式只会重命名@ComponentScan扫描到的注解类

* 第二种只有是初始化的注解类就会被重命名

* 列如第一种方式不会重命名 @Configuration 注解的bean名称，而第二种就会重命名 @Configuration 注解的Bean名称

Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

/**

* 用于解析@Scope注解，可通过 AnnotationConfigApplicationContext 的 setScopeMetadataResolver 方法重新设定处理类

* ScopeMetadataResolver scopeMetadataResolver = definition -> new ScopeMetadata(); 这里只是new了一个对象作为演示，没有做实际的逻辑操作

* AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();

* annotationConfigApplicationContext.setScopeMetadataResolver(scopeMetadataResolver);

* annotationConfigApplicationContext.register(MainConfig2.class);

* annotationConfigApplicationContext.refresh();

* 也可以通过@ComponentScan 的 scopeResolver 属性设置

*@ComponentScan(value = “spring.annotation.componentscan”,scopeResolver = MyAnnotationScopeMetadataResolver.class)

Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;

// 设置类的代理模式

ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;

/**

* 扫描路径如 resourcePattern = “**/*.class”

* 使用 includeFilters 和 excludeFilters 会更灵活

String resourcePattern() default “**/*.class”;

/**

* 指示是否应启用对带有{@code @Component}，{@ code @Repository}，

* {@ code @Service}或{@code @Controller}注释的类的自动检测。

boolean useDefaultFilters() default true;

/**

* 对被扫描的包或类进行过滤，若符合条件，不论组件上是否有注解，Bean对象都将被创建

* @ComponentScan(value = “com.onestar”,includeFilters = {

* @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class}),

* @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {UserDao.class}),

* @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class}),

* @ComponentScan.Filter(type = FilterType.ASPECTJ, pattern = “spring.annotation…*”),

* @ComponentScan.Filter(type = FilterType.REGEX, pattern = “¹+Dao$”)

* },useDefaultFilters = false)

* useDefaultFilters 必须设为 false

ComponentScan.Filter[] includeFilters() default {};

// 设置排除的过滤条件，指定扫描的时候按照什么规则排除哪些组件，排除要扫描的包，用法参考includeFilters

ComponentScan.Filter[] excludeFilters() default {};

/**

* 指定是否应注册扫描的Bean以进行延迟初始化。

* @ComponentScan(value = “com.onestar”,lazyInit = true)

boolean lazyInit() default false;

// @Filter注解，用于 includeFilters 或 excludeFilters 的类型筛选器

@Retention(RetentionPolicy.RUNTIME)

@Target({})

public @interface Filter {

/**

* 要使用的过滤器类型，默认为 ANNOTATION 注解类型

* @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})

FilterType type() default FilterType.ANNOTATION;

/**

* 过滤器的参数，参数必须为class数组，单个参数可以不加大括号

* 只能用于 ANNOTATION 、ASSIGNABLE_TYPE 、CUSTOM 这三个类型

* @ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class, Service.class})

* @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {UserDao.class})

* @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})

@AliasFor(“classes”)

Class<?>[] value() default {};

/**

* 作用同上面的 value 相同

* ANNOTATION 参数为注解类，如 Controller.class, Service.class, Repository.class

* ASSIGNABLE_TYPE 参数为类，如 UserDao.class

* CUSTOM 参数为实现 TypeFilter 接口的类，如 MyTypeFilter.class

* MyTypeFilter 同时还能实现 EnvironmentAware，BeanFactoryAware，BeanClassLoaderAware，ResourceLoaderAware

* 这四个接口

* EnvironmentAware

* 此方法用来接收 Environment 数据，主要为程序的运行环境，Environment 接口继承自 PropertyResolver 接口，

* 详细内容在下方

* @Override

* public void setEnvironment(Environment environment) {

* String property = environment.getProperty(“os.name”);

* }

* BeanFactoryAware

* BeanFactory Bean容器的根接口，用于操作容器，如获取bean的别名、类型、实例、是否单例的数据

* @Override

* public void setBeanFactory(BeanFactory beanFactory) throws BeansException {

* Object bean = beanFactory.getBean(“BeanName”)

* }

* BeanClassLoaderAware

* ClassLoader 是类加载器，在此方法里只能获取资源和设置加载器状态

* @Override

* public void setBeanClassLoader(ClassLoader classLoader) {

* ClassLoader parent = classLoader.getParent();

* }

* ResourceLoaderAware

* ResourceLoader 用于获取类加载器和根据路径获取资源

* public void setResourceLoader(ResourceLoader resourceLoader) {

* ClassLoader classLoader = resourceLoader.getClassLoader();

* }

@AliasFor(“value”)

Class<?>[] classes() default {};

/**

* 这个参数是 classes 或 value 的替代参数，主要用于 ASPECTJ 类型和 REGEX 类型

* ASPECTJ 为 ASPECTJ 表达式

* @ComponentScan.Filter(type = FilterType.ASPECTJ, pattern = “com.onestar…*”)

* REGEX 参数为正则表达式

* @ComponentScan.Filter(type = FilterType.REGEX, pattern = “²+Dao$”)

String[] pattern() default {};

}

1. excludeFilters=Filter[ ]

通过excludeFilters=Filter[ ]来排除要扫描的包，在配置类注解中修改：

@Configuration

@ComponentScan(value = “com.onestar”,excludeFilters = {

@Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})})

public class AppConfig {

}

type：表示过滤类型，这里是按照注解进行过滤
classes：表示过滤器参数，这里是过滤掉有@Controller和@Service注解的组件

查看源码我们可以得知，通过实现Filter接口的type属性用于设置过滤类型，默认值为FilterType.ANNOTATION，提供了这几个过滤类型：

FilterType.ANNOTATION：按照注解过滤

FilterType.ASSIGNABLE_TYPE：按照给定的类型过滤

FilterType.ASPECTJ：按照ASPECTJ表达式过滤

FilterType.REGEX：按照正则表达式过滤

FilterType.CUSTOM：按照自定义规则过滤

classes和value属性为过滤器的参数，必须为class数组，类只能为以下三种类型：

ANNOTATION 参数为注解类，如 Controller.class, Service.class, Repository.class

ASSIGNABLE_TYPE 参数为类，如 UserDao.class

CUSTOM 参数为实现 TypeFilter 接口的类，如 MyTypeFilter.class

通过上面的excludeFilters注解配置，咱们再来运行一下测试类，打印信息如下，可以看到，标有@Controller和@Service注解的组件不被扫描：

2. includeFilters=filter[ ]

通过includeFilters=Filter[ ]只需要包含要扫描的包，在配置类注解中修改，默认的规则是扫描value下所有的包，所以我们要禁用这个规则：

@Configuration

@ComponentScan(value = “com.onestar”,includeFilters = {

@Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})},useDefaultFilters = false)

public class AppConfig {

}

useDefaultFilters = false：禁用默认扫描规则

通过上面的includeFilters注解配置，咱们再来运行一下测试类，打印信息如下，可以看到，标有@Controller和@Service注解的组件才被扫描：

3. `FilterType.CUSTOM`

上面提到，可以使用FilterType.CUSTOM按照自定义规则进行过滤，通过源码，我们知道，可以实现TypeFilter的实现类来进行自定义过滤

public class MyTypeFilter implements TypeFilter {

/**

* @description TODO

* @author ONESTAR

* @date 2021/1/20 14:29

* @param metadataReader:读取到当前正在扫描的类的信息

* @param metadataReaderFactory：可以获取到其他任何类的信息

* @throws

* @return boolean

@Override

public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {

// 获取当前类注解的信息

AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();

// 获取当前正在扫描的类的信息

ClassMetadata classMetadata = metadataReader.getClassMetadata();

// 获取当前类资源

Resource resource = metadataReader.getResource();

String className = classMetadata.getClassName();

// 指定包含“serv”的组件进行扫描

if(className.contains(“serv”)){

return true;

}

return false;

}

该实现类通过获取当前所有资源组件，并进行指定扫描，这里包含“serv”的组件进行扫描，然后修改配置类指定自定义扫描规则：

@Configuration

@ComponentScan(value = “com.onestar”,includeFilters = {

@Filter(type = FilterType.CUSTOM,classes = {MyTypeFilter.class})},useDefaultFilters = false)

public class AppConfig {

}

MyTypeFilter.class：指定自定义过滤参数

运行测试类，可以看到打印信息，包含“serv”的组件进行扫描：

三、源码追踪

同样，咱们以AnnotationConfigApplicationContext类为入口，点进去跟踪源码：

通过refresh()跟踪Bean 工厂的后置处理器调用：

继续跟踪，查看源码，这里实例化并调用所有已注册的BeanFactoryPostProcessor：

继续跟踪，主方法中有一些加载顺序之类的，找到invokeBeanDefinitionRegistryPostProcessors，查看调用Bean的注册定义的后置处理器的方法，进入源码查看：

继续跟踪，这里有个循环，会把所有的处理器拿出来进行处理：

继续跟踪，可以看到是一个接口，进入查看实现类，我们可以看到一个配置Bean的定义，就是指我们Configuration配置的里面的一些Bean的定义：

继续跟踪，processConfigBeanDefinitions类中可以看到Configuration类的解析器，通过parser.parse(candidates);把要扫描的东西进行解析

继续跟踪，判断我们声明的是否是一个注解Bean，是的话，再进行解析

继续跟踪：

继续跟踪，在processConfigurationClass方法中找到和配置相关的方法：

继续跟踪，可以看到和@ComponentScan注解注解相关的东西了，我们进入componentScanParser.parse看其具体的解析方法：

继续跟踪，查看构造方法：

继续跟踪，前面我们讲到useDefaultFilters表示默认扫描规则，默认是true：

跟踪到这就可以了，就是在这里将所有标有@Component注解的组件都添加到我们的includeFiltes里面去，而@Controller、@Service、@Repository注解都标有@Component注解，所以只要标注了@Controller、@Service、@Repository、@Component注解中的任何一个，其组件都会被自动扫描，加入到容器中

A-Za-z. ↩︎
A-Za-z. ↩︎

2401_85767310

关注

24
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
@ComponentScan注解 -【Spring底层原理】

ComponentScan注解 -【Spring底层原理】案例已上传GitHub，欢迎star：https://github.com/oneStarLR/spring-annotation一、注解用法。
复制链接

扫一扫