# 写在前面的话
相关背景及资源：
[曹工说Spring Boot源码（1）-- Bean Definition到底是什么，附spring思维导图分享](https://www.cnblogs.com/grey-wolf/p/12044199.html)
[曹工说Spring Boot源码（2）-- Bean Definition到底是什么，咱们对着接口，逐个方法讲解](https://www.cnblogs.com/grey-wolf/p/12051957.html )
[曹工说Spring Boot源码（3）-- 手动注册Bean Definition不比游戏好玩吗，我们来试一下](https://www.cnblogs.com/grey-wolf/p/12070377.html)
[曹工说Spring Boot源码（4）-- 我是怎么自定义ApplicationContext，从json文件读取bean definition的？](https://www.cnblogs.com/grey-wolf/p/12078673.html)
[曹工说Spring Boot源码（5）-- 怎么从properties文件读取bean](https://www.cnblogs.com/grey-wolf/p/12093929.html)
[曹工说Spring Boot源码（6）-- Spring怎么从xml文件里解析bean的](https://www.cnblogs.com/grey-wolf/p/12114604.html )
[曹工说Spring Boot源码（7）-- Spring解析xml文件，到底从中得到了什么（上）](https://www.cnblogs.com/grey-wolf/p/12151809.html)
[曹工说Spring Boot源码（8）-- Spring解析xml文件，到底从中得到了什么（util命名空间）](https://www.cnblogs.com/grey-wolf/p/12158935.html)
[曹工说Spring Boot源码（9）-- Spring解析xml文件，到底从中得到了什么（context命名空间上）](https://www.cnblogs.com/grey-wolf/p/12189842.html)
[曹工说Spring Boot源码（10）-- Spring解析xml文件，到底从中得到了什么（context:annotation-config 解析）](https://www.cnblogs.com/grey-wolf/p/12199334.html)
[曹工说Spring Boot源码（11）-- context:component-scan，你真的会用吗（这次来说说它的奇技淫巧）](https://www.cnblogs.com/grey-wolf/p/12203743.html)
[曹工说Spring Boot源码（12）-- Spring解析xml文件，到底从中得到了什么（context:component-scan完整解析)](https://www.cnblogs.com/grey-wolf/p/12214408.html)
[曹工说Spring Boot源码（13）-- AspectJ的运行时织入（Load-Time-Weaving），基本内容是讲清楚了（附源码）](https://www.cnblogs.com/grey-wolf/p/12228958.html)
[曹工说Spring Boot源码（14）-- AspectJ的Load-Time-Weaving的两种实现方式细细讲解，以及怎么和Spring Instrumentation集成](https://www.cnblogs.com/grey-wolf/p/12283544.html)
[曹工说Spring Boot源码（15）-- Spring从xml文件里到底得到了什么（context：load-time-weaver 完整解析）](https://www.cnblogs.com/grey-wolf/p/12288391.html)
[曹工说Spring Boot源码（16）-- Spring从xml文件里到底得到了什么（aop：config完整解析【上】）](https://www.cnblogs.com/grey-wolf/p/12314954.html)
[曹工说Spring Boot源码（17）-- Spring从xml文件里到底得到了什么（aop：config完整解析【中】）](https://www.cnblogs.com/grey-wolf/p/12317612.html)
[曹工说Spring Boot源码（18）-- Spring AOP源码分析三部曲，终于快讲完了 (aop：config完整解析【下】)](https://www.cnblogs.com/grey-wolf/p/12322587.html)
[曹工说Spring Boot源码（19）-- Spring 带给我们的工具利器，创建代理不用愁（ProxyFactory）](https://www.cnblogs.com/grey-wolf/p/12359963.html)
[曹工说Spring Boot源码（20）-- 码网恢恢，疏而不漏，如何记录Spring RedisTemplate每次操作日志](https://www.cnblogs.com/grey-wolf/p/12375656.html)
[曹工说Spring Boot源码（21）-- 为了让大家理解Spring Aop利器ProxyFactory，我已经拼了](https://www.cnblogs.com/grey-wolf/p/12384356.html)
[曹工说Spring Boot源码（22）-- 你说我Spring Aop依赖AspectJ，我依赖它什么了](https://www.cnblogs.com/grey-wolf/p/12418425.html)
[曹工说Spring Boot源码（23）-- ASM又立功了，Spring原来是这么递归获取注解的元注解的](https://www.cnblogs.com/grey-wolf/p/12535152.html)
[曹工说Spring Boot源码（24）-- Spring注解扫描的瑞士军刀，asm技术实战（上）](https://www.cnblogs.com/grey-wolf/p/12571217.html)
[曹工说Spring Boot源码（25）-- Spring注解扫描的瑞士军刀，ASM + Java Instrumentation，顺便提提Jar包破解](https://www.cnblogs.com/grey-wolf/p/12584861.html)
[曹工说Spring Boot源码（26）-- 学习字节码也太难了，实在不能忍受了，写了个小小的字节码执行引擎](https://www.cnblogs.com/grey-wolf/p/12600097.html)
[曹工说Spring Boot源码（27）-- Spring的component-scan，光是include-filter属性的各种配置方式，就够玩半天了](https://www.cnblogs.com/grey-wolf/p/12601823.html)
[工程代码地址](https://gitee.com/ckl111/spring-boot-first-version-learn ) [思维导图地址](https://www.processon.com/view/link/5deeefdee4b0e2c298aa5596)
工程结构图：
# 概要
本讲相对独立，我们也不爱说废话，直接说本讲要做啥。
大家知道，@Component-scan注解，在注解时代，最主要的用法就是指定一个package的名称，然后spring就会去对应的包下面，扫描注解了@Controller、@Service、@Repository等注解的类，然后注册为bean。
spring boot时代，这个注解则站到了幕后，如下：
```java
@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 {
}
```
总之，这个注解大家再熟悉不过了。我们本讲，最核心的目标是，让大家更懂spring，方法呢，就是让我们自己来实现以下目标：
1. 定义main类
```java
@MyConfiguration
@MyComponentScan(value = "org.springframework.test")
public class BootStrap {
public static void main(String[] args) {
...
}
```
这个上面定义了2个自定义的注解，都加了个前缀"My"。下面简单看看。
```java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyConfiguration {
}
```
这个的效果，类似于@configuration，表示我们是一个配置类，配置类上一般会有一堆其他注解，来引入其他bean definition。
然后是MyComponentScan 注解：
```java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyComponentScan {
/*
* 要扫描的包名
*/
String value();
}
```
2. 我们的target包下，有一个需要我们扫描的bean，如下：
```java
package org.springframework.test;
@MyComponent
@MyComponentScan(value = "org.springframework.test1")
public class PersonService {
private String personname1;
}
```
这里使用MyComponent注解，这个注解，用来注解我们要扫描为bean的那些类。比如这里，我们希望PersonService这个类，被扫描为bean。
其次，我们还定义了一个`@MyComponentScan(value = "org.springframework.test1")`，这个主要是：我们要能够支持递归处理。
当然，现在可以先忽略，权且当它不存在。
3. 最终的测试效果如下：
```java
import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.custom.MyConfigurationClassPostProcessor;
import org.springframework.custom.annotation.MyComponentScan;
import org.springframework.custom.annotation.MyConfiguration;
import org.springframework.test1.AnotherPersonService;
@MyConfiguration
@MyComponentScan(value = "org.springframework.test")
public class BootStrap {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
AnnotatedGenericBeanDefinition beanDefinition = new AnnotatedGenericBeanDefinition(BootStrap.class);
context.registerBeanDefinition(BootStrap.class.getName(), beanDefinition);
/**
* 注册一个beanFactoryPostProcessor,用来处理MyComponentScan注解
*/
RootBeanDefinition def = new RootBeanDefinition(MyConfigurationClassPostProcessor.class);
def.setSource(null);
context.registerBeanDefinition(MyConfigurationClassPostProcessor.class.getName(),
def);
context.refresh();
PersonService bean = context.getBean(PersonService.class);
System.out.println(bean);
}
}
```
输出如下：
> 12:39:27.259 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance of singleton bean 'personService'
> org.springframework.test.PersonService@71ba5790
可以看到，我们的目标就是以上这样。为了实现这个目标，其实我们是仿照spring的实现，自己ctrl c/v了一把，其中进行了大量的简化。
# 实现思路
思路基本等同于spring的实现，因为本系列教程的目的就是让大家更懂Spring，所以没必要另辟蹊径。
##用@MyConfiguration注解一个起点配置类
指定一个用 @MyConfiguration 注解的类，这个类一开始就会被注册为bean definition，类似于spring boot中的启动类，大家知道，spring boot中，启动类也是间接注解了 @SpringBootConfiguration，而 @SpringBootConfiguration呢，大家看看：
```java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}
```
该注解，是注解了@configuration。
其实就是手动指定一个配置类，这个配置类，源码里好像是叫做startUp config，作为一个起点，通过这个起点，我们能发现在这个起点类上的，更多的元注解，比如，在我们公司的真实项目中，启动类就配置了一堆东西：
```java
@SpringBootApplication
@EnableTransactionManagement
@EnableAspectJAutoProxy(exposeProxy = true)
@MapperScan("com.xxx.cad.mapper")
@ComponentScan("com.xxx")
@EnableFeignClients
//@Slf4j
@Controller
@EnableScheduling
public class CadWebService {
```
这个类，就是我们这里的起点类。这个起点类，然后被注册为一个bean。
## 注册一个BeanDefinitionRegistryPostProcessor，用来处理配置类上的@MyComponentScan，以发现更多bean
大家知道@configuration配置类，是怎么被处理的呢？就是通过`org.springframework.context.annotation.ConfigurationClassPostProcessor`。
这个类呢，实现了如下接口：
```java
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
/**
* Modify the application context's internal bean definition registry after its
* standard initialization. All regular bean definitions will have been loaded,
* but no beans will have been instantiated yet. This allows for adding further
* bean definitions before the next post-processing phase kicks in.
* @param registry the bean definition registry used by the application context
* @throws org.springframework.beans.BeansException in case of errors
*/
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}
```
这个接口的这个方法的调用时机，是在：截止目前，通过配置(不论是xml，还是像上面第一步这样，去手动注册bean definition)的方式，能够找到的bean definition都已经找到了；本来，下一步就是找出其中的要eager-init的单例bean，去初始化了。
但是呢，在这之前，我们还有一个步骤，也算是一个扩展点吧，可以让我们去修改目前的bean definition集合。
如果举个通俗的例子，大概是这样的，比如，一个公司，组织大家出去玩，大家自愿报名，一开始假设报了10个人，预定周六出发；在此之前呢，公司再让大家确认一下，大家可以
1. 增，带家属，带男女朋友；
2. 删，自己不去了
3. 改，我周六好像还要写bug，但我另一个同事没啥事，他可以去
而要实现这些，只要你实现前面我们提到的那个接口的方法即可，大家可以再观察下这个方法：
```java
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
```
入参是registry，也就是当前的报名表，报名表都给你了，你还有啥不能干的？
```java
public interface BeanDefinitionRegistry extends AliasRegistry {
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
...
}
```
就拿上面那几个方法举例：
1. registerBeanDefinition，这个就是往名单上加人
2. removeBeanDefinition，这个就是自己不去了
3. BeanDefinition getBeanDefinition(String beanName)，这个可以用自己名字查到报名信息，改个名字，没问题吧？
@Configuration注解的处理，就是依赖于一个实现了`BeanDefinitionRegistry`接口的类，在这个类里，它干了很多事：
假如现在的名单里，只有我们的启动类，对吧，上面标了一坨注解，什么各种Enable，什么Component-scan啦，都有。但我们标注这些，比如component-scan，不是摆着玩的，是要去对应的package下，帮我们扫描bean的；这就是相当于说，要往名单上加人。
大致的逻辑可以理解为：
1. 拿到初始名单，这里就是启动类的bean definition，以及一些其他手动弄进去的bean definition
2. 通过实现了`BeanDefinitionRegistry`的`ConfigurationClassPostProcessor`，来看看第一步的初始名单中，有没有注解@Component-scan，如果没注解，直接返回；如果注解了，进入第三步；
3. 拿到@component-scan里配置的要扫描的package名，然后获取这个package下的全部class，然后看看这些class满不满足条件（比如，只认注解了controller、service等注解的）
4. 第三步筛出来的，满足条件的class，它们本身合格了，可以作为bean了；然后看看它们有没有作为配置类的资格，我拿下面的举例：
```java
@Component
@ComponentScan(value = "xxxx.xxxx")
public class PersonService {
private String personname1;
}
```
本身，上面这个例子中，PersonService因为component-scan的功劳，已经被收为bean了，但是，这不是结束，因为它自己上面还注解了@ComponentScan注解，而这，就需要去递归处理。
有些同学会觉得有点极端，maybe，但是，下面的例子极端吗：
```java
@Component
@Import({MainClassForTestAnnotationConfig.class})
public class PersonService {
private String personname1;
```
如果觉得@Import极端，那么@ImportResource去导入xml文件里的bean，这个场景，有些时候还是会遇到吧，比如，要兼容老程序的时候。
而我要说的就是，在`ConfigurationClassPostProcessor`处理@configuration注解的过程中，如果发现这个类上有以下行为，都会递归处理：
1. 内部类先解析
2. `PropertySource` 注解
3. `ComponentScan`注解
4. `Import` 注解
5. `ImportResource`注解
6. 有`Bean` 注解的方法
7. 处理superClass
总体来说，这个类还是比较难的，而且会递归处理。
我们今天的demo，为了聚焦，也为了实现简单，先只处理了@component-scan本身的递归。
接下来，就来看看具体实现。
# 具体实现
## 测试类，主逻辑，驱动整体流程
```java
@MyConfiguration
@MyComponentScan(value = "org.springframework.test")
public class BootStrap {
public static void main(String[] args) {
// 1
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
AnnotatedGenericBeanDefinition beanDefinition = new AnnotatedGenericBeanDefinition(BootStrap.class);
context.registerBeanDefinition(BootStrap.class.getName(), beanDefinition);
/**
* 2 注册一个beanFactoryPostProcessor
*/
RootBeanDefinition def = new RootBeanDefinition(MyConfigurationClassPostProcessor.class);
def.setSource(null);
context.registerBeanDefinition(MyConfigurationClassPostProcessor.class.getName(),
def);
// 3
context.refresh();
// 4
PersonService bean = context.getBean(PersonService.class);
System.out.println(bean);
AnotherPersonService anotherPersonService = context.getBean(AnotherPersonService.class);
System.out.println(anotherPersonService);
}
}
```
* 1处，使用spring默认的注解驱动上下文，设置：config的起点类为当前类，注册到spring容器
* 2处，注册一个 MyConfigurationClassPostProcessor 到spring 容器，这个和前面讲的ConfigurationClassPostProcessor 效果类似，用于解析我们自己的@MyComponentScan
* 3处，加载上下文
* 4处，获取bean，检测效果。
##MyConfigurationClassPostProcessor，解析@MyComponentScan
```java
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
log.info("postProcessBeanDefinitionRegistry...");
/**
* 1: 找到标注了{@link org.springframework.custom.annotation.MyConfiguration}注解的类
* 这些类就是我们的配置类
* 我们通过这些类，可以发现更多的bean definition
*/
Set beanDefinitionHolders = new LinkedHashSet();
for (String beanName : registry.getBeanDefinitionNames()) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (MyConfigurationUtils.checkConfigurationClassCandidate(beanDef)) {
beanDefinitionHolders.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 2
if (CollectionUtils.isEmpty(beanDefinitionHolders)) {
return;
}
// 3
MyConfigurationClassParser parser = new MyConfigurationClassParser(environment,registry);
parser.parse(beanDefinitionHolders);
}
```
* 1处，找到目前的，标注了 MyConfiguration注解的全部bean definition
* 2处，如果不存在，返回
* 3处，对第一步找到的集合，进行下一步处理
具体解析的工作，落在了第三步的身上，具体说，是MyConfigurationClassParser类的身上。
##MyConfigurationClassParser具体执行者
```java
public void parse(Set configCandidates) {
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
String className = bd.getBeanClassName();
try {
processConfigurationClass(className);
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("Failed to load bean class: " + bd.getBeanClassName(), ex);
}
}
}
```
这里就是对每个找到的配置类进行处理。比如，我们这里的demo，找到的就是启动类。
然后调用了下面的方法：
```java
protected void processConfigurationClass(String className) throws IOException {
MetadataReader metadataReader = MyConfigurationUtils.getMetadataReader(className);
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
/**
* 1. 判断该类上，是否有标注{@link MyComponentScan}
*/
Map annotationAttributes = annotationMetadata.getAnnotationAttributes(MyComponentScan.class.getName(), true);
AnnotationAttributes componentScan = AnnotationAttributes.fromMap(annotationAttributes);
/**
* 2. 如果类上有这个{@link MyComponentScan},则需要进行处理
*/
if (componentScan != null) {
/**
* 3. 马上扫描这个base package路径下的bean，在里面，会注册beanDefinition到bean registry
*/
Set scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, annotationMetadata.getClassName());
/**
* 4. 如果扫描回来的bean definition不为空，递归处理
*/
if (!CollectionUtils.isEmpty(scannedBeanDefinitions)) {
this.parse(scannedBeanDefinitions);
}
}
}
```
* 1处，判断该类上，是否有标注 @MyComponentScan
* 2处，如果类上有这个 @MyComponentScan ,则需要进行处理
* 3处，马上扫描这个base package路径下的bean，在里面，会注册beanDefinition到bean registry
* 4处，对第三步扫描，得到bean，递归处理，查找更多bean
重点是这里的第三步，交给了一个叫componentScanParser的去处理，这个componentScanParser是在本类初始化的时候赋值的：
```java
public MyConfigurationClassParser(Environment environment, BeanDefinitionRegistry registry) {
this.environment = environment;
this.registry = registry;
this.componentScanParser = new MyComponentScanParser(componentScanBeanNameGenerator,
environment,registry);
}
```
## MyComponentScanParser的处理过程
```java
public Set parse(AnnotationAttributes componentScan, String className) {
// 1
String basePackage = componentScan.getString("value");
// 2
includeFilters.add(new AnnotationTypeFilter(MyComponent.class));
// 3
Set beanDefinitions = new LinkedHashSet();
/**
* 4 获取包下的全部bean definition
*/
Set candidates = findCandidateComponents(basePackage);
/**
* 5 对扫描回来的bean，进行一定的处理，然后注册到bean registry
*/
for (BeanDefinition candidate : candidates) {
String generateBeanName = componentScanBeanNameGenerator.generateBeanName(candidate, registry);
if (candidate instanceof AbstractBeanDefinition) {
((AbstractBeanDefinition)candidate).applyDefaults(this.beanDefinitionDefaults);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
boolean b = checkCandidate(generateBeanName, candidate);
if (b) {
// 6
beanDefinitions.add(new BeanDefinitionHolder(candidate,generateBeanName));
}
}
/**
* 7 注册到bean definition registry
*/
for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitions) {
registry.registerBeanDefinition(beanDefinitionHolder.getBeanName(),beanDefinitionHolder.getBeanDefinition());
}
return beanDefinitions;
}
```
* 1处，获取MyComponentScan注解中value信息，表示要扫描的package
* 2处，设置识别bean的规则，这里是把注解了@MyComponent的，认为是自己人
* 3处，定义变量，用于存放返回的结果
* 4处，扫描包下的全部满足条件的，bean definition
* 5处，处理第4步拿到的bean definition集合
* 6处，加到待返回的结果集
* 7处，注册到spring容器
以上，只有第4处需要再次说明，其他都比较简单。
## 获取满足条件的bean definition的过程
```java
public Set findCandidateComponents(String basePackage) {
Set candidates = new LinkedHashSet();
try {
// 1
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + "/" + this.resourcePattern;
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
// 2
for (Resource resource : resources) {
log.info("Scanning " + resource);
if (!resource.isReadable()) {
continue;
}
// 3
MetadataReader metadataReader = MyConfigurationUtils.getMetadataReader(resource);
// 4
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
// 5
candidates.add(sbd);
}
else {
log.info("Ignored because not matching any filter: " + resource);
}
}
}
...
return candidates;
}
```
* 1处，扫描包下的全部class
* 2处，遍历class
* 3处，获取该class的注解信息
* 4处，利用注解信息，判断是否是自己人（注解了@MyComponent）
* 5处，自己人，准备带走
其中，第4处，实现如下：
```java
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, MyConfigurationUtils.getMetadataReaderFactory())) {
return true;
}
}
return false;
}
```
就是用includeFilters去匹配，大家还记得前面，我们设置了吧：
```java
includeFilters.add(new AnnotationTypeFilter(MyComponent.class));
```
大致的过程，就是这样了。
# dubbo中的实现，粗浅分析
我发现，好像和我上面说的，差得不太多，我也没用过dubbo，确实没参考dubbo的实现。
比如，它也定义了一个BeanDefinitionRegistryPostProcessor的实现类，叫：
```java
public class ServiceAnnotationBeanPostProcessor implements BeanDefinitionRegistryPostProcessor, EnvironmentAware,
ResourceLoaderAware, BeanClassLoaderAware {
```
其实现如下：
```java
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
registerBeans(registry, DubboBootstrapApplicationListener.class);
// 1
Set resolvedPackagesToScan = resolvePackagesToScan(packagesToScan);
if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
// 2
registerServiceBeans(resolvedPackagesToScan, registry);
} else {
if (logger.isWarnEnabled()) {
logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!");
}
}
}
```
* 1处，找到要扫描的package
* 2处，扫描指定包
上面的2处，实现如下：
```java
private void registerServiceBeans(Set packagesToScan, BeanDefinitionRegistry registry) {
DubboClassPathBeanDefinitionScanner scanner =
new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);
BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);
scanner.setBeanNameGenerator(beanNameGenerator);
// 1
scanner.addIncludeFilter(new AnnotationTypeFilter(Service.class));
// 2
scanner.addIncludeFilter(new AnnotationTypeFilter(com.alibaba.dubbo.config.annotation.Service.class));
// 3
for (String packageToScan : packagesToScan) {
// 4 Registers @Service Bean first
scanner.scan(packageToScan);
// 5
Set beanDefinitionHolders =
findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);
// 6
if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {
for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
// 7
registerServiceBean(beanDefinitionHolder, registry, scanner);
}
}
}
}
```
* 1，设置includeFilters，注解类型，注解了`org.apache.dubbo.config.annotation.Service`类型就算
* 2，还是设置includeFilters，只是为了兼容以前的
* 3，遍历要扫描的package
* 4，扫描指定的包
* 5，扫描包，获取到满足条件的集合
* 6，第五步返回不为空，则开始在下面的第7步去注册到spring
* 7，注册到spring
# 总结
经过前面的讲解，大家应该立即更清楚一些了吧，如果还是有点懵，那最好把demo拉下来试试。
如果大家觉得还有点帮助，帮忙点个赞吧。
