为什么spirng扫描到@compent会把对象注册到容器上
spring 扫描方式有多少种？
首先spring是可以通过xml方式和注解方式来扫描指定的包
1.xml形式：
applicationContext.xml文件
<context:component-scan base-package="com.onion"></context:component-scan>
2.注解方式
@ComponentScan(basePackages = "com.onion")
源码解析
最后会触发:ComponentScanBeanDefinitionParser.parse去解析xml ， 如果想知道为什么会触发ComponentScanBeanDefinitionParser的小伙伴可以看： https://www.cnblogs.com/dabenxiang/p/11038914.html
public class ComponentScanBeanDefinitionParser implements BeanDefinitionParser {
private static final String BASE_PACKAGE_ATTRIBUTE = "base-package";
private static final String RESOURCE_PATTERN_ATTRIBUTE = "resource-pattern";
private static final String USE_DEFAULT_FILTERS_ATTRIBUTE = "use-default-filters";
private static final String ANNOTATION_CONFIG_ATTRIBUTE = "annotation-config";
private static final String NAME_GENERATOR_ATTRIBUTE = "name-generator";
private static final String SCOPE_RESOLVER_ATTRIBUTE = "scope-resolver";
private static final String SCOPED_PROXY_ATTRIBUTE = "scoped-proxy";
private static final String EXCLUDE_FILTER_ELEMENT = "exclude-filter";
private static final String INCLUDE_FILTER_ELEMENT = "include-filter";
private static final String FILTER_TYPE_ATTRIBUTE = "type";
private static final String FILTER_EXPRESSION_ATTRIBUTE = "expression";
//注释
public ComponentScanBeanDefinitionParser() {
}
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
String basePackage = element.getAttribute("base-package");
basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
String[] basePackages = StringUtils.tokenizeToStringArray(basePackage, ",;
");
ClassPathBeanDefinitionScanner scanner = this.configureScanner(parserContext, element);
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
this.registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
return null;
}
}
可以看到这里他是Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages); ，扫描包，并得到Set<BeanDefinitionHolder>集合。
scanner.doScan的代码展示：
public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
...
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet();
String[] var3 = basePackages;
int var4 = basePackages.length;
for(int var5 = 0; var5 < var4; ++var5) {
String basePackage = var3[var5];
Set<BeanDefinition> candidates = this.findCandidateComponents(basePackage);
...
}
return beanDefinitions;
}
}
public class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {
...
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
return this.componentsIndex != null && this.indexSupportsIncludeFilters() ? this.addCandidateComponentsFromIndex(this.componentsIndex, basePackage) :
//调用scanCandidateComponents
this.scanCandidateComponents(basePackage);
}
...
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
LinkedHashSet candidates = new LinkedHashSet();
String packageSearchPath = "classpath*:" + this.resolveBasePackage(basePackage) + '/' + this.resourcePattern;
//扫描包，得到相应的类信息
Resource[] resources = this.getResourcePatternResolver().getResources(packageSearchPath);
Resource[] var7 = resources;
int var8 = resources.length;
for(int var9 = 0; var9 < var8; ++var9) {
Resource resource = var7[var9];
if (resource.isReadable()) {
//得到类的元数据信息
MetadataReader metadataReader = this.getMetadataReaderFactory().getMetadataReader(resource);
//判断条件，如果满足加入到候选人处
if (this.isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setSource(resource);
if (this.isCandidateComponent((AnnotatedBeanDefinition)sbd)) {
//加入到集合
candidates.add(sbd);
}
}
}
return candidates;
}
...
}
从代码中可以看到scanner.doScan到 ClassPathScanningCandidateComponentProvider.findCandidateComponents(basePackage)再到ClassPathScanningCandidateComponentProvider.scanCandidateComponents(basePackage)。 注意： ClassPathBeanDefinitionScanner是ClassPathScanningCandidateComponentProvider的子类
this.scanCandidateComponents 前面部分用途就是扫描basepackage，并从中得到相应的类，并且把相应的类信息，转换成元数据MetadataReader，
然后再通过this.isCandidateComponent(metadataReader) 来判断这个类是否需要加入到容器里，
ClassPathScanningCandidateComponentProvider.isCandidateComponent 代码展示
public class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {
//构造方法
public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters, Environment environment) {
if (useDefaultFilters) {
this.registerDefaultFilters();
}
}
//这里可以看到注入了@Component
protected void registerDefaultFilters() {
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
}
//判断
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
Iterator var2 = this.excludeFilters.iterator();
TypeFilter tf;
do {
if (!var2.hasNext()) {
var2 = this.includeFilters.iterator(); //遍历includeFilters，然后跟metadataReader做比对
do {
if (!var2.hasNext()) {
return false;
}
tf = (TypeFilter)var2.next();
} while(!tf.match(metadataReader, this.getMetadataReaderFactory()));
return this.isConditionMatch(metadataReader);
}
tf = (TypeFilter)var2.next();
} while(!tf.match(metadataReader, this.getMetadataReaderFactory()));
return false;
}
}
从ClassPathScanningCandidateComponentProvider的构造方法再到registerDefaultFilters里可以看出，默认情况下，spring 会调用 this.includeFilters.add(new AnnotationTypeFilter(Component.class)); 这个代码。而isCandidateComponent 则是遍历includeFilters里面的注解，再去跟传进来的类元数据做对比，如果类元数据存在该注解，返回true,就是需要这个类加入容器。
总结说明：这就是说明了只要加入了@Component注解的类就能注入到容器中，@Service , @Controller 等等都是继承了@Component，所以加上这些注解的类都可以注入到容器里。
那如果我们想自定义一个注解且不继承@Component， 怎么让带上这个自定义注解的类注入到容器里呢？
带上自定义注解，注入到容器
openFeign的代码示例
其实openFeign，也是做过这样的事情，只要我们仿造openFeign就可以达到这样的目的。
@SpringBootApplication
@EnableFeignClients
@EnableMyBeanAnno
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}
@FeignClient(value = "spring-cloud-order-service")
public interface OpenFeignService {
@GetMapping("/orders")
public String getAllOrder();
}
@FeignClient 就是属于openFeign的自定义标签
@RestController
public class OpenFeignController {
@Autowired
private OpenFeignService openFeignService;
@GetMapping("/orders")
public String getAllOrder(){
return openFeignService.getAllOrder();
}
}
这段代码可以直接注入OpenFeignService，证明OpenFeignService已经注入到容器里。
源码解析
为何带上@FeignClient的接口能注入到容器里：
首先看@EnableFeignClients
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({FeignClientsRegistrar.class})
public @interface EnableFeignClients {
String[] value() default {};
String[] basePackages() default {};
}
根据@Import的第三种用法，会加载FeignClientsRegistrar.registerBeanDefinitions的方法，因为FeignClientsRegistrar 实现了 ImportBeanDefinitionRegistrar ，
提示：
@Import使用方法解析： https://www.cnblogs.com/yichunguo/p/12122598.html
FeignClientsRegistrar代码：
class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
...
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
this.registerDefaultConfiguration(metadata, registry);
this.registerFeignClients(metadata, registry);
}
...
protected ClassPathScanningCandidateComponentProvider getScanner() {
return new ClassPathScanningCandidateComponentProvider(false, this.environment) {
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
boolean isCandidate = false;
if (beanDefinition.getMetadata().isIndependent() && !beanDefinition.getMetadata().isAnnotation()) {
isCandidate = true;
}
return isCandidate;
}
};
}
...
public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
ClassPathScanningCandidateComponentProvider scanner = this.getScanner();
scanner.setResourceLoader(this.resourceLoader);
//获取EnableFeignClients的属性
Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
//构造AnnotationTypeFilter参数是FeignClient.class
AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);
Class<?>[] clients = attrs == null ? null : (Class[])((Class[])attrs.get("clients"));
Object basePackages;
if (clients != null && clients.length != 0) {
....
}
else {
//加入到includeFilter里面去
scanner.addIncludeFilter(annotationTypeFilter);
basePackages = this.getBasePackages(metadata);
}
Iterator var17 = ((Set)basePackages).iterator();
while(var17.hasNext()) {
String basePackage = (String)var17.next();
//扫描包。返回可以注入到容器中的BeanDefinition
Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
Iterator var21 = candidateComponents.iterator();
while(var21.hasNext()) {
BeanDefinition candidateComponent = (BeanDefinition)var21.next();
if (candidateComponent instanceof AnnotatedBeanDefinition) {
AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition)candidateComponent;
AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
Assert.isTrue(annotationMetadata.isInterface(), "@FeignClient can only be specified on an interface");
Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(FeignClient.class.getCanonicalName());
String name = this.getClientName(attributes);
this.registerClientConfiguration(registry, name, attributes.get("configuration"));
//注入到容器里
this.registerFeignClient(registry, annotationMetadata, attributes);
}
}
}
}
}
可以看到FeignClientsRegistrar.registerBeanDefinitions 调用 this.registerFeignClients
解析this.registerFeignClients，
第一： 获取EnableFeignClients的属性，来确定要扫描的包是什么。
第二： 把FeignClient.class 加入到 scanner中
第三： scanner.findCandidateComponents(basePackage)。 返回加上了FeignClient的类信息的BeanDefinition
第四：把带上FeignClient注解的类注入到容器里
scanner.findCandidateComponents就不做解析了。因为上面解析@compent已经解析过了
自制自定义注解
首先仿照@EnableFeignClients ， 新建一个@EnableMyBeanAnno
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({MyImportBeanDefinitionRegistrar.class})
public @interface EnableMyBeanAnno {
String[] value() default {};
String[] basePackages() default {};
Class<?>[] basePackageClasses() default {};
Class<?>[] defaultConfiguration() default {};
Class<?>[] clients() default {};
}
仿照@FeignClientsRegistrar ， 新建一个@MyImportBeanDefinitionRegistrar
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
private ResourceLoader resourceLoader;
private Environment environment;
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
ClassPathScanningCandidateComponentProvider scanner = this.getScanner();
scanner.setResourceLoader(this.resourceLoader);
//加入MyBeanAnno.class到includeFilter中
AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(MyBeanAnno.class);
scanner.addIncludeFilter(annotationTypeFilter);
//这里我就直接指定要读的包了。不搞那么麻烦了
Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents("com.onion.test");
for (BeanDefinition candidateComponent : candidateComponents) {
beanDefinitionRegistry.registerBeanDefinition(candidateComponent.getBeanClassName(),candidateComponent);
}
}
protected ClassPathScanningCandidateComponentProvider getScanner() {
return new ClassPathScanningCandidateComponentProvider(false, this.environment) {
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
boolean isCandidate = false;
if (beanDefinition.getMetadata().isIndependent() && !beanDefinition.getMetadata().isAnnotation()) {
isCandidate = true;
}
return isCandidate;
}
};
}
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourceLoader = resourceLoader;
}
public void setEnvironment(Environment environment) {
this.environment = environment;
}
}
带上@MyBeanAnno注解的类
@MyBeanAnno
public class MyBean {
}
测试类：
@SpringBootApplication
@EnableFeignClients
@EnableMyBeanAnno //带上了我们自定义的注解
public class App {
@Autowired
private StaticApp staticApp;
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
@Component
public class StaticApp implements ApplicationContextAware {
private ApplicationContext applicationContext;
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
MyBean bean = applicationContext.getBean(MyBean.class);
System.out.println(bean);
}
}
}
最后的结果:
