Migrating from Jersey to RestEasy 4.7.7.final

[malakeel]

I am trying to migrate an existing application to RestEasy, running on WF 26. The existing application has many endpoint returning collections. The root for these collections is renamed to the plural of the single item when serializing to XML.
For example, assuming the return type is List, we get the XML response something like:

<books> <book>...</book> </books>

This behavior must be retained with RestEasy. However, RestEasy, serializes the collection with the root . For the above example, we end up with:

<collection> <book>...</book> </collection>

I was not able to find the exact Provider in Jersey or the equivalent Provider in RestEasy responsible for this feature. Is there a way to activate similar feature to obtain the same expected results ?

[jamezp]

Just as an FYI RESTEasy 4.7.x and WildFly 26 will no longer receive updates.

That said, have a look at https://docs.jboss.org/resteasy/docs/4.7.7.Final/userguide/html/Built_in_JAXB_providers.html#JAXB_Collections. What you likely want, assuming you can change the source, is the @org.jboss.resteasy.annotations.providers.jaxb.Wrapped annotation.

[malakeel]

Using the wrapped annotation means tagging every endpoint with this annotation. I am looking for a solution without having to change the source, like using a provider. With many endpoints, this is not doable at the moment. Following the example in the link you provided:

@GET
@Path("list")
@Produces("application/xml")
@Wrapped(element="list", namespace="http://foo.org", prefix="foo")
public List<Customer> getCustomerSet()

I am wondering if there's a configuration option or provider that I can activate to achieve the same results.

[jamezp]

I'll have to dig into this a bit as I'm not too familiar with this provider. However, this is the provider used https://github.com/resteasy/resteasy/blob/4.7/providers/jaxb/src/main/java/org/jboss/resteasy/plugins/providers/jaxb/CollectionProvider.java. As soon as I get some time, I'll look at what options there are.

FWIW I think it's valid not to want to annotate every endpoint. That definitely seems like overkill.

[malakeel]

Yes please. It will be highly appreciated. I can not move forward with the current migration without having this part resolved. I don't believe a widely used product like resteasy does not offer this feature. I have a feeling it is hidden somewhere.

[jamezp]

I don't really see an easy way to do this. Typically I think this should likely be done with with an @XmlElementWrapper.

The best I could come up with is something like this:

package dev.resteasy.examples.resources;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.concurrent.CompletionStage;

import jakarta.annotation.Priority;
import jakarta.enterprise.util.AnnotationLiteral;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.WebApplicationException;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.MultivaluedMap;
import jakarta.ws.rs.ext.Provider;
import org.jboss.resteasy.annotations.providers.jaxb.Wrapped;
import org.jboss.resteasy.plugins.providers.jaxb.CollectionProvider;
import org.jboss.resteasy.spi.AsyncOutputStream;

/**
 * @author <a href="mailto:[email protected]">James R. Perkins</a>
 */
@Provider
@Produces({"application/xml", "application/*+xml", "text/xml", "text/*+xml"})
@Consumes({"application/xml", "application/*+xml", "text/xml", "text/*+xml"})
@Priority(100)
public class XmlCollectionProvider extends CollectionProvider {
    @Override
    public Object readFrom(final Class<Object> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, String> httpHeaders, final InputStream entityStream) throws IOException, WebApplicationException {
        return super.readFrom(type, genericType, appendWrappedAnnotation(genericType, annotations), mediaType, httpHeaders, entityStream);
    }

    @Override
    public CompletionStage<Void> asyncWriteTo(final Object o, final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, Object> httpHeaders, final AsyncOutputStream entityStream) {
        return super.asyncWriteTo(o, type, genericType, appendWrappedAnnotation(genericType, annotations), mediaType, httpHeaders, entityStream);
    }

    @Override
    public void writeTo(final Object entry, final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, Object> httpHeaders, final OutputStream entityStream) throws IOException, WebApplicationException {
        super.writeTo(entry, type, genericType, appendWrappedAnnotation(genericType, annotations), mediaType, httpHeaders, entityStream);
    }

    private Annotation[] appendWrappedAnnotation(final Type genericType, final Annotation[] annotations) {
        if (genericType instanceof ParameterizedType) {
            // This is for collections only so we just want the first type to resolve the name from
            final var parameterizedType = (ParameterizedType) genericType;
            final var types = parameterizedType.getActualTypeArguments();
            if (types.length > 0) {
                final var type = types[0];
                var typeName = type.getTypeName();
                final int i = typeName.lastIndexOf('.');
                if (i > 0) {
                    typeName = typeName.substring(i + 1);
                }
                typeName = Character.toLowerCase(typeName.charAt(0)) + typeName.substring(1) + 's';
                final int length = annotations.length;
                final Annotation[] newAnnotations = Arrays.copyOf(annotations, length + 1);
                newAnnotations[length] = new WrappedType(typeName, null, "");
                return newAnnotations;
            }
        }
        return annotations;
    }

    private static class WrappedType extends AnnotationLiteral<Wrapped> implements Wrapped {

        private static final long serialVersionUID = 1L;
        private final String element;
        private final String namespace;
        private final String prefix;

        private WrappedType(final String element, final String namespace, final String prefix) {
            this.element = element;
            this.namespace = namespace;
            this.prefix = prefix;
        }

        @Override
        public String element() {
            return element;
        }

        @Override
        public String namespace() {
            return namespace;
        }

        @Override
        public String prefix() {
            return prefix;
        }
    }
}

Note that I through this together quickly so there are some potential bugs with resolving the name of the type.

The other option is to have a custom MessageBodyReader and/or MessageBodyWriter for the types you want to serialize/deserialize.