Sprawdzanie poprawności żądania JAX-WS przy użyciu JAXB

Question

W JAX-WS, aby sprawdzić żądanie przychodzące, jednym ze sposobów jest użycie @SchemaValidation zgodnie z sugestią pod poniższym linkiem.

JAX-WS and XSD Validation

Jednak serwer aplikacji (WAS 7) Używam jeszcze nie obsługują @SchemaValidation. (Proszę poprawić mnie, jeśli WAS 7 obsługuje tę adnotację)

Tak więc patrzę na inne opcje, takie jak implementowanie programu obsługi w celu sprawdzenia przychodzącego żądania. Zarówno w klasie obsługi, jak i klasie punktu końcowego, mogę utworzyć JAXBContext i użyć walidatora JAXB. Czy muszę utworzyć jawnie JAXBContext lub czy jest on dostępny jako zasób/adnotacja, ponieważ JAX-WS wewnętrznie używa JAXB? Czy to dobry sposób na wdrożenie sprawdzania poprawności w JAX-WS? (W przypadku braku sprawdzania poprawności @SchemaValidation)

Czy standardową praktyką jest weryfikowanie przychodzącego xml żądania w serwisach WWW, czy jest on pomijany z powodu działania, które może spowodować?

Answer 1

Dobrą praktyką jest sprawdzenie przychodzącego żądania xml, jak ma to miejsce w każdym systemie MVC. (MVC może nie pasować tutaj, ale w zasadzie tak samo, jak widok jest XML). Jeśli wspomniana adnotacja (@SchemaValidation) nie jest obsługiwana, wówczas jednym sposobem jest użycie programu obsługi, który sprawdzi żądanie przychodzące za pomocą JAXB Validation.

Answer 2

Lepszą praktyką, jeśli jesteś DUŻĄ organizacją, jest używanie DataPower. Przeprowadzi on walidacje dla Ciebie wraz z wieloma funkcjami. Jeśli chodzi o najlepszą praktykę, proponuję DataPower tylko dlatego, że został do tego zaprojektowany, ale musisz się upewnić, że stworzysz kod, który może sprawdzić poprawność, w przeciwnym razie trafisz na problemy sprawdzania poprawności w środowisku wykonawczym.

Również NIE polecam używania @SchemaValidation, ponieważ jest to specyficzne dla dostawcy, a nie standardowe.

Powiedziawszy to, napisałem, co następuje, kiedy bawiłem się przechwytywaczami dla mojej referencyjnej aplikacji Java EE, która nie używa żadnych API specyficznych dla danego dostawcy.

/** 
* Validates the XML streams going in the request and response if the log level 
* is {@link Level#FINER} or below against {@value #LOGGER_NAME}. If 
* {@link Level#FINEST} is used it will also dump the XML that were sent. 
* 
* @author Archimedes Trajano 
* 
*/ 
public class XmlValidationInterceptor { 
    /** 
    * Logger. 
    */ 
    private static final Logger LOG; 

    /** 
    * Name of the logger. 
    */ 
    public static final String LOGGER_NAME = "xml.validation"; //$NON-NLS-1$ 

    static { 
     LOG = Logger.getLogger(LOGGER_NAME, "Messages"); //$NON-NLS-1$ 
    } 

    /** 
    * Contains a composite of multiple schema files into one schema that used 
    * on all message validations. 
    */ 
    private final Schema schema; 

    /** 
    * Loads up the schema into memory. This uses the default 
    * 
    * @throws SAXException 
    *    problem parsing the schema files. 
    */ 
    public XmlValidationInterceptor() throws SAXException { 
     final SchemaFactory sf = SchemaFactory 
       .newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI); 
     schema = sf.newSchema(); 
    } 

    /** 
    * Loads up the schema from the specified array of {@link Source} into 
    * memory. 
    * 
    * @param schemaSources 
    *   schema sources. 
    * @throws SAXException 
    *    problem parsing the schema files. 
    */ 
    public XmlValidationInterceptor(final Source... schemaSources) 
      throws SAXException { 
     final SchemaFactory sf = SchemaFactory 
       .newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI); 
     schema = sf.newSchema(schemaSources); 
    } 

    /** 
    * Writes the object as XML to the logger. 
    * 
    * @param param 
    *   object to marshal 
    * @param context 
    *   invocation context used for logging. 
    * @throws JAXBException 
    *    problem with the Java binding except schema issues because 
    *    schema validation errors are caught and processed 
    *    differently. 
    */ 
    private void marshalObject(final Object param, 
      final InvocationContext context) throws JAXBException { 
     if (!param.getClass().isAnnotationPresent(XmlRootElement.class)) { 
      return; 
     } 

     // validate against known schemas 
     final JAXBContext jaxbContext = JAXBContext.newInstance(param 
       .getClass()); 
     final Marshaller m = jaxbContext.createMarshaller(); 
     m.setSchema(schema); 
     m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); 
     try { 
      final StringWriter w = new StringWriter(); 
      m.marshal(param, w); 
      LOG.finest(w.toString()); 
     } catch (final MarshalException e) { 
      if (!(e.getLinkedException() instanceof SAXParseException)) { 
       throw e; 
      } 
      final SAXParseException parseException = (SAXParseException) e 
        .getLinkedException(); 
      LOG.log(Level.SEVERE, 
        "XmlValidationInterceptor.parseException", // $NON-NLS-1$ 
        new Object[] { context.getMethod(), param, 
          parseException.getMessage() }); 
      m.setSchema(null); 
      final StringWriter w = new StringWriter(); 
      m.marshal(param, w); 
      LOG.finest(w.toString()); 
     } 
    } 

    /** 
    * Validates the data in the parameters and return values. 
    * 
    * @param context 
    *   invocation context 
    * @return invocation return value 
    * @throws Exception 
    *    invocation exception 
    */ 
    @AroundInvoke 
    public Object validate(final InvocationContext context) throws Exception { 
     if (!LOG.isLoggable(Level.FINER)) { 
      return context.proceed(); 
     } 

     final Object[] params = context.getParameters(); 
     for (final Object param : params) { 
      marshalObject(param, context); 
     } 

     final Object ret = context.proceed(); 
     if (ret != null) { 
      marshalObject(ret, context); 
     } 
     return ret; 
    } 

}