最简单的答案是遵循spring子项目(引导,数据……)如何实现这种类型的要求.它们通常定义一个自定义组合注释,该注释启用该功能并定义一组要扫描的包.

例如,给出这个注释：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import({MyInterfaceScanRegistrar.class})
public @interface MyInterfaceScan {
  String[] value() default {};
}

其中value定义要扫描的包,而@Import启用MyInterfaceScan检测.

然后创建ImportBeanDefinitionRegistrar.这个类将能够创建bean定义

Interface to be implemented by types that register additional bean
definitions when processing @Configuration classes. Useful when
operating at the bean definition level (as opposed to @Bean
method/instance level) is desired or necessary.

public class MyInterfaceScanRegistrar implements ImportBeanDefinitionRegistrar,EnvironmentAware {
  private Environment environment;
  @Override
  public void setEnvironment(Environment environment) {
    this.environment = environment;
  }
  @Override
  public void registerBeanDefinitions(AnnotationMetadata Metadata,BeanDefinitionRegistry registry) {
    // Get the MyInterfaceScan annotation attributes
    MapMetadata.getAnnotationAttributes(MyInterfaceScan.class.getCanonicalName());
    if (annotationAttributes != null) {
      String[] basePackages = (String[]) annotationAttributes.get("value");
      if (basePackages.length == 0){
        // If value attribute is not set,fallback to the package of the annotated class
        basePackages = new String[]{((StandardAnnotationMetadata) Metadata).getIntrospectedClass().getPackage().getName()};
      }
      // using these packages,scan for interface annotated with MyCustomBean
      ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false,environment){
        // Override isCandidateComponent to only scan for interface
        @Override
        protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
          AnnotationMetadata Metadata = beanDefinition.getMetadata();
          return Metadata.isIndependent() && Metadata.isInterface();
        }
      };
      provider.addIncludeFilter(new AnnotationTypeFilter(MyCustomBean.class));
      // Scan all packages
      for (String basePackage : basePackages) {
        for (BeanDefinition beanDefinition : provider.findCandidateComponents(basePackage)) {
          // Do the stuff about the bean definition
          // For example,redefine it as a bean factory with custom atribute... 
          // then register it
          registry.registerBeanDefinition(generateAName(),beanDefinition);
          System.out.println(beanDefinition);
        }
      }
    }
  }
}

这是逻辑的核心. bean定义可以被操作并重新定义为具有属性的bean工厂,或者使用来自接口的生成类重新定义.

MyCustomBean是一个简单的注释：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCustomBean {
}

哪个可以注释一个接口：

@MyCustomBean
public interface Class1 {
}

解决方案2：提取组件扫描

提取@ComponentScan中定义的包的代码会更复杂.

你应该创建一个BeanDefinitionRegistryPostProcessor并模仿ConfigurationClassPostProcessor：

>使用具有ComponentScan属性的声明类(例如,从ConfigurationClassPostProcessor中提取)迭代bean注册表以获取bean定义：

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
  ListMetadataReaderFactory)) {
      // Extract component scan
    }
  }
}

>像Spring一样提取这些属性

SetMetadata(),ComponentScans.class,ComponentScan.class);

>然后扫描包并注册bean定义,就像第一个解决方案一样