如何利用Spring的@Import扩展点与spring进行无缝整合

利用Spring的@import扩展与spring进行无缝整合前言BeanFactoryPostProcessor@import实现POM文件定义数据层Resource（dao）层的扫描注解定义我的数据层Resource使用的注解ArteryResourceimportBeanDefinitionRegistrar实现自定义扫描类ClassPathArteryResourceScanner代理注册工厂ResourceRegistryResouce的代理工厂真正的代理类方法调用类AbstractBeanDefinitionFactory我们编写测试，来启动我们的spring容器类图

前言

spring有那些扩展呢？
spring的扩展非常多，比较常用的就是
BeanFactoryPostProcessor 我们可以插手spring bean工厂的初始化
BeanPostProcessor 我们可以插手spring bean实例化前后（比如SPRING AOP)
@import
importAware。

BeanFactoryPostProcessor

spring的扩展点之一BeanFactoryPostProcessor,这个学名叫spring的Bean工厂后置处理器，
它可以插手spring bean工厂的实例化，我们可以启动spring的时候自己手动注册一个bean工厂后置处理器，它能做的事情太多，研究过spring源码的同学都知道，spring容器启动时候，会先暴露一个工厂出来，这个工厂就是DefaultListableBeanFactory，这里面放置了我们的BeanDeinition，我们都知道spring 单例bean容器放了很多单例的bean，而这些bean最后都是来自于DefaultListableBeanFactory中的bd容器；
BeanFactoryPostProcessor是spring提供给我们来扩展spring的，当然了它自己也在用，spring有自己内部的bean工厂后置处理器，处理的时候讲我们的和spring自己的一起处理。我们只需要把我们新建的类实现了BeanFactoryPostProcessor，并且加入@Component或者交给@import就可以了。实现这个接口必须实现它的一个方法，它的这个方法就可以得到我们的beanDefinittionMap，也就是bdmap，这里面放置了我们系统所有的注册到spring容器里面的bd，最后spring循环这个bd，将其实例化成对象放入Bean容器。

今天我们的主题是使用sprinng的扩展点之一的@import来实现公司的平台与spring整合，类似于Mybatis与spring整合一样

@import

这个要说就要说很久，如果没有研究过spring底层源码的，可以去研究下，功能非常强大这边我大概介绍一下：
@import支持3中类型：
普通类（spring管理的类）：就是讲一个普通的类通过@import导入，而不适用@Component,但是这样做毫无意义。
实现了importSelector：实现这个接口要求实现它的一个方法返回一个类名列表
Registrar：真正牛逼的注册类，实现了它，我们可以手动往里面添加自己的BeanDefiniton，自己实现扫描机制，自己实现很多很多自己的逻辑（mybatis整合spring就用的它）

实现

我的工程命名是：xxx-spring-platform-1.0.REALSE
xxx是公司的简称
工程结构：

其中context是核心，core是一些常用的核心类，aop写了一半，还没完成

POM文件

  org.springframework
  spring-core
  5.2.7.RELEASE
  
  
  org.springframework
  spring-context
  5.2.7.RELEASE
  
  
  org.springframework
  spring-beans
  5.2.7.RELEASE
  
  
  org.springframework
  spring-aop
  5.2.7.RELEASE
  
  
  org.springframework
  spring-context-support
  5.2.7.RELEASE
  

就是用了srping的几个基础包

定义数据层Resource（dao）层的扫描注解

@documented
@Retention(RUNTIME)
@Target(TYPE)
@import(ArteryResourceimportBeanDefinitionRegistrar.class)
//这个是用了spring的@import
//其中用了其扩展点之一的@import中的Registrar，ArteryResourceimportBeanDefinitionRegistrar才是我们的核心所在
public @interface ArteryResourceScan {

 String[] value() default {};

 
 String[] basePackages() default {};

 
 String[] typeAliases() default {};

 
 Class factoryBean() default ArteryResourceFactoryBean.class;

 
 Class annotationClass() default Annotation.class;

 
 Class markerInterface() default Class.class;

 

 Class nameGenerator() default BeanNameGenerator.class;

 
 boolean lazy() default false;

 
 String scope() default AbstractBeanDefinition.SCOPE_SINGLETON;

}

定义我的数据层Resource使用的注解

ArteryResourceimportBeanDefinitionRegistrar实现

