逐行阅读Spring5.X源码（番外篇）自定义扫描器， Mybatis是如何利用spring完成Mapper扫描的

上一篇详细讲解了spring的扫描器ClassPathBeanDefinitionScanner，本篇我们我们将模拟mybatis如何通过spring完成Mapper扫描，讲解如何通过spring编写自定义扫描器。既然ClassPathBeanDefinitionScanner完成了spring的扫描功能，我们完全可以继承这个类来达到创建自定义扫描器的目的。

public class CustomScanner extends ClassPathBeanDefinitionScanner {
    public CustomScanner(BeanDefinitionRegistry registry) {
        super(registry);
    }
}

这就是我们的自定义扫描器，当然什么功能也没有，再次基础上我们继续进行扩展，上一篇我们讲过ClassPathBeanDefinitionScanner通过includeFilters来过滤符合条件的业务类，那我们增加我们的扫描规则即可。如何includeFilters在添加我们的扫描规则？很简单，实现addIncludeFilter即可

public class CustomScanner extends ClassPathBeanDefinitionScanner {
    public CustomScanner(BeanDefinitionRegistry registry) {
        super(registry);
    }
    @Override
    public void addIncludeFilter(TypeFilter includeFilter) {
        super.addIncludeFilter(includeFilter);
    }
}

也就是说，我们只要编写我们的规则类TypeFilter 就行了，剩下的交给ClassPathBeanDefinitionScanner来完成，有读者嘲讽：“我还以为你要模拟一个ClassPathBeanDefinitionScanner”，答：“我闲的？mybatis也是利用了ClassPathBeanDefinitionScanner好吗？”。 TypeFilter只是一个接口，它的实现类在哪里？spring启动时会默认生成一个ClassPathBeanDefinitionScanner对象，该对象在初始化时会生成一坨默认的过滤器(上篇讲过)：

    protected void registerDefaultFilters() {
        this.includeFilters.add(new AnnotationTypeFilter(Component.class));
        ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();

        try {
            this.includeFilters.add(new AnnotationTypeFilter(ClassUtils.forName("javax.annotation.ManagedBean", cl), false));
            this.logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
        } catch (ClassNotFoundException var4) {
        }

        try {
            this.includeFilters.add(new AnnotationTypeFilter(ClassUtils.forName("javax.inject.Named", cl), false));
            this.logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
        } catch (ClassNotFoundException var3) {
        }

    }

看到没，就是AnnotationTypeFilter啦！

OK，我们先自定义一个注解:

public @interface MyAnnotation {
}

再生成两个业务类，加上上面的注解：

@MyAnnotation
public class MyClass {
}

@MyAnnotation
public class MyClass2 {
}

测试以下：

public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        //注册配置类
        context.register(Config.class);
        CustomScanner customScanner = new CustomScanner(context);
        customScanner.addIncludeFilter(new AnnotationTypeFilter(MyAnnotation.class));
  //将带有MyAnnotation注解的类扫描到springIOC容器中，并返回扫描的个数
        int num = customScanner.scan("com.scan");
        System.out.println("扫描的个数:"+num);
        context.refresh();

        System.out.println(context.getBean(MyClass.class));

    }
}
打印结果：
扫描的个数:2
com.scan.MyClass@1199fe66

哈哈，简单吧！其实，这就是spring扩展，要扩展就得懂spring源码，欢迎读者关注本专题，我将带大家深入分析并解开spring源码神秘面纱。现在java开发，逃不掉spring全家桶！ spring只能扫描实体类，抽象类和接口是不能扫描的，看上篇讲过的源码:

if (isCandidateComponent(sbd)) {
            if (debugEnabled) {
                    logger.debug("Identified candidate component class: " + resource);
                                }
            //返回BeanDefinition 注册到 BeanFactory
            candidates.add(sbd);
    }

isCandidateComponent这个方法判断如果是实体类返回true,如果是抽象类，但是抽象方法被 @Lookup 注解注释返回true。

    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        AnnotationMetadata metadata = beanDefinition.getMetadata();
        return (metadata.isIndependent() && (metadata.isConcrete() ||
                (metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
    }

也就是说如果你是接口，isCandidateComponent返回的是false，candidates.add(sbd);就不执行了，自然添加不到IOC容器中，mybatis就是修改了这个方法，让Mapper接口能扫描到IOC容器中的，我们先模拟：

@MyAnnotation
public interface MyInterFace {
    
    @Select("select * from table")
    public void select();
}

public class CustomScanner extends ClassPathBeanDefinitionScanner {
    public CustomScanner(BeanDefinitionRegistry registry) {
        super(registry);
    }

    @Override
    public void addIncludeFilter(TypeFilter includeFilter) {
        super.addIncludeFilter(includeFilter);
    }

    @Override
    protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
//如果是接口，则返回true，会添加到IOC容器中去
            return beanDefinition.getMetadata().isInterface();

    }
}

public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        //注册配置类
        context.register(Config.class);
        CustomScanner customScanner = new CustomScanner(context);
        customScanner.addIncludeFilter(new AnnotationTypeFilter(MyAnnotation.class));
        int num = customScanner.scan("com.scan");
        System.out.println("扫描的个数:"+num);
        context.refresh();
    }
}
打印结果
扫描的个数:1

然后，spring会根据MyInterFace生成一个动态代理类，并通过反射拿到你所有的方法，拿到方法后再通过反射拿到你的注解信息，还需要我继续说吗? 实际上，mybatis就是这么做的，不信看mybatis源码：

ClassPathMapperScanner.java // mybatis的自定义扫描类
   protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
    }

这就是spring扩展开发，插件开发就是这个原理吧，前提是你要对spring足够的掌握，欢迎大家关注本专题，一起精通spring源码。