springcloud 默认扫描 spring组件扫描

@ComponentScan(basePackages = {“com”})

组件扫描
@ComponentScan等价于
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.scan("com");


模拟包扫描

获取项目真实路径
File file =new File(RealPath)
String[] files= file.list()
clazz = files.for(file.split(.class)[0])
class.forname(clazz)

扫描当前包及其子包

根据spring的包表达式进行扫描 classpath*:/com/**/*.class
• Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);

由源码可见Spring提供了一个资源扫描的类 可以根据spring的包表达式进行扫描

PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        try {
            Resource[] resource = resolver.getResources("classpath*:/com/atsun/**/*.class");
            for (int i = 0; i < resource.length; i++) {
                
                System.out.println(resource[i].getFilename()+"---------------");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }



或者

PathMatchingResourcePatternResolver resolver = (PathMatchingResourcePatternResolver)ResourcePatternUtils.getResourcePatternResolver(null);
 try {
     Resource[] resource = resolver.getResources("classpath*:/com/atsun/**/*.class");
     for (int i = 0; i < resource.length; i++) {

         System.out.println(resource[i].getFilename()+"---------------");
     }
 } catch (IOException e) {
     e.printStackTrace();
 }

TypeFilter

这里添加的typefilter

org.springframework.context.annotation.ComponentScanAnnotationParser#parse

确定加了@Compent注解后

• ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);

再判断是否有资格成为候选类，由就添加进候选集合

这也就是为什么接口上加了@Component注解还是无法扫描进容器的原因

+ 添加进候选集合

由源码可以看出，我们也可以借助spring的扫描器来自定义扫描路径，需要将判断条件修改成我们自己的就行了

添加自定义扫描

public class MyScanner extends ClassPathScanningCandidateComponentProvider {


    public MyScanner(){
        this.addIncludeFilter(new TypeFilter() {
            @Override
            public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
                return true;
            }
        });

    }

    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        AnnotationMetadata metadata = beanDefinition.getMetadata();
//	判断类是否有资格作为候选  有可能时内部类 ,接口或者抽象类,有没有加lookup
        return metadata.isInterface();
    }

}

第二种方法添加自定义扫描

@Retention(RetentionPolicy.RUNTIME)
public @interface Sunxxx {
}

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

    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        AnnotationMetadata metadata = beanDefinition.getMetadata();
		只要是接口就可以
        return metadata.isInterface();

    }

}

A a = new A(context);


//private final List<TypeFilter> includeFilters = new ArrayList<>();


注册	includeFilters 
a.addIncludeFilter(new AnnotationTypeFilter(Sunxxx.class));

int com = a.scan("com");


System.out.println(com);

mybatis

• 自定义就是改变isCandidateComponent方法的判断

再看一下是何时添加的TypeFilter --》 自定义过滤规则 CUSTOM @MapperScanner注解时就有使用

由 new AnnotationConfigApplicationContextnew —> ClassPathBeanDefinitionScanner() 一步步调用过来

在spring-mybatis中扫描的拓展

扫描在哪里执行的？

扫描是在执行BeanDefinitionRegistryPostProcess时执行的，进行扫描的类是他的一个子类ConfigurationClassProcess中

在创建spring应用时，先会调用父类实例化bean工厂

AnnotationConfigApplicationContext extend   GenericApplicationContext
public AnnotationConfigApplicationContext() {
	注册默认bd 
	this.reader = new AnnotatedBeanDefinitionReader(this);
	this.scanner = new ClassPathBeanDefinitionScanner(this);
}

这里注册默认的5个bd

在这个方法中会实例化实现了BeanDefinitionRegistryPostProcessor的类，而ConfigurationClassPostProcess就实现了这个类

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.List<org.springframework.beans.factory.config.BeanFactoryPostProcessor>)

此时已经有了bd，但是还没在容器中，如果getBean的话就会去创建它

bean工厂后置处理器

//			ConfigurationClassPostProcessor 是唯一一个实现了BeanDefinitionRegistryPostProcessor的类
//			执行 ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry
//			这个类中完成扫描 解析注解 当解析到import时 mybatis中执行import的类的 一个方法
扫描bd {
	普通注解，
	配置类
}
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);


先获取所有的bd candidateNames  默认5个+自己注册的配置类一个


else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
候选类是一个 ImportBeanDefinitionRegistrar -> 委托给它注册额外的 bean 定义
	Class<?> candidateClass = candidate.loadClass();

如果import的类 实现了ImportBeanDefinitionRegistrar接口, 主要是实例化它, 拓展点
	ImportBeanDefinitionRegistrar registrar =
			ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
					this.environment, this.resourceLoader, this.registry);

