企业网站定制开发Spring注解详解：@ComponentScan自动扫描组件使用

目录

企业网站定制开发无注解方式-scan使用

之前，企业网站定制开发我们需要扫描工程下一企业网站定制开发些类上所标注的注解，企业网站定制开发这些常用注解有：

@Controller,@Service,@Component,@Repository

通过在Spring企业网站定制开发的配置文件中配置<context:component-scan>扫描对应包下扫描这些注解的方式：

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. 	xmlns:p="http://www.springframework.org/schema/p"
  4. 	xmlns:context="http://www.springframework.org/schema/context"
  5. 	xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.          http://www.springframework.org/schema/beans/spring-beans.xsd
  7.          http://www.springframework.org/schema/context  
  8.          http://www.springframework.org/schema/context/spring-context-2.5.xsd">
  9.  
  10.     <!--@Controller,@Service,@Component,@Repository-->
  11. 	<context:component-scan base-package="com.jektong.spring"/>
  12.  
  13. </beans>

注解方式@ComponentScan使用

建三个类，依次将

@Controller，@Repository，@Service,标注这些类：

图1

现在通过使用注解@ComponentScan的方式来扫描所在包下面的这些类：之前定义的PersonConfig修改：

  1. package com.jektong.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.ComponentScan;
  5. import org.springframework.context.annotation.Configuration;
  6.  
  7. import com.jektong.spring.Person;
  8.  
  9. @Configuration
  10. @ComponentScan("com.jektong")
  11. public class PersonConfig {
  12.  
  13. 	@Bean("person01")
  14. 	public Person person() {
  15. 		return new Person("李四",21);
  16. 	}
  17. }

测试，看是否扫描到这些注解所标注的类：PersonTest.java

  1. @Test
  2. public  void test02() {
  3. 	ApplicationContext ac = new AnnotationConfigApplicationContext(PersonConfig.class);
  4. 	Person bean = ac.getBean(Person.class);
  5. 	System.out.println(bean);
  6. 	
  7. 	String[] beanDefinitionNames = ac.getBeanDefinitionNames();
  8. 	for (String string : beanDefinitionNames) {
  9. 		System.out.println(string);
  10. 	}
  11. }

测试效果：除了Spring要自动加载的配置类以外也显示了刚才添加的配置类：

图2

为何会出现PersonConfig,因为@Configuration本 身就是@Component注解的：

图3

@ComponentScan的扫描规则

如果需要指定配置类的扫描规则, @ComponentScan提供对应的扫描方式@Filter进行配置类的过滤：

  1. // 扫描包的时候只规定扫描一些注解配置类。
  2. Filter[] includeFilters() default {};
  3.  
  4. // 扫描包的时候可以排除一些注解配置类。 
  5. Filter[] excludeFilters() default {};

Filter其实也是一个注解，相当于@ComponentScan的子注解，可以看图4：

图4

Filter对应的过滤规则如下:

第一种：扫描包的时候只规定扫描一些注解配置类【includeFilters】。

使用这个includeFilters过滤规则，必须解除默认的过滤规则，

使用【useDefaultFilters = false】：

  1. package com.jektong.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.ComponentScan;
  5. import org.springframework.context.annotation.ComponentScan.Filter;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.context.annotation.FilterType;
  8. import org.springframework.stereotype.Controller;
  9.  
  10. import com.jektong.spring.Person;
  11.  
  12. @Configuration
  13. @ComponentScan(value = "com.jektong",includeFilters  = {
  14. 		@Filter(type = FilterType.ANNOTATION,value= {Controller.class})
  15. },useDefaultFilters = false )
  16. public class PersonConfig {
  17.  
  18. 	@Bean("person01")
  19. 	public Person person() {
  20. 		return new Person("李四",21);
  21. 	}
  22. }

这样就只会扫描用@Controller,标注的配置类交给Spring容器中了：

图5

 第二种：扫描包的时候可以排除一些注解配置类【excludeFilters 】。