我们的注册类实现了spring的即可importBeanDefinitionRegistrar，而importBeanDefinitionRegistrar提供了一个方法registerBeanDefinitions可以得到我们的ArteryResourceScan 注解，从而定义自己的扫描规则，使用spring的的扫描逻辑帮助我们完成扫描，然后注册到bdmap里面，因我们的Resource层是接口，而spring实例化是不能实例化接口的，所以当spring帮我们扫描成bd的时候，我们这个时候要这个扫描的列表取出来，替换我们的接口类，怎么替换呢？
因为接口需要被代理出去，而代理类帮我们完成我们想要做的事情，比如数据查询，所以我们还需要定义一个工厂bean即FactoryBean，它来帮我们产生对象，FactoryBean也是一个Bean，但是他比较特殊，它可以产生对象，我们先看Registrar的实现：

public class ArteryResourceimportBeanDefinitionRegistrar implements importBeanDefinitionRegistrar {

 private final String DEFAULT_RESOURACE_PATTERN = "**
  AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassmetadata.getAnnotationAttributes(ArteryResourceScan.class.getName()));

  Class factoryBean = annoAttrs.getClass("factoryBean");
  if (!ArteryResourceFactoryBean.class.equals(factoryBean)) {
   scanner.setArteryResourceFactoryBean(BeanUtils.instantiateClass(factoryBean));
  }
  Class annotionClass = annoAttrs.getClass("annotationClass");
  if (!Annotation.class.equals(annotionClass)) {
   scanner.setAnnotationClass(annotionClass);
  }
  Class markerInteface = annoAttrs.getClass("markerInterface");
  if (!Class.class.equals(markerInteface)) {
   scanner.setMarkerInterface(markerInteface);
  }

  Class nameGenerator = annoAttrs.getClass("nameGenerator");
  if (!BeanNameGenerator.class.equals(nameGenerator)) {
   scanner.setBeanNameGenerator(BeanUtils.instantiateClass(nameGenerator));
  }
  scanner.setLazy(annoAttrs.getBoolean("lazy"));
  scanner.setResourceScope(annoAttrs.getString("scope"));
  //base package handler
  List basePackages = new ArrayList<>(20);
  Arrays.asList(annoAttrs.getStringArray("basePackages")).forEach(item -> {
   if (StringUtils.hasText(item)) {
    basePackages.add(item);
   }
  });
  Arrays.asList(annoAttrs.getStringArray("value")).forEach(item -> {
   if (StringUtils.hasText(item)) {
    basePackages.add(item);
   }
  });


  
  String[] typeAlis = annoAttrs.getStringArray("typeAliases");
  if (typeAlis != null && typeAlis.length > 0) {
   ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
   metadataReaderFactory metadataReaderFactory = new CachingmetadataReaderFactory(resolver);
   //typeAliaes
   for (String typeAliases : Arrays.asList(annoAttrs.getStringArray("typeAliases"))) {
    getResource(resolver, metadataReaderFactory, typeAliases, basePackages);
   }
  }
  scanner.registerFilters();
  scanner.doScan(StringUtils.toStringArray(basePackages));
 }

 private void getResource(ResourcePatternResolver resolver, metadataReaderFactory metadataReaderFactory, String classPath, List basePackages) {
  classPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + ClassUtils.convertClassNameToResourcePath(classPath) + "/" + DEFAULT_RESOURACE_PATTERN;
  try {
   Resource[] resources = resolver.getResources(classPath);
   if (resources != null && resources.length > 0) {
    metadataReader metadataReader = null;
    for (Resource resource : resources) {
     if (resource.isReadable()) {
      metadataReader = metadataReaderFactory.getmetadataReader(resource);
      basePackages.add(Class.forName(metadataReader.getClassmetadata().getClassName()).getPackage().getName());
     }
    }
   }
  } catch (IOException | ClassNotFoundException e) {
   e.printStackTrace();
  }
 }
}

以上代码的doScan方法是核心，是调用了我们自定义的扫描类

自定义扫描类ClassPathArteryResourceScanner

public class ClassPathArteryResourceScanner extends ClassPathBeanDefinitionScanner {
 private final Logger logger = LoggerFactory.getLogger(ClassPathArteryResourceScanner.class);
 
 private ArteryResourceFactoryBean arteryResourceFactoryBean = new ArteryResourceFactoryBean