Spring Native中注册自定义注解类：AOT处理器vs导入注册器

我需要让所有带有自定义注解的类在Native运行时可见，已知要在Native应用启动前的processAOT编译阶段完成注册。想知道正确的实现方式是用BeanRegistrationAotProcessor还是ImportBeanDefinitionRegistrar？有没有更简便的方案？我已经尝试过这两种方式，都能正常将类添加到BeanDefinitions中，但想了解更优解。

方案一：使用ImportBeanDefinitionRegistrar #

1. 定义启用注解并导入注册器 #

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.CLASS)
@Import(KafkaMessages.KafkaMessagesRegistrar::class)
annotation class EnableKafkaMessages

2. 实现注册器与支持类 #

class KafkaMessageSupport(val classes: Set<Class<*>>) {

    class KafkaMessagesRegistrar : ImportBeanDefinitionRegistrar {
        override fun registerBeanDefinitions(metadata: AnnotationMetadata, registry: BeanDefinitionRegistry) {
            val kafkaMessages = findKafkaMessages(metadata)

            if (registry.containsBeanDefinition(BEAN)) {
                val beanDefinition = registry.getBeanDefinition(BEAN)
                beanDefinition.constructorArgumentValues.addIndexedArgumentValue(0, kafkaMessages)
            } else {
                val mongockSupportBeanDefinitionBuilder =
                    BeanDefinitionBuilder
                        .rootBeanDefinition(KafkaMessageSupport::class.java)
                        .addConstructorArgValue(kafkaMessages)

                registry.registerBeanDefinition(BEAN, mongockSupportBeanDefinitionBuilder.beanDefinition)
            }
        }

        private fun findKafkaMessages(metadata: AnnotationMetadata): MutableSet<Class<*>> {
            // 实现逻辑：扫描并返回带有KafkaMessage注解的类
            ... 
            return classes
        }
    }

    companion object {
        @JvmStatic
        val BEAN: String = KafkaMessageSupport::class.java.name
    }
}

3. 实际使用示例 #

@Configuration
@EnableKafkaMessages
class KafkaTopicResolverConfiguration(private val kafkaMessageSupport: KafkaMessageSupport) {
    @Bean
    fun kafkaTopics(applicationContext: ApplicationContext): KafkaTopicResolver {
        return KafkaTopicResolver(kafkaMessageSupport.classes.associateWith { it.simpleName })
    }
}

4. IDE兼容补充配置 #

为避免IntelliJ报错，添加兜底Bean定义：

@Configuration(proxyBeanMethods = false)
@EnableKafkaMessages
class KafkaMessagesConfiguration {
    @Bean
    @ConditionalOnMissingBean
    fun kafkaMessages() = KafkaMessages(setOf())
}

方案二：使用BeanRegistrationAotProcessor #

1. 定义基础Bean #

@Configuration
class MongockConfiguration {
    @Bean
    fun mongockRunnerSupport() = MongockRunnerSupport()
}

2. 实现AOT处理器 #

class ChangeUnitBeanRegistrationAotProcessor : BeanRegistrationAotProcessor {
    override fun processAheadOfTime(registeredBean: RegisteredBean): BeanRegistrationAotContribution? {
        if (registeredBean.beanClass == MongockRunnerSupport::class.java) {
            return object : RegisteredBeanAotContribution {
                override fun applyTo(
                    generationContext: GenerationContext,
                    beanRegistrationCode: BeanRegistrationCode
                ) {
                    source.mergedBeanDefinition.propertyValues.addPropertyValue(
                        "changeUnitClasses",
                        AnnotatedTypeScanner(ChangeUnit::class.java).findTypes(
                            "io.mongock.runner.core.executor.system.changes",
                            "me.tmarciniak.springbootstarter"
                        )
                    )
                }

                override fun getSource(): RegisteredBean {
                    return registeredBean
                }
            }
        } else {
            return null
        }
    }
}

方案对比 #