图6

 @Filter看上图，有5种不同类型的过滤策略。拿第一种举例，我们需要过滤使用@Controller注解的配置类：

  1. package com.jektong.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.ComponentScan;
  5. import org.springframework.context.annotation.ComponentScan.Filter;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.context.annotation.FilterType;
  8. import org.springframework.stereotype.Controller;
  9.  
  10. import com.jektong.spring.Person;
  11.  
  12. @Configuration
  13. @ComponentScan(value = "com.jektong",excludeFilters = {
  14. 		@Filter(type = FilterType.ANNOTATION,value= {Controller.class})
  15. } )
  16. public class PersonConfig {
  17.  
  18. 	@Bean("person01")
  19. 	public Person person() {
  20. 		return new Person("李四",21);
  21. 	}
  22. }

测试看一下发现图2中的personController不会交给Spring容器去管理了：

图7

上面的图6展示出5种不同类型的过滤策略，上面介绍了注解类型（FilterType.ANNOTATION），还有四种： 

重点看一下CUSTOM自定义扫描策略。

 

从源码看，自定义扫描注解类型需要实现TypeFilter接口,下面就写一个实现类MyFilter.java:在实现类中可以自定义配置规则：

  1. package com.jektong.config;
  2.  
  3. import java.io.IOException;
  4.  
  5. import org.springframework.core.io.Resource;
  6. import org.springframework.core.type.AnnotationMetadata;
  7. import org.springframework.core.type.ClassMetadata;
  8. import org.springframework.core.type.classreading.MetadataReader;
  9. import org.springframework.core.type.classreading.MetadataReaderFactory;
  10. import org.springframework.core.type.filter.TypeFilter;
  11.  
  12. public class MyFilter implements TypeFilter {
  13.  
  14. 	@Override
  15. 	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
  16. 			throws IOException {
  17. 		// 查看当前类的注解。
  18. 		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
  19. 		// 查看当前扫描类的信息
  20. 		ClassMetadata classMetadata = metadataReader.getClassMetadata();
  21. 		// 获取当前类资源
  22. 		Resource resource = metadataReader.getResource();
  23. 		String className = classMetadata.getClassName();
  24. 		System.out.println("className===>" + className);
  25. 		// 只要类名包含er则注册Spring容器
  26. 		if(className.contains("er")) {
  27. 			return true;
  28. 		}
  29. 		return false;
  30. 	}
  31. }

测试：

PersonConfig 中进行扫描：

  1. package com.jektong.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.ComponentScan;
  5. import org.springframework.context.annotation.ComponentScan.Filter;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.context.annotation.FilterType;
  8. import org.springframework.stereotype.Controller;
  9.  
  10. import com.jektong.service.PersonService;
  11. import com.jektong.spring.Person;
  12.  
  13. @Configuration
  14. @ComponentScan(value = "com.jektong",includeFilters  = {
  15. 		@Filter(type = FilterType.CUSTOM,value= {MyFilter.class})
  16. },useDefaultFilters = false )
  17. public class PersonConfig {
  18.  
  19. 	@Bean("person01")
  20. 	public Person person() {
  21. 		return new Person("李四",21);
  22. 	}
  23. }

可以看出扫描出包下面的类只要带“er”的全部扫描出来，并配置给Spring容器：

ASSIGNABLE_TYPE：按照指定的类型去加载对应配置类：

  1. package com.jektong.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.ComponentScan;
  5. import org.springframework.context.annotation.ComponentScan.Filter;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.context.annotation.FilterType;
  8. import org.springframework.stereotype.Controller;
  9.  
  10. import com.jektong.service.PersonService;
  11. import com.jektong.spring.Person;
  12.  
  13. @Configuration
  14. @ComponentScan(value = "com.jektong",includeFilters  = {
  15. 		@Filter(type = FilterType.ASSIGNABLE_TYPE,value= {PersonService.class})
  16. },useDefaultFilters = false )
  17. public class PersonConfig {
  18.  
  19. 	@Bean("person01")
  20. 	public Person person() {
  21. 		return new Person("李四",21);
  22. 	}
  23. }

尽管我们将PersonService.java上的注解去掉，使用ASSIGNABLE_TYPE依然会加载出来（自行测试）。

ASPECTJ与REGEX基本不用，不用了解。

以上就是@ComponentScan的具体用法，该兴趣的话可以看一下源码。

网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发