Validez JAXBElement dans le service Web JPA / JAX-RS

J'ai un JAX-RS webservice (Jersey) qui est une interface CRUD pour JPA (EclipseLink) les entités. Mes entités ont été générés automatiquement à partir des tables de base de données et j'ai annoté avec des annotations JAXB afin qu'ils puissent être placés/unmarshalled vers/à partir de XML. Ma ressource méthodes prennent JAXBElement objets en tant que paramètre si nécessaire.

Je n'ai pas de XSD, cependant, je suis prêt à en écrire un pour valider le XML reçu dans les demandes. Mais, je ne sais pas comment lancer la validation. Jersey est gérer automatiquement le marshalling/unmarshalling et toutes les références que j'ai trouvé sur la validation se fait à ce niveau.

Ce que quelqu'un sait d'un exemple de/tutoriel qui montre comment faire cela?

Merci!

source d'informationauteur sdoca

  1. 15

    Vous pourriez gérer ce par la création d'une coutume MessageBodyReader. L'exemple ci-dessous est basé sur un modèle Client:

    import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.net.URL;
import javax.ws.rs.Consumes;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.Provider;
import javax.ws.rs.ext.Providers;
import javax.xml.XMLConstants;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
@Provider
@Consumes("application/xml")
public class ValidatingReader implements MessageBodyReader<Customer> {
@Context
protected Providers providers;
private Schema schema;
public ValidatingReader() {
try {
SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
URL schemaURL = null;
schema = sf.newSchema(schemaURL);
} catch(Exception e) {
throw new RuntimeException(e);
}
}
public boolean isReadable(Class<?> arg0, Type arg1, Annotation[] arg2, MediaType arg3) {
return arg0 == Customer.class;
}
public Customer readFrom(Class<Customer> arg0, Type arg1, Annotation[] arg2, MediaType arg3, MultivaluedMap<String, String> arg4, InputStream arg5)
throws IOException, WebApplicationException {
try {
JAXBContext jaxbContext = null;
ContextResolver<JAXBContext> resolver = providers.getContextResolver(JAXBContext.class, arg3);
if(null != resolver) {
jaxbContext = resolver.getContext(arg0);
}
if(null == jaxbContext) {
jaxbContext = JAXBContext.newInstance(arg0);
}
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
unmarshaller.setSchema(schema);
return (Customer) unmarshaller.unmarshal(arg5);
} catch(JAXBException e) {
throw new RuntimeException(e);
}
}
}
  2. 9

    Nous pouvons aller plus loin et créer un générique (résumé) ValidatingReader qui peut être sous-classée comme et quand nécessaire. C'est ce que j'ai fait, grâce à l'idée de Blaise:

    import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.Providers;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
public abstract class AbstractValidatingReader<T> implements
MessageBodyReader<T> {
@Context
protected Providers providers;
@SuppressWarnings("unchecked")
@Override
public boolean isReadable(Class<?> arg0, Type arg1, Annotation[] arg2,
MediaType arg3) {
Class<T> readableClass = (Class<T>) ((ParameterizedType) getClass()
.getGenericSuperclass()).getActualTypeArguments()[0];
return arg0 == readableClass;
}
@SuppressWarnings("unchecked")
@Override
public T readFrom(Class<T> arg0, Type arg1, Annotation[] arg2,
MediaType arg3, MultivaluedMap<String, String> arg4,
InputStream arg5) throws IOException, WebApplicationException {
T type = null;
JAXBContext jaxbContext = null;
ContextResolver<JAXBContext> resolver = providers.getContextResolver(
JAXBContext.class, arg3);
try {
if (resolver != null) {
jaxbContext = resolver.getContext(arg0);
}
if (jaxbContext == null) {
jaxbContext = JAXBContext.newInstance(arg0);
}
type = (T) jaxbContext.createUnmarshaller().unmarshal(arg5);
validate(type);
} catch (JAXBException e) {
throw new WebApplicationException(
Response.Status.INTERNAL_SERVER_ERROR);
}
return type;
}
protected abstract void validate(T arg0) throws WebApplicationException;
}

    Remplacer la méthode de validation et d'annoter la sous-classe avec @Fournisseur et nous y sommes.