Configure Jersey/Jackson para NO usar la anotación de campo @XmlElement para el nombre de campo JSON

Question

Estoy ejecutando un servicio de REST de Jersey. Los POJO que representan mis recursos son clases Java simples anotadas JAXB (XML) (se generan a partir de una definición de esquema, por lo que tienen las anotaciones).

Quiero que Jersey/Jackson ignore las anotaciones XML. Hice esta configuración en mi web.xml (como se mencionó here):

<init-param> 
    <param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name> 
    <param-value>true</param-value> 
    </init-param> 

ahora que esperaba que la anotación @XMLElement no se usa más para la política de nombres de campo JSON.

Pero al mirar a este campo de Java (miembro)

@XmlElement(name = "person", required = true) 
protected List<Person> persons; 

sigo teniendo la siguiente representación JSON:

....,"person":[{"name":"FooBar", ....... (person without the 's') 

Todos los otros campos también todavía consiguen sus nombres JSON de la anotación en lugar @XmlElement del nombre de campo de Java.

Me gustaría obtener una salida JSON como se describe en Jackson Full Data Binding (POJO) Example.

Funciona bien en las pruebas simples como este (clases con mi XML anotado):

ObjectMapper mapper = new ObjectMapper(); 
    mapper.writeValue(System.out, myObject); 

pero incrustados en Jersey no he tenido la salida JSON esperado.

Son sus otras opciones de configuración en Jersey para obtener la representación POJO JSON 'simple' (porque esto se adapta mejor a los clientes que tienen que deserializar el resultado JSON).

Gracias Klaus

solución detallada

(1) aplicar una ContextResolver para Jacksons ObjectMapper que crea un ObjectMapper que no va a utilizar las anotaciones.

package foo.bar.jackson; 

import javax.ws.rs.Produces; 
import javax.ws.rs.core.MediaType; 
import javax.ws.rs.ext.ContextResolver; 
import javax.ws.rs.ext.Provider; 

import org.codehaus.jackson.map.DeserializationConfig; 
import org.codehaus.jackson.map.ObjectMapper; 
import org.codehaus.jackson.map.SerializationConfig; 

/** 
* Customized {@code ContextResolver} implementation that does not use any 
* annotations to produce/resolve JSON field names. 
*/ 
@Provider 
@Produces(MediaType.APPLICATION_JSON) 
public class JacksonContextResolver implements ContextResolver<ObjectMapper> { 

    private ObjectMapper objectMapper; 

    /** 
    * Creates a new instance. 
    * 
    * @throws Exception 
    */ 
    public JacksonContextResolver() throws Exception { 
     this.objectMapper = new ObjectMapper().configure(
       DeserializationConfig.Feature.USE_ANNOTATIONS, false) 
       .configure(SerializationConfig.Feature.USE_ANNOTATIONS, false); 
     ; 
    } 

    /** 
    * @see javax.ws.rs.ext.ContextResolver#getContext(java.lang.Class) 
    */ 
    public ObjectMapper getContext(Class<?> objectType) { 
     return objectMapper; 
    } 
} 

(2) Registrar el grano de primavera ContextResolver en su aplicacion.xml

<bean class="foo.bar.jackson.JacksonContextResolver"/> 

Answer 1

En el nivel bajo, lo que se necesita para asegurarse de que ObjectMapper NO utiliza JAXBAnnotationIntrospector, pero sólo por defecto JacksonAnnotationIntrospector. Creo que debería poder simplemente construir ObjectMapper (que no agrega JAXB introspector por defecto), y registrarlo a través del mecanismo de proveedor JAX-RS estándar. Esto debería anular ObjectMapper que la funcionalidad del mapeador POJO de lo contrario construiría.