SpringBoot 2.0 系列006 --启动实战之注解使用

柔光的暖阳◎ 2022-05-24 02:39 183阅读 0赞

# SpringBoot 2.0 系列006 --启动实战之注解使用 #

## 一些误区说明 ##

> 网上很多教程默认使用SpringBootApplcation注解，且只用这个即可扫描启动类包下所有的bean。 而官方默认教程使用的是@EnableAutoConfiguration，这个注解和SpringBootApplication注解的区别是什么？

*  [参阅2.0.1官方文档说明][2.0.1]

> If you don’t want to use @SpringBootApplication, the @EnableAutoConfiguration and @ComponentScan annotations that it imports defines that behaviour so you can also use that instead.

> 意思是如果你不想用@SpringBootApplication 可以使用@EnableAutoConfiguration and @ComponentScan 注解来代替它

### @SpringBootApplication注解说明 ###

> 很多开发者喜欢它们的app能auto-configuration, component scan 和在启动类中做额外配置。那么@SpringBootApplication可以满足你的这三项要求

*  @EnableAutoConfiguration ：开启自动配置
 *  @ComponentScan ：开启application所在包下的扫描
 *  @Configuration ：允许你注册额外的bean或者导入额外的配置classes

## SpringBoot是如何扫描到我们的class的？ ##

*  流程图

[![SpringBoot_ComponetScan.png][]][SpringBoot_ComponetScan.png]

> 从流程图可知，在refreshContext时，会调用上层的refresh方法触发invokeBeanFactoryPostProcessors，在到后边会触发到的ComponentScanAnnotationParser类中

## ComponentScanAnnotationParser.java ##

> 在此方法中，我们可以判定出我们的basePackages目录以方便我们扫描。

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
         
    		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
    				componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
    
    		Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
    		boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
    		scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
    				BeanUtils.instantiateClass(generatorClass));
    
    		ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
    		if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
         
    			scanner.setScopedProxyMode(scopedProxyMode);
    		}
    		else {
         
    			Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
    			scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
    		}
    
    		scanner.setResourcePattern(componentScan.getString("resourcePattern"));
    
    		for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
         
    			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
         
    				scanner.addIncludeFilter(typeFilter);
    			}
    		}
    		for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
         
    			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
         
    				scanner.addExcludeFilter(typeFilter);
    			}
    		}
    
    		boolean lazyInit = componentScan.getBoolean("lazyInit");
    		if (lazyInit) {
         
    			scanner.getBeanDefinitionDefaults().setLazyInit(true);
    		}
    
    		Set<String> basePackages = new LinkedHashSet<>();
    		String[] basePackagesArray = componentScan.getStringArray("basePackages");
    		for (String pkg : basePackagesArray) {
         
    			String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
    					ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
    			Collections.addAll(basePackages, tokenized);
    		}
    		for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
         
    			basePackages.add(ClassUtils.getPackageName(clazz));
    		}
    		// 默认使用@componentScan 不写basePackages则使用此处做为基础包路径
    		if (basePackages.isEmpty()) {
         
    		    // declaringClass=com.ricky.SpringBootApplication05
    		    // 即 com.ricky
    			basePackages.add(ClassUtils.getPackageName(declaringClass));
    		}
    
    		scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
         
    			@Override
    			protected boolean matchClassName(String className) {
         
    				return declaringClass.equals(className);
    			}
    		});
    		return scanner.doScan(StringUtils.toStringArray(basePackages));
    	}

## .ClassPathScanningCandidateComponentProvider ##

> 会扫描我们启动类packageSearchPath所在目录下的所有class,最终装载到Set candidates对象中。

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
         
    		Set<BeanDefinition> candidates = new LinkedHashSet<>();
    		try {
         
    			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
    					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
    			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
    			boolean traceEnabled = logger.isTraceEnabled();
    			boolean debugEnabled = logger.isDebugEnabled();
    			for (Resource resource : resources) {
         
    				if (traceEnabled) {
         
    					logger.trace("Scanning " + resource);
    				}
    				if (resource.isReadable()) {
         
    					try {
         
    						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
    						if (isCandidateComponent(metadataReader)) {
         
    							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
    							sbd.setResource(resource);
    							sbd.setSource(resource);
    							if (isCandidateComponent(sbd)) {
         
    								if (debugEnabled) {
         
    									logger.debug("Identified candidate component class: " + resource);
    								}
    								candidates.add(sbd);
    							}
    							else {
         
    								if (debugEnabled) {
         
    									logger.debug("Ignored because not a concrete top-level class: " + resource);
    								}
    							}
    						}
    						else {
         
    							if (traceEnabled) {
         
    								logger.trace("Ignored because not matching any filter: " + resource);
    							}
    						}
    					}
    					catch (Throwable ex) {
         
    						throw new BeanDefinitionStoreException(
    								"Failed to read candidate component class: " + resource, ex);
    					}
    				}
    				else {
         
    					if (traceEnabled) {
         
    						logger.trace("Ignored because not readable: " + resource);
    					}
    				}
    			}
    		}
    		catch (IOException ex) {
         
    			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
    		}
    		return candidates;
    	}

*  相关图

> 项目目录结构

[![cp06_dir.png][]][cp06_dir.png]

> 扫描到的目录

[![cp06.png][]][cp06.png]

> 扫描到类

[![cp06_02.png][]][cp06_02.png]

## @SpringBootApplication 使用 ##

*  注解源码