• ImportBeanDefinitionRegistrar：仅针对指定Bean触发逻辑，无需遍历所有Bean；但需要额外定义@ConditionalOnMissingBean的Bean来兼容IDE。
• BeanRegistrationAotProcessor：会遍历所有注册的Bean，需要额外判断目标类型；可以直接为已存在的Bean设置参数，无需兜底Bean。

AOT生成结果对比 #

BeanRegistrationAotProcessor生成的Bean定义 #

public static BeanDefinition getMongockRunnerSupportBeanDefinition() {
    RootBeanDefinition beanDefinition = new RootBeanDefinition(MongockRunnerSupport.class);
    beanDefinition.getPropertyValues().addPropertyValue("changeUnitClasses", Set.of(AddEntityViewCollection00001.class, SystemChangeUnit00001.class));
    beanDefinition.setInstanceSupplier(getMongockRunnerSupportInstanceSupplier());
    return beanDefinition;
}

ImportBeanDefinitionRegistrar生成的Bean定义 #

public static BeanDefinition getKafkaMessagesBeanDefinition() {
    RootBeanDefinition beanDefinition = new RootBeanDefinition(KafkaMessages.class);
    beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, Set.of(EntityUpdatedEventMessage.class, EntityCreatedEventMessage.class, EntityDeletedEventMessage.class));
    beanDefinition.setInstanceSupplier(getKafkaMessagesInstanceSupplier());
    return beanDefinition;
}

最终结论 #

优先选择**ImportBeanDefinitionRegistrar**，原因如下：

1. 它专为导入单个Bean设计，无需在@Configuration中提前定义@Bean，仅通过@Import即可引入。
2. 与AOT无关，同时兼容常规Spring应用和Spring Native应用。

优化后的通用实现示例 #

定义启用注解

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.CLASS)
@Import(ChangeUnitSupport::class, ChangeUnitSupport.ChangeUnitsRegistrar::class)
annotation class EnableChangeUnits(
    val basePackages: Array<String> = []
)

实现注册器与支持类

class ChangeUnitSupport(val changeUnitClasses: Set<Class<*>>) {

    class ChangeUnitsRegistrar : ImportBeanDefinitionRegistrar {
        override fun registerBeanDefinitions(metadata: AnnotationMetadata, registry: BeanDefinitionRegistry) {
            val annotation = EnableChangeUnits::class.java
            val attributes = metadata.getAnnotationAttributes(annotation.name)
                ?: throw IllegalStateException("无法获取注解$annotation的属性")
            val annotationAttributes = AnnotationAttributes(attributes)
            val packages = annotationAttributes.getStringArray("basePackages").toList()
            val changeUnitClasses = findChangeUnits(packages)

            if (registry.containsBeanDefinition(BEAN)) {
                val beanDefinition = registry.getBeanDefinition(BEAN)
                beanDefinition.constructorArgumentValues.addIndexedArgumentValue(0, changeUnitClasses)
            } else {
                val beanDefinitionBuilder = BeanDefinitionBuilder
                    .rootBeanDefinition(ChangeUnitSupport::class.java)
                    .addConstructorArgValue(changeUnitClasses)
                registry.registerBeanDefinition(BEAN, beanDefinitionBuilder.beanDefinition)
            }
        }

        private fun findChangeUnits(packages: List<String>): MutableSet<Class<*>> =
            AnnotatedTypeScanner(ChangeUnit::class.java).findTypes(packages)
    }

    companion object {
        @JvmStatic
        val BEAN: String = ChangeUnitSupport::class.java.name
    }
}

未来简化展望 #

期望Spring后续能提供更简洁的注解式支持，例如：

@EnableAnnotatedClassesSupport(
    annotationName = "xyz", 
    packages = ["com.xyz"], 
    supportClass = sample.Xyz::class
)

自动创建指定的支持类Bean，并注入所有符合条件的带注解类。

内容的提问来源于Stack Exchange，提问作者Tomasz Marciniak