把实例好的ImportBeanDefinitionRegistrar 放入map中  后面会循环执行
	configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}

mybatis  就是在执行
ImportBeanDefinitionRegistrar.registerBeanDefinitions方法时，给bd中添加了一个
MapperScannerConfigurer的bd 他实现了 BeanDefinitionRegistryPostProcessor
等spring自己执行到BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry时再来完成扫描

新版中多了一个方式 可以不用@MapperScan注解了

因为MapperScannerConfigurer也实现了 BeanDefinitionRegistryPostProcessor

所以spring就会去执行他的方法

/**
 * customeimport.properties配置文件中的内容：
 * 		custome.importselector.expression= com.itheima.service.impl.*
 * @author 黑马程序员
 * @Company http://www.itheima.com
 */
public class CustomeImportSelector implements ImportSelector {

    private String expression;

    public CustomeImportSelector(){
        try {
            Properties loadAllProperties = PropertiesLoaderUtils.loadAllProperties("customeimport.properties");
            expression = loadAllProperties.getProperty("custome.importselector.expression");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 生成要导入的bean全限定类名数组
     * @param importingClassMetadata
     * @return
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //1.定义扫描包的名称
        String[] basePackages = null;
        //2.判断有@Import注解的类上是否有@ComponentScan注解
        if (importingClassMetadata.hasAnnotation(ComponentScan.class.getName())) {
            //3.取出@ComponentScan注解的属性
            Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(ComponentScan.class.getName());
            //4.取出属性名称为basePackages属性的值
            basePackages = (String[]) annotationAttributes.get("basePackages");
        }
        //5.判断是否有此属性（如果没有ComponentScan注解则属性值为null，如果有ComponentScan注解，则basePackages默认为空数组）
        if (basePackages == null || basePackages.length == 0) {
            String basePackage = null;
            try {
                //6.取出包含@Import注解类的包名
                basePackage = Class.forName(importingClassMetadata.getClassName()).getPackage().getName();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //7.存入数组中
            basePackages = new String[] {basePackage};
        }
        //8.创建类路径扫描器
        ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
        //9.创建类型过滤器(此处使用切入点表达式类型过滤器)
        TypeFilter typeFilter = new AspectJTypeFilter(expression,this.getClass().getClassLoader());
        //10.给扫描器加入类型过滤器
        scanner.addIncludeFilter(typeFilter);
        //11.创建存放全限定类名的集合
        Set<String> classes = new HashSet<>();
        //12.填充集合数据
        for (String basePackage : basePackages) {
            scanner.findCandidateComponents(basePackage).forEach(beanDefinition -> classes.add(beanDefinition.getBeanClassName()));
        }
        //13.按照规则返回
        return classes.toArray(new String[classes.size()]);
    }
}

/**
 * @author 黑马程序员
 * @Company http://www.itheima.com
 */
@Configuration
@ComponentScan("com.itheima")
@Import(CustomeImportDefinitionRegistrar.class)
public class SpringConfiguration {
}

/**
 * 自定义bean导入注册器
 * @author 黑马程序员
 * @Company http://www.itheima.com
 */
public class CustomeImportDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    private String expression;

    public CustomeImportDefinitionRegistrar(){
        try {
            Properties loadAllProperties = PropertiesLoaderUtils.loadAllProperties("customeimport.properties");
            expression = loadAllProperties.getProperty("custome.importselector.expression");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //1.定义扫描包的名称
        String[] basePackages = null;
        //2.判断有@Import注解的类上是否有@ComponentScan注解
        if (importingClassMetadata.hasAnnotation(ComponentScan.class.getName())) {
            //3.取出@ComponentScan注解的属性
            Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(ComponentScan.class.getName());
            //4.取出属性名称为basePackages属性的值
            basePackages = (String[]) annotationAttributes.get("basePackages");
        }
        //5.判断是否有此属性（如果没有ComponentScan注解则属性值为null，如果有ComponentScan注解，则basePackages默认为空数组）
        if (basePackages == null || basePackages.length == 0) {
            String basePackage = null;
            try {
                //6.取出包含@Import注解类的包名
                basePackage = Class.forName(importingClassMetadata.getClassName()).getPackage().getName();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //7.存入数组中
            basePackages = new String[] {basePackage};
        }
        //8.创建类路径扫描器
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry, false);
        //9.创建类型过滤器(此处使用切入点表达式类型过滤器)
        TypeFilter typeFilter = new AspectJTypeFilter(expression,this.getClass().getClassLoader());
        //10.给扫描器加入类型过滤器
        scanner.addIncludeFilter(typeFilter);
        //11.扫描指定包
        scanner.scan(basePackages);
    }
}