How to auto register POJOs for reflection?

[IvanPuntev]

Is there a way to auto register for reflection all java models in the project without adding @RegisterForReflection annotation on each of them? I also have the jandex-maven-plugin but it doesn't work. If the models are packaged as jar from an external project which has the plugin then it works.

[cescoffier]

CC @Ladicek

[Ladicek]

I'm no expert on this topic (CC @geoand, who I'm sure knows more about the topic than me), but I'm not aware of any mechanism for bulk registering classes for reflection outside of Quarkus extension.

In a Quarkus extension, it should be relatively straightforward to obtain all classes you need from Jandex and produce ReflectiveClassBuildItem for them.

Outside of an extension, you can either annotate each class with @RegisterForReflection, or you can put the @RegisterForReflection annotation on a separate class and list all classes in targets or classNames. That still requires listing all class names, so not a terribly huge improvement, but it's useful if you need to register for reflection classes that you don't control.

[geoand]

I agree on all counts

[IvanPuntev]

@geoand Would it be possible to implement such solution myself? I see the existence of ReflectiveClassBuildItem and CombinedIndexBuildItem. Maybe a new build step in the extension processor? I use my common / core extension inside all of my projects so if this can be automated I would not need to register everything.

[geoand]

Sure, as @Ladicek mentions, it would be easy to do in an extension

[IvanPuntev]

@geoand @Ladicek I've implemented this solution and it works just fine for my needs.

import io.quarkus.deployment.annotations.BuildProducer;
import io.quarkus.deployment.annotations.BuildStep;
import io.quarkus.deployment.builditem.*;
import io.quarkus.deployment.builditem.nativeimage.ReflectiveClassBuildItem;
import io.quarkus.deployment.builditem.nativeimage.ReflectiveHierarchyBuildItem;
import io.quarkus.deployment.pkg.steps.NativeOrNativeSourcesBuild;
import org.jboss.jandex.AnnotationInstance;
import org.jboss.jandex.ClassInfo;
import org.jboss.jandex.DotName;
import org.jboss.logging.Logger;

import java.lang.reflect.Modifier;
import java.util.List;

public class ReflectionProcessor {

    private static final String FEATURE = "integration-reflection-processor";
    private static final Logger log = Logger.getLogger(ReflectionProcessor.class);

    private static final List<DotName> excludeAnnotations = List.of( //leave jakarta.validation
        DotName.createSimple("io.quarkus.runtime.annotations.RegisterForReflection"), //skip already registered ones
        // JAX-RS
        DotName.createSimple("jakarta.ws.rs.Path"), // REST resources
        DotName.createSimple("jakarta.ws.rs.ext.Provider"), // ExceptionMappers, Filters, etc.
        // CDI
        DotName.createSimple("jakarta.inject.Inject"),
        DotName.createSimple("jakarta.inject.Named"),
        DotName.createSimple("jakarta.inject.Singleton"),
        DotName.createSimple("jakarta.enterprise.context.ApplicationScoped"),
        DotName.createSimple("jakarta.enterprise.context.Dependent"),
        DotName.createSimple("jakarta.enterprise.context.RequestScoped"),
        DotName.createSimple("jakarta.enterprise.context.SessionScoped"),
        // Tests
        DotName.createSimple("io.quarkus.test.junit.QuarkusTest"),
        DotName.createSimple("io.quarkus.test.junit.QuarkusIntegrationTest"),
        DotName.createSimple("io.quarkus.test.InjectMock"),
        DotName.createSimple("org.junit.jupiter.api.Test"),
        DotName.createSimple("org.junit.jupiter.params.ParameterizedTest")
    );

    ReflectionProcessorConfig reflectionProcessorConfig;

    @BuildStep
    FeatureBuildItem feature() {
        return new FeatureBuildItem(FEATURE);
    }

    @BuildStep(onlyIf = NativeOrNativeSourcesBuild.class)
    void registerForReflection(
        BuildProducer<ReflectiveClassBuildItem> reflectiveClassProducer,
        BuildProducer<ReflectiveHierarchyBuildItem> reflectiveHierarchyProducer,
        ApplicationArchivesBuildItem applicationArchivesBuildItem
    ) {
        if (!reflectionProcessorConfig.enabled()) {
            log.warn("Reflection discovery is disabled.");
            return;
        }

        List<String> classNames = applicationArchivesBuildItem.getRootArchive().getIndex().getKnownClasses().parallelStream()
        .filter(
            classInfo -> !classInfo.isInterface()
            && !Modifier.isAbstract(classInfo.flags())
            && !classInfo.isSynthetic()
        )
        .filter(
            classInfo -> !isStaticUtilityClass(classInfo)
            && !classInfo.name().toString().contains("$") // inner / anonymous classes
            && classInfo.annotations().stream().map(AnnotationInstance::name).noneMatch(excludeAnnotations::contains)
        )
        .map(ClassInfo::name)
        .map(DotName::toString)
        .sorted()
        .toList();

        if (classNames.isEmpty()) {
            log.info("No classes detected that need reflection.");
            return;
        }

        log.info("Registering %d classes for reflection:%n%s".formatted(classNames.size(), "  - " +String.join("\n  - ", classNames)));

        classNames.forEach(
            className -> {
                reflectiveClassProducer.produce(
                    ReflectiveClassBuildItem.builder(className)
                    .methods(true)
                    .fields(true)
                    .constructors(true)
                    .build()
                );

                reflectiveHierarchyProducer.produce(
                    ReflectiveHierarchyBuildItem.builder(className).build()
                );
            }
        );
    }

    private boolean isStaticUtilityClass(ClassInfo classInfo) {
        boolean onlyStaticMethods = classInfo.methods().stream().allMatch(m -> m.name().equals("<init>") || Modifier.isStatic(m.flags()));
        boolean onlyStaticFields = classInfo.fields().stream().allMatch(f -> Modifier.isStatic(f.flags()));
        boolean hasPrivateConstructors = classInfo.constructors().stream().allMatch(m -> Modifier.isPrivate(m.flags()));
        return onlyStaticMethods && onlyStaticFields && (classInfo.constructors().isEmpty() || hasPrivateConstructors);
    }

}

[Ladicek]

IndexView.getKnownClasses() is a fairly heavy hammer, but I don't immediately see how autoRegisterModelClassesForReflection() could be implemented without it. I think registerJacksonClassesForReflection() could be implemented using IndexView.getAnnotations() and IndexView.getAllKnownSubclasses(), but what you have also works, so 👍

[IvanPuntev]

@Ladicek If I want to make this configurable then where should I place the build time config (smallrye)? Inside the deployment module? And later get it from the build step as a method parameter? I've read the quarkus configuration documentation but couldn't find such similar case.

[geoand]

Build time configuration can indeed be in the deployment module

[Ladicek]

Yes, this is also written in https://quarkus.io/guides/writing-extensions#config-phases

[IvanPuntev]

A little update. Instead of CombinedIndexBuildItem I started using ApplicationArchivesBuildItem. Then I get the index from its getRootArchive().getIndex() method which represents the classes and resources that are only part of the current project.