How to still validate javax.validation annotated classes?

[roamingthings]

I'm running into an issue with Quarkus 3.21.3 where I need to validate model classes from an external library that are (still) annotated using the javax.validation.constraints annotations. There is no way of migrating this library to jakarta.validation.constraints.

I came up with the idea of adding constraints programmatically to these classes by implementing a ValidatorFactoryCustomizer that uses reflection to then generate the constraints programmatically.
This works when creating a Validator manually that is using the Hibernate ValidatorImpl. However, Quarkus pre-configures the validator using the PredefinedScopeValidatorFactoryImpl.
When determining which classes are constraint, Quarkus only accepts classes that are at least annotated with any validation annotation that refers to jakarta.validation.Constraint or one of the built in hibernate annotations.

Even beans that are added using the AdditionalConstrainedClassBuildItem are filtered out, when the do not have one of these annotations (io.quarkus.hibernate.validator.deployment.HibernateValidatorProcessor#beanValidationAnnotations). I've validated this by temporarily adding a jakarta.validation annotation to theses model beans.

From my understanding this means that I am not able to validate the beans of my model nor any other bean that doesn't have any of the mentioned annotations, even if I programmatically add constraints using a ValidatorFactoryCustomizer.

Do I miss something here? Is there any way of getting my external beans validated?

[gsmet]

If I were you, I would build a small Quarkus extension that rewrites the library bytecode. It would be done at build time once and for all. See https://quarkus.io/guides/building-my-first-extension for a guide on how to create your first extension.

Then your extension would be basically a build step similar to: https://github.com/quarkusio/quarkus/blob/3.15/extensions/quartz/deployment/src/main/java/io/quarkus/quartz/deployment/JakartaEnablement.java . It uses the Eclipse Transformer to rewrite things (make sure you have a look at its options to rewrite the right package).

I'm pretty sure listing the classes would be annoying, so what could could do instead is index the library with Jandex and inject a CombinedIndexBuildItem that will allow you to query the annotations.
You can find an example here for how to query the index:

quarkus/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheProcessor.java

Line 291 in 9d9405e

for (AnnotationInstance registerRestClientAnnotation : combinedIndex.getIndex().getAnnotations(REGISTER_REST_CLIENT)) {

You can also find some information about how to index the library here: https://quarkus.io/guides/cdi-reference#how-to-generate-a-jandex-index .

You can get all the built-in constraints from Hibernate Validator with ConstraintHelper.getBuiltinConstraints(), replace jakarta. by javax. in the class name and the query the index to find all the classes annotated by these annotations (and it might be a good idea to do a package check to avoid being too broad).

It should be very simple so if you hit a wall, don't hesitate to ping me here.

[roamingthings]

I have the feeling that my transformation is executed after the Validation extension already has built its factory.

So if I understand you correctly another way would be to take the original jar, do the transformation independently of Quarkus, generate a new jar from the transformed classes and then feed that into my Quarkus application?

[gsmet]

Yeah, you can use the Eclipse Jakarta Transformer directly on a jar and it will adjust the jar properly.

Are you following my instructions? How did you rewrite the classes?

[roamingthings]

This is what I ended up with following your first instructions plus the additional constraint beans.

When debugging it seems as if the actual transform() method is called after the io.quarkus.hibernate.validator.deployment.HibernateValidatorProcessor#build method.

Thank you again for your help.

// Imports obmitted for readability
public class JakartaValidationEnablement {

    private static final Class<?>[] CLASSES_TO_TRANSFORM = new Class<?>[] {
            // MyClasses.class are listed here... I've choosen an array since there are quite a few of them.
    };

    private static final List<String> CLASSES_NEEDING_TRANSFORMATION = Arrays.stream(CLASSES_TO_TRANSFORM).map(Class::getName).toList();

    @BuildStep
    void transformToJakarta(BuildProducer<BytecodeTransformerBuildItem> transformers) {
        if (QuarkusClassLoader.isClassPresentAtRuntime("jakarta.validation.Constraint")) {
            JakartaTransformer tr = new JakartaTransformer();
            for (String classname : CLASSES_NEEDING_TRANSFORMATION) {
                final BytecodeTransformerBuildItem item = new BytecodeTransformerBuildItem.Builder()
                                                                  .setCacheable(true)
                                                                  .setContinueOnFailure(false)
                                                                  .setClassToTransform(classname)
                                                                  .setClassReaderOptions(ClassReader.SKIP_DEBUG)
                                                                  .setInputTransformer(tr::transform)
                                                                  .build();
                transformers.produce(item);
            }
        }
    }

    @BuildStep
    void addExternalClassesToValidation(
            BuildProducer<AdditionalConstrainedClassBuildItem> additionalConstrainedClasses,
            BuildProducer<ReflectiveClassBuildItem> reflectiveClasses) {

        for (Class<?> modelClass : CLASSES_TO_TRANSFORM) {
            additionalConstrainedClasses.produce(
                    AdditionalConstrainedClassBuildItem.of(modelClass)
            );

            reflectiveClasses.produce(
                    ReflectiveClassBuildItem.builder(modelClass)
                            .methods(true)
                            .fields(true)
                            .build()
            );
        }
    }

    private static class JakartaTransformer {

        private final Logger logger;
        private final ActionContext ctx;
        // We need to prevent the Eclipse Transformer to adjust the "javax" packages.
        // Thus why we split the strings.
        private static final Map<String, String> renames = Map.of("javax" + ".validation", "jakarta.validation",
                                                                  "javax" + ".validation" + ".constraints", "jakarta.validation.constraints");

        JakartaTransformer() {
            logger = LoggerFactory.getLogger("JakartaTransformer");
            //N.B. we enable only this single transformation of package renames, not the full set of capabilities of Eclipse Transformer;
            //this might need tailoring if the same idea gets applied to a different context.
            ctx = new ActionContextImpl(logger,
                                        new SelectionRuleImpl(logger, Collections.emptyMap(), Collections.emptyMap()),
                                        new SignatureRuleImpl(logger, renames, null, null, null, null, null, Collections.emptyMap()));
        }

        byte[] transform(final String name, final byte[] bytes) {
            logger.info("Jakarta EE Validation compatibility enhancer for Quarkus: transforming " + name + " with " + bytes.length + " bytes");
            final ClassActionImpl classTransformer = new ClassActionImpl(ctx);
            final ByteBuffer input = ByteBuffer.wrap(bytes);
            final ByteData inputData = new ByteDataImpl(name, input, FileUtils.DEFAULT_CHARSET);
            final ByteData outputData = classTransformer.apply(inputData);
            return outputData.buffer().array();
        }
    }
}

[roamingthings]

When I reflect one of the transformed classes in a QuarkusTest I can see that the annotations have been transformed correctly.

[roamingthings]

Also generating a Validator manually using the default method also validates my model.

[roamingthings]

I decided to write and use an extension to transform the javax.validation references to jakarta.validatoin. Unfortunately, I was not able to get the Hibernate validator that is initialized by the Quarkus extension to recognize the transformed classes. So for now, I'm creating a second validator with the 'plain' factory provided by Hibernate validation. Also this may not be an optimal solution I had to somehow proceed and for now this works for me.

[gsmet]

If you have some time to prepare a small reproducer of where you were at, I would be interested to have a look and maybe @marko-bekhta too.

If we can make it work, we should probably document it, and also document how to use the Jakarta transformer to convert an existing jar.

[roamingthings]

I would also be interested in finding out more or even get it to work. I'm interested do lern more about how Quarkus works on the inside.
I will try to prepare a small project to reproduce this.

[roamingthings]

@gsmet @marko-bekhta I've set up an application to reproduce the issue at https://github.com/roamingthings/javax-validation-test

[marko-bekhta]

Thanks! I'll try to take a look soon.

BTW, with the newer Quarkus version (3.24+ where Hibernate Validator 9.0 is included) it should now be possible to define constraints just in the XML ( #5531 ). That's just in case someone else reads through this discussion and would find XML approach more suitable 😃 .