Spring Native Process-AOT无法注册Lambda：如何动态添加捕获类？

解决方案：在Spring AOT阶段自动将@Service类注册到lambdaCapturingTypes #

方案一：结合RuntimeHintsRegistrar与自定义Native Image Feature

这种方式通过自动扫描@Service类，在AOT阶段收集目标类，再通过Native Image Feature注册为lambda捕获类，无需手动维护配置。

1. 创建类收集器与RuntimeHintsRegistrar

import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.RuntimeHintsRegistrar;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.stereotype.Service;

import java.util.Set;
import java.util.stream.Collectors;

public class LambdaCapturingServiceHintsRegistrar implements RuntimeHintsRegistrar {

    @Override
    public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
        // 扫描指定包下所有带@Service注解的类
        ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
        scanner.addIncludeFilter(new AnnotationTypeFilter(Service.class));
        
        Set<String> serviceClassNames = scanner.findCandidateComponents("com.shushang")
                .stream()
                .map(beanDef -> beanDef.getBeanClassName())
                .collect(Collectors.toSet());
        
        // 注册持有类的反射信息，确保Native Image构建时能读取到收集的类名
        hints.reflection().registerType(LambdaCapturingClassesHolder.class, hint -> hint.withField("serviceClassNames"));
        LambdaCapturingClassesHolder.setServiceClassNames(serviceClassNames);
    }
}

// 用于传递收集到的服务类名的持有类
class LambdaCapturingClassesHolder {
    private static Set<String> serviceClassNames;

    public static void setServiceClassNames(Set<String> serviceClassNames) {
        LambdaCapturingClassesHolder.serviceClassNames = serviceClassNames;
    }

    public static Set<String> getServiceClassNames() {
        return serviceClassNames;
    }
}

2. 自定义Native Image Feature注册lambda捕获类

import org.graalvm.nativeimage.hosted.Feature;
import org.graalvm.nativeimage.hosted.RuntimeSerialization;

import java.util.Set;

public class AutoLambdaCapturingFeature implements Feature {

    @Override
    public void duringSetup(DuringSetupAccess access) {
        Set<String> serviceClassNames = LambdaCapturingClassesHolder.getServiceClassNames();
        if (serviceClassNames == null) return;
        
        for (String className : serviceClassNames) {
            try {
                Class<?> clazz = Class.forName(className);
                RuntimeSerialization.registerLambdaCapturingClass(clazz);
            } catch (ClassNotFoundException e) {
                throw new RuntimeException("加载lambda捕获类失败: " + className, e);
            }
        }
    }
}

3. 注册组件并配置构建参数

• 在Spring配置类中注册RuntimeHintsRegistrar：

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportRuntimeHints;

@Configuration
@ImportRuntimeHints(LambdaCapturingServiceHintsRegistrar.class)
public class AotConfig {
}

• 在application.properties中添加Native Image构建参数：

spring.native.image.build.args=--features=com.shushang.AutoLambdaCapturingFeature

方案二：直接修改AOT生成的serialization-config.json

通过自定义ApplicationContextAotProcessor，在AOT生成配置文件后直接修改，将@Service类添加到lambdaCapturingTypes数组。

import org.springframework.aot.context.DefaultApplicationContextAotProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.stereotype.Service;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.File;
import java.io.IOException;
import java.util.Set;
import java.util.stream.Collectors;

public class CustomAotProcessor extends DefaultApplicationContextAotProcessor {

    @Override
    protected void postProcessGeneratedFiles(ApplicationContext applicationContext, File generatedFilesDir) {
        super.postProcessGeneratedFiles(applicationContext, generatedFilesDir);
        
        File serializationConfig = new File(generatedFilesDir, "META-INF/native-image/serialization-config.json");
        if (!serializationConfig.exists()) return;
        
        try {
            ObjectMapper mapper = new ObjectMapper();
            ObjectNode root = (ObjectNode) mapper.readTree(serializationConfig);
            
            // 扫描@Service类
            ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
            scanner.addIncludeFilter(new AnnotationTypeFilter(Service.class));
            Set<String> serviceClassNames = scanner.findCandidateComponents("com.shushang")
                    .stream()
                    .map(beanDef -> beanDef.getBeanClassName())
                    .collect(Collectors.toSet());
            
            // 添加到lambdaCapturingTypes
            ObjectNode lambdaNode = root.withArray("lambdaCapturingTypes");
            for (String className : serviceClassNames) {
                ObjectNode typeNode = mapper.createObjectNode();
                typeNode.put("name", className);
                lambdaNode.add(typeNode);
            }
            
            mapper.writeValue(serializationConfig, root);
        } catch (IOException e) {
            throw new RuntimeException("修改serialization-config.json失败", e);
        }
    }
}

然后在application.properties中指定自定义处理器：

spring.aot.processor=com.shushang.CustomAotProcessor

注意事项 #

• 将代码中的com.shushang替换为你的项目基础包路径，确保能扫描到所有目标类。
• 两种方案均适用于Spring Boot 3.x及以上版本（支持AOT特性）。

内容的提问来源于stack exchange，提问作者Qeir Mr.钟