Modify response of web service with JAX-WS

Question

How can I modify the namespace of the response like this:

old response:

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
   <soap:Body>
      <ns2:GetAmountResponse xmlns:ns2="http://ws.dsi.otn.com/dab">
         <etat>0</etat>
         <montant>500.0</montant>
      </ns2:GetAmountResponse>
   </soap:Body>
</soap:Envelope>

new response wanted :

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
   <soap:Body>
      <GetAmountResponse xmlns="http://ws.dsi.otn.com/dab">
         <etat>0</etat>
         <montant>500.0</montant>
      </GetAmountResponse>
   </soap:Body>
</soap:Envelope>

I want to remove the ns2 namespce prefix.

Answer 1

This is a very old question, still it is yet to be effectively answered. This week I faced a very similar problem. My application is invoking a Soap web-service provided by a legacy system whose XML is response syntactically wrong with some empty characters (line break, or tabs or white spaces) before XML declaration. In my scenario I could not change the legacy system to fix its response so changing the response before parsing was the only alternative I was left with.

Here is my solution:

I have added the following maven dependencies to my application:

<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.0</version>
</dependency>

<dependency>
    <groupId>javax.xml.ws</groupId>
    <artifactId>jaxws-api</artifactId>
    <version>2.3.0</version>
</dependency>

<dependency>
    <groupId>com.sun.xml.ws</groupId>
    <artifactId>jaxws-rt</artifactId>
    <version>2.3.0</version>
</dependency>

Then I have registered a Java SPI custom implementation of “com.oracle.webservices.impl.internalspi.encoding.StreamDecoder”. This class is invoked immediately before the XML parse with the corresponding response InputStream, so at this point you can read the response InputStream or wrap/proxy it and make any change to jax-ws response before parsing. In my case I just remove some invisible characters before first visible character.

My StreamDecoder SPI implementation:

package sample.streamdecoder;


import com.oracle.webservices.impl.encoding.StreamDecoderImpl;
import com.oracle.webservices.impl.internalspi.encoding.StreamDecoder;
import com.sun.xml.ws.api.SOAPVersion;
import com.sun.xml.ws.api.message.AttachmentSet;
import com.sun.xml.ws.api.message.Message;

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;

public class MyStreamDecoder implements StreamDecoder {

    //JAX-WS default implementation
    private static final StreamDecoderImpl streamDecoder = new StreamDecoderImpl();


    @Override
    public Message decode(InputStream inputStream, String charset, AttachmentSet attachmentSet, SOAPVersion soapVersion) throws IOException {
        //Wrapping inputStream
        InputStream wrapped = wrapInputStreamStrippingBlankCharactersBeforeXML(inputStream, charset);
        //Delegating further processing to default StreamDecoder
        return streamDecoder.decode(wrapped, charset, attachmentSet, soapVersion);
    }
    
    private InputStream wrapInputStreamStrippingBlankCharactersBeforeXML(InputStream inputStream, String charset) throws IOException {
        int WHITESPACE = (int) Charset.forName(charset).encode(" ").get();
        int LINE_BREAK = (int) Charset.forName(charset).encode("\n").get();
        int TAB        = (int) Charset.forName(charset).encode("\t").get();
        return new InputStream() {
            private boolean xmlBegin = true;

            @Override
            public int read() throws IOException {
                int read = inputStream.read();
                if (!xmlBegin) {
                    return read;
                } else {
                    while (WHITESPACE == read
                            || LINE_BREAK == read
                            || TAB == read) {
                        read = inputStream.read();
                    }
                    xmlBegin = false;
                }
                return read;
            }
        };
    }

}

In order to register it, just create a file “META-INF/services/ com.oracle.webservices.impl.internalspi.encoding.StreamDecoder” named “” and write the fully qualified name of your SPI implementation on the first line like that:

Content of file META-INF/services/ com.oracle.webservices.impl.internalspi.encoding.StreamDecoder :

sample.streamdecoder.MyStreamDecoder

Now every response will be passed to you implementation before parse.

Answer 2

logical handler are enough to transform to the message as expected :

package com.ouertani.slim;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.ws.LogicalMessage;
import javax.xml.ws.handler.LogicalHandler;
import javax.xml.ws.handler.LogicalMessageContext;
import javax.xml.ws.handler.MessageContext;

/**
 *
 * @author ouertani
 */
public class MyLogicalHandler implements LogicalHandler<LogicalMessageContext> {

    @Override
    public boolean handleMessage(LogicalMessageContext messageContext) {
        /// extract state and amount
        int state = 0;
        double amount = 200.0;
        transform(messageContext, state, amount);
        return false;
    }

    public boolean handleFault(LogicalMessageContext messageContext) {
        return true;
    }

    public void close(MessageContext context) {
    }
    private void transform( LogicalMessageContext messageContext, int etat, double montant){
            LogicalMessage msg = messageContext.getMessage();

        String htom = "<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">"+
   "<soap:Body>"+
      "<GetAmountResponse xmlns=\"http://ws.dsi.otn.com/dab\">"+
         "<etat>"+etat+"</etat>"+
         "<montant>"+montant+"</montant>"+
      "</GetAmountResponse>"+
   "</soap:Body>"+
"</soap:Envelope>";
        InputStream is = new ByteArrayInputStream(htom.getBytes());
        Source ht = new StreamSource(is);
        msg.setPayload(ht);
    }
}

Answer 3

In the first case, the GetAmountResponse is in namespace http://ws.dsi.otn.com/dab while etat and montant are in a default (empty) namespace.

In the new message you want, GetAmountResponse, etat and montant are all in namespace http://ws.dsi.otn.com/dab.

The namespaces can be controlled from the namespaces of your classes. Use the same namespace in all and you will have them in the same namespace, leave classes with defaults and they default to empty namespace.

For example, if you were to have something like this in your web service class:

@WebMethod
    public 
    @WebResult(name = "getAmountResponse", targetNamespace = "http://ws.dsi.otn.com/dab")
    AmountResponse getAmount(
            @WebParam(name = "getAmountRequest", targetNamespace = "http://ws.dsi.otn.com/dab") AmountRequest request) {

        AmountResponse response = new AmountResponse();
        response.setEtat(0);
        response.setMontant(500.0);

        return response;
    }

with a response class like this:

@XmlRootElement
public class AmountResponse {
    private int etat;
    private double montant;
    // getter and setters omitted
}

you will end up with the first type of soap message.

But if you change the response class to look like this instead:

@XmlRootElement(namespace = "http://ws.dsi.otn.com/dab")
@XmlAccessorType(XmlAccessType.NONE)
public class AmountResponse {

    @XmlElement(namespace = "http://ws.dsi.otn.com/dab")
    private int etat;

    @XmlElement(namespace = "http://ws.dsi.otn.com/dab")
    private double montant;

    // getters and setter omitted
}

you will bring all tags in the same namespace and you get something equivalent to the new type of message you want. I said equivalent because I don't think you will get exactly this:

<GetAmountResponse xmlns="http://ws.dsi.otn.com/dab">
     <etat>0</etat>
     <montant>500.0</montant>
</GetAmountResponse>

It's more likely to get something like this instead:

<ns2:getAmountResponse xmlns:ns2="http://ws.dsi.otn.com/dab">
     <ns2:etat>0</ns2:etat>
     <ns2:montant>500.0</ns2:montant>
</ns2:getAmountResponse>

It's the same "XML meaning" for both messages although they don't look the same.

If you absolutely want it to look like that, I think you will have to go "low level" and use something like a SOAP handler to intercept the response and modify it. But be aware that it won't be a trivial task to change the message before it goes on the wire.