> 源码可以解释 为什么官方说一般可以使用@EnableAutoConfiguration和 @ComponentScan 进行替代。

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(excludeFilters = {
         
    		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
    public @interface SpringBootApplication {
         
    
    	@AliasFor(annotation = EnableAutoConfiguration.class)
    	Class<?>[] exclude() default {};
    
    	@AliasFor(annotation = EnableAutoConfiguration.class)
    	String[] excludeName() default {};
    
    	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
    	String[] scanBasePackages() default {};
    
    	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
    	Class<?>[] scanBasePackageClasses() default {};
    
    }

*  exclude 废弃指定class的EnableAutoConfiguration类型

> 只支持org.springframework.boot.autoconfigure包下的

@SpringBootApplication(exclude = HibernateJpaAutoConfiguration.class)

*  excludeName 废弃指定全类名的EnableAutoConfiguration类型

> 只支持org.springframework.boot.autoconfigure包下的

@SpringBootApplication(excludeName = "org.springframework.boot.autoconfigure.orm.jpaHibernateJpaAutoConfiguration.class")

*  scanBasePackages 指定扫描的包

@SpringBootApplication(scanBasePackages = { "com.ricky","com.ricky02"})

*  scanBasePackageClasses 指定含有ComponentScan的类

> 可以自定义

@Configuration
    @ComponentScan
    public class Ricky03Config {
         
    }

@SpringBootApplication(scanBasePackages = { "com.ricky","com.ricky02"},scanBasePackageClasses = Ricky03Config.class)

## 替代SpringBootApplication注解的方式 ##

> 和实现上述功能一样的方式，需要EnableAutoConfiguration、ComponentScan或者配合Import

@Configuration
    @ComponentScan
    public class Ricky04Config {
         
    }

@EnableAutoConfiguration
    @ComponentScan(basePackages = {
         "com.ricky","com.ricky02","com.ricky03"},basePackageClasses = {
         Ricky04Config.class})
    //@Import({Ricky04Config.class}) //ricky04目录的也扫描进来
    public class SpringBootApplication06_3 {
         
        /** * 开启SpringBoot服务 * @param args */
        public static void main(String[] args) {
         
            ConfigurableApplicationContext context = SpringApplication.run(SpringBootApplication06_3.class, args);
    
            String[] names = context.getBeanDefinitionNames();
            for (String name:names){
         
                System.out.println(name);
            }
    
            context.close();
        }
    }

*  Import

> import一般可以引入我们的@configuration相关的类。 我们可以利用import和Configuration来实现开启 动态注入bean对象的场景。

*   *  说明

> 这里是假定我们redis实例都是通过公共模块来调用，类似单独的SB项目模块独立管理。在其他模块使用的时候需要引入该模块。

*   *  定义一个开关注解

> 公共模块中

/**
     * 自定义开启redis
     *
     */
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(RedisConfig.class)
    public @interface EnableZDRedis {
         
    }

*   *  redisConfig

> 公共模块中

@Configuration
    @ConditionalOnClass(Jedis.class)
    public class RedisConfig {
         
    
        @Bean
        @ConditionalOnMissingBean
        public Jedis jedis(){
         
            return new Jedis("127.0.0.1",6379);
        }
    }

*   *  使用

> 调用模块中,开启我们定义的注解即可。

@SpringBootApplication
    @EnableZDRedis
    public class SpringBootApplication06_2 {
         
        @AutoWired
        private Jedis jedis;
    }

## 演示项目地址,欢迎fork和star ##

> 码云：[SpringBootLearn][]

# 最后 #

*  [SpringBoot 2.0 系列001 -- 入门介绍以及相关概念][SpringBoot 2.0 _001 --]
 *  [SpringBoot 2.0 系列002 --运行流程分析][SpringBoot 2.0 _002 --]
 *  [SpringBoot 2.0 系列003 -- 自定义Parent][SpringBoot 2.0 _003 -- _Parent]
 *  [SpringBoot 2.0 系列004 -- 启动实战之配置文件][SpringBoot 2.0 _004 --]
 *  [SpringBoot 2.0 系列005 -- 启动实战之SpringApplication应用][SpringBoot 2.0 _005 -- _SpringApplication]
 *  作者ricky
 *  交流群：244930845

[2.0.1]: https://docs.spring.io/spring-boot/docs/2.0.1.RELEASE/reference/htmlsingle/#using-boot-using-the-default-package
[SpringBoot_ComponetScan.png]: /images/20220524/f444906f88984c47aa07b3f176241329.png
[cp06_dir.png]: /images/20220524/86c0023a782749a0858508e33a2bf879.png
[cp06.png]: /images/20220524/6756141d31e445e2b33dedd334c6c090.png
[cp06_02.png]: /images/20220524/06636acd686f4355a97b94ae8c0af5a8.png
[SpringBootLearn]: https://gitee.com/bgt0314/SpringBootLearn
[SpringBoot 2.0 _001 --]: https://blog.csdn.net/u014042066/article/details/80271073
[SpringBoot 2.0 _002 --]: https://blog.csdn.net/u014042066/article/details/80311954
[SpringBoot 2.0 _003 -- _Parent]: https://blog.csdn.net/u014042066/article/details/80321856
[SpringBoot 2.0 _004 --]: https://blog.csdn.net/u014042066/article/details/80336467
[SpringBoot 2.0 _005 -- _SpringApplication]: https://blog.csdn.net/u014042066/article/details/80353282