Seguimiento de solicitudes / respuestas XML con JAX-WS

¿Existe una manera fácil (también conocida como: no usar un proxy) para obtener acceso al XML de solicitud / respuesta sin procesar para un servicio web publicado con la implementación de referencia JAX-WS (la que se incluye en JDK 1.5 y superior)? Poder hacer eso a través del código es lo que necesito hacer. Solo tener que iniciar sesión en un archivo mediante configuraciones de registro inteligentes sería bueno pero suficiente.

Sé que existen otros marcos más complejos y completos que podrían hacer eso, pero me gustaría mantenerlo lo más simple posible y axis, cxf, etc., todos agregan una sobrecarga considerable que quiero evitar.

¡Gracias!

Las siguientes opciones permiten el registro de todas las comunicaciones a la consola (técnicamente, solo necesita una de estas, pero eso depende de las bibliotecas que utilice, por lo que configurar las cuatro es una opción más segura). Puede configurarlo en el código como en el ejemplo, o como parámetro de línea de comando usando -D o como variable de entorno como escribió Upendra.

System.setProperty("com.sun.xml.ws.transport.http.client.HttpTransportPipe.dump", "true");
System.setProperty("com.sun.xml.internal.ws.transport.http.client.HttpTransportPipe.dump", "true");
System.setProperty("com.sun.xml.ws.transport.http.HttpAdapter.dump", "true");
System.setProperty("com.sun.xml.internal.ws.transport.http.HttpAdapter.dump", "true");
System.setProperty("com.sun.xml.internal.ws.transport.http.HttpAdapter.dumpTreshold", "999999");

Consulte la pregunta Seguimiento de solicitudes / respuestas XML con JAX-WS cuando se produce un error para obtener más detalles.

Aquí está la solución en código sin formato (todo junto gracias a Stjohnroe y Shamik):

Endpoint ep = Endpoint.create(new WebserviceImpl());
List<Handler> handlerChain = ep.getBinding().getHandlerChain();
handlerChain.add(new SOAPLoggingHandler());
ep.getBinding().setHandlerChain(handlerChain);
ep.publish(publishURL);

Donde está SOAPLoggingHandler (extraído de ejemplos vinculados):

package com.myfirm.util.logging.ws;

import java.io.PrintStream;
import java.util.Map;
import java.util.Set;

import javax.xml.namespace.QName;
import javax.xml.soap.SOAPMessage;
import javax.xml.ws.handler.MessageContext;
import javax.xml.ws.handler.soap.SOAPHandler;
import javax.xml.ws.handler.soap.SOAPMessageContext;

/*
 * This simple SOAPHandler will output the contents of incoming
 * and outgoing messages.
 */
public class SOAPLoggingHandler implements SOAPHandler<SOAPMessageContext> {

    // change this to redirect output if desired
    private static PrintStream out = System.out;

    public Set<QName> getHeaders() {
        return null;
    }

    public boolean handleMessage(SOAPMessageContext smc) {
        logToSystemOut(smc);
        return true;
    }

    public boolean handleFault(SOAPMessageContext smc) {
        logToSystemOut(smc);
        return true;
    }

    // nothing to clean up
    public void close(MessageContext messageContext) {
    }

    /*
     * Check the MESSAGE_OUTBOUND_PROPERTY in the context
     * to see if this is an outgoing or incoming message.
     * Write a brief message to the print stream and
     * output the message. The writeTo() method can throw
     * SOAPException or IOException
     */
    private void logToSystemOut(SOAPMessageContext smc) {
        Boolean outboundProperty = (Boolean)
            smc.get (MessageContext.MESSAGE_OUTBOUND_PROPERTY);

        if (outboundProperty.booleanValue()) {
            out.println("\nOutbound message:");
        } else {
            out.println("\nInbound message:");
        }

        SOAPMessage message = smc.getMessage();
        try {
            message.writeTo(out);
            out.println("");   // just to add a newline
        } catch (Exception e) {
            out.println("Exception in handler: " + e);
        }
    }
}

Antes de iniciar tomcat, JAVA_OPTSconfigúrelo a continuación en envs de Linux. Entonces comienza Tomcat. Verá la solicitud y la respuesta en el catalina.outarchivo.

export JAVA_OPTS="$JAVA_OPTS -Dcom.sun.xml.ws.transport.http.client.HttpTransportPipe.dump=true"

Establezca las siguientes propiedades del sistema, esto habilitará el registro xml. Puede configurarlo en java o en el archivo de configuración.

static{
        System.setProperty("com.sun.xml.ws.transport.http.client.HttpTransportPipe.dump", "true");
        System.setProperty("com.sun.xml.ws.transport.http.HttpAdapter.dump", "true");
        System.setProperty("com.sun.xml.internal.ws.transport.http.client.HttpTransportPipe.dump", "true");
        System.setProperty("com.sun.xml.internal.ws.transport.http.HttpAdapter.dump", "true");
        System.setProperty("com.sun.xml.internal.ws.transport.http.HttpAdapter.dumpTreshold", "999999");
    }

registros de la consola:

INFO: Outbound Message
---------------------------
ID: 1
Address: http://localhost:7001/arm-war/castService
Encoding: UTF-8
Http-Method: POST
Content-Type: text/xml
Headers: {Accept=[*/*], SOAPAction=[""]}
Payload: xml
--------------------------------------
INFO: Inbound Message
----------------------------
ID: 1
Response-Code: 200
Encoding: UTF-8
Content-Type: text/xml; charset=UTF-8
Headers: {content-type=[text/xml; charset=UTF-8], Date=[Fri, 20 Jan 2017 11:30:48 GMT], transfer-encoding=[chunked]}
Payload: xml
--------------------------------------

Inyectar SOAPHandler a la interfaz de punto final. podemos rastrear la solicitud y respuesta SOAP

Implementando SOAPHandler con Programmatic

ServerImplService service = new ServerImplService();
Server port = imgService.getServerImplPort();
/**********for tracing xml inbound and outbound******************************/
Binding binding = ((BindingProvider)port).getBinding();
List<Handler> handlerChain = binding.getHandlerChain();
handlerChain.add(new SOAPLoggingHandler());
binding.setHandlerChain(handlerChain);

Declarativo agregando@HandlerChain(file = "handlers.xml") anotaciones a su interfaz de punto final.

handlers.xml

<?xml version="1.0" encoding="UTF-8"?>
<handler-chains xmlns="http://java.sun.com/xml/ns/javaee">
    <handler-chain>
        <handler>
            <handler-class>SOAPLoggingHandler</handler-class>
        </handler>
    </handler-chain>
</handler-chains>

SOAPLoggingHandler.java

/*
 * This simple SOAPHandler will output the contents of incoming
 * and outgoing messages.
 */


public class SOAPLoggingHandler implements SOAPHandler<SOAPMessageContext> {
    public Set<QName> getHeaders() {
        return null;
    }

    public boolean handleMessage(SOAPMessageContext context) {
        Boolean isRequest = (Boolean) context.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);
        if (isRequest) {
            System.out.println("is Request");
        } else {
            System.out.println("is Response");
        }
        SOAPMessage message = context.getMessage();
        try {
            SOAPEnvelope envelope = message.getSOAPPart().getEnvelope();
            SOAPHeader header = envelope.getHeader();
            message.writeTo(System.out);
        } catch (SOAPException | IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return true;
    }

    public boolean handleFault(SOAPMessageContext smc) {
        return true;
    }

    // nothing to clean up
    public void close(MessageContext messageContext) {
    }

}

Hay varias formas de hacer esto mediante programación, como se describe en las otras respuestas, pero son mecanismos bastante invasivos. Sin embargo, si sabe que está utilizando JAX-WS RI (también conocido como "Metro"), puede hacerlo en el nivel de configuración. Consulte aquí para obtener instrucciones sobre cómo hacer esto. No hay necesidad de meterse con su aplicación.

// Esta solución proporciona una manera programática de agregar un controlador al cliente del servicio web sin la configuración XML

// Ver documento completo aquí: http://docs.oracle.com/cd/E17904_01//web.1111/e13734/handlers.htm#i222476

// Crea una nueva clase que implementa SOAPHandler

public class LogMessageHandler implements SOAPHandler<SOAPMessageContext> {

@Override
public Set<QName> getHeaders() {
    return Collections.EMPTY_SET;
}

@Override
public boolean handleMessage(SOAPMessageContext context) {
    SOAPMessage msg = context.getMessage(); //Line 1
    try {
        msg.writeTo(System.out);  //Line 3
    } catch (Exception ex) {
        Logger.getLogger(LogMessageHandler.class.getName()).log(Level.SEVERE, null, ex);
    } 
    return true;
}

@Override
public boolean handleFault(SOAPMessageContext context) {
    return true;
}

@Override
public void close(MessageContext context) {
}
}

// Agregue de forma programática su LogMessageHandler

   com.csd.Service service = null;
    URL url = new URL("https://service.demo.com/ResService.svc?wsdl");

    service = new com.csd.Service(url);

    com.csd.IService port = service.getBasicHttpBindingIService();
    BindingProvider bindingProvider = (BindingProvider)port;
    Binding binding = bindingProvider.getBinding();
    List<Handler> handlerChain = binding.getHandlerChain();
    handlerChain.add(new LogMessageHandler());
    binding.setHandlerChain(handlerChain);

Estoy publicando una nueva respuesta, ya que no tengo suficiente reputación para comentar sobre la proporcionada por Antonio (ver: https://stackoverflow.com/a/1957777 ).

En caso de que desee que el mensaje SOAP se imprima en un archivo (por ejemplo, a través de Log4j), puede usar:

OutputStream os = new ByteArrayOutputStream();
javax.xml.soap.SOAPMessage soapMsg = context.getMessage();
soapMsg.writeTo(os);
Logger LOG = Logger.getLogger(SOAPLoggingHandler.class); // Assuming SOAPLoggingHandler is the class name
LOG.info(os.toString());

Tenga en cuenta que, en determinadas circunstancias, la llamada al método writeTo () puede no funcionar como se espera (consulte: https://community.oracle.com/thread/1123104?tstart=0 o https://www.java.net/node / 691073 ), por lo tanto, el siguiente código hará el truco:

javax.xml.soap.SOAPMessage soapMsg = context.getMessage();
com.sun.xml.ws.api.message.Message msg = new com.sun.xml.ws.message.saaj.SAAJMessage(soapMsg);
com.sun.xml.ws.api.message.Packet packet = new com.sun.xml.ws.api.message.Packet(msg);
Logger LOG = Logger.getLogger(SOAPLoggingHandler.class); // Assuming SOAPLoggingHandler is the class name
LOG.info(packet.toString());

Debe implementar un javax.xml.ws.handler.LogicalHandler, este controlador debe estar referenciado en un archivo de configuración del controlador, que a su vez está referenciado por una anotación @HandlerChain en su punto final de servicio (interfaz o implementación). Luego puede enviar el mensaje a través de system.out o un registrador en su implementación de processMessage.

Ver

http://publib.boulder.ibm.com/infocenter/wasinfo/v7r0/index.jsp?topic=/com.ibm.websphere.express.doc/info/exp/ae/twbs_jaxwshandler.html

http://java.sun.com/mailers/techtips/enterprise/2006/TechTips_June06.html

Las respuestas enumeradas aquí que lo guían para usar SOAPHandler son completamente correctas. El beneficio de ese enfoque es que funcionará con cualquier implementación JAX-WS, ya que SOAPHandler es parte de la especificación JAX-WS. Sin embargo, el problema con SOAPHandler es que intenta implícitamente representar todo el mensaje XML en la memoria. Esto puede conducir a un gran uso de memoria. Varias implementaciones de JAX-WS han agregado sus propias soluciones para esto. Si trabaja con solicitudes grandes o respuestas grandes, entonces debe buscar uno de los enfoques propietarios.

Dado que usted pregunta sobre "el incluido en JDK 1.5 o superior", responderé con respecto a lo que se conoce formalmente como JAX-WS RI (también conocido como Metro), que es lo que se incluye con el JDK.

JAX-WS RI tiene una solución específica para esto que es muy eficiente en términos de uso de memoria.

Ver https://javaee.github.io/metro/doc/user-guide/ch02.html#efficient-handlers-in-jax-ws-ri . Desafortunadamente, ese enlace ahora está roto, pero puedes encontrarlo en WayBack Machine. Daré los aspectos más destacados a continuación:

La gente de Metro en 2007 introdujo un tipo de controlador adicional MessageHandler<MessageHandlerContext>, que es propiedad de Metro. Es mucho más eficiente que SOAPHandler<SOAPMessageContext>ya que no intenta hacer una representación DOM en memoria.

Aquí está el texto crucial del artículo original del blog:

MessageHandler:

Utilizando el marco de controlador extensible proporcionado por la especificación JAX-WS y la mejor abstracción de mensajes en RI, presentamos un nuevo controlador llamadoMessageHandler para extender sus aplicaciones de servicio web. MessageHandler es similar a SOAPHandler, excepto que sus implementaciones tienen acceso aMessageHandlerContext(una extensión de MessageContext). A través de MessageHandlerContext se puede acceder al Mensaje y procesarlo usando la API de mensajes. Como puse en el título del blog, este controlador le permite trabajar en Message, que proporciona formas eficientes de acceder / procesar el mensaje, no solo un mensaje basado en DOM. El modelo de programación de los manejadores es el mismo y los manejadores de mensajes se pueden mezclar con manejadores lógicos y SOAP estándar. He agregado una muestra en JAX-WS RI 2.1.3 que muestra el uso de MessageHandler para registrar mensajes y aquí hay un fragmento de la muestra:

public class LoggingHandler implements MessageHandler<MessageHandlerContext> {
    public boolean handleMessage(MessageHandlerContext mhc) {
        Message m = mhc.getMessage().copy();
        XMLStreamWriter writer = XMLStreamWriterFactory.create(System.out);
        try {
            m.writeTo(writer);
        } catch (XMLStreamException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    public boolean handleFault(MessageHandlerContext mhc) {
        ..... 
        return true;
    }

    public void close(MessageContext messageContext) {    }

    public Set getHeaders() {
        return null;
    }
}

(Cita final de la publicación del blog de 2007)

No hace falta decir que su controlador personalizado, LoggingHandleren el ejemplo, debe agregarse a su cadena de controlador para tener algún efecto. Esto es lo mismo que agregar cualquier otro Handler, por lo que puede buscar en las otras respuestas en esta página cómo hacerlo.

Puede encontrar un ejemplo completo en el repositorio de Metro GitHub .

Podrías intentar poner un ServletFilterfrente al servicio web e inspeccionar la solicitud y la respuesta al servicio devuelto / devuelto.

Aunque específicamente no solicitó un proxy, a veces encuentro que tcptrace es suficiente para ver qué sucede en una conexión. Es una herramienta simple, sin instalación, muestra los flujos de datos y también puede escribir en el archivo.

En tiempo de ejecución , simplemente podría ejecutar

com.sun.xml.internal.ws.transport.http.client.HttpTransportPipe.dump = true

como dump es una var pública definida en la clase de la siguiente manera

public static boolean dump;

¿Estoy en lo cierto al entender que desea cambiar / acceder al mensaje XML sin procesar?

Si es así, usted (o dado que tiene cinco años, el próximo tipo) podría querer echar un vistazo a la interfaz del proveedor que forma parte de JAXWS. La contraparte del cliente se realiza utilizando la clase "Despacho". De todos modos, no tiene que agregar controladores o interceptores. Aún PUEDES, por supuesto. La desventaja es de esta manera, usted es COMPLETAMENTE responsable de construir el SOAPMessage, pero es fácil, y si eso es lo que quiere (como yo hice), esto es perfecto.

Aquí hay un ejemplo para el lado del servidor (poco torpe, fue solo para experimentar):

@WebServiceProvider(portName="Provider1Port",serviceName="Provider1",targetNamespace = "http://localhost:8123/SoapContext/SoapPort1")
@ServiceMode(value=Service.Mode.MESSAGE)
public class Provider1 implements Provider<SOAPMessage>
{
  public Provider1()
  {
  }

  public SOAPMessage invoke(SOAPMessage request)
  { try{


        File log= new File("/home/aneeshb/practiceinapachecxf/log.txt");//creates file object
        FileWriter fw=new FileWriter(log);//creates filewriter and actually creates file on disk

            fw.write("Provider has been invoked");
            fw.write("This is the request"+request.getSOAPBody().getTextContent());

      MessageFactory mf = MessageFactory.newInstance();
      SOAPFactory sf = SOAPFactory.newInstance();

      SOAPMessage response = mf.createMessage();
      SOAPBody respBody = response.getSOAPBody();
      Name bodyName = sf.createName("Provider1Insertedmainbody");
      respBody.addBodyElement(bodyName);
      SOAPElement respContent = respBody.addChildElement("provider1");
      respContent.setValue("123.00");
      response.saveChanges();
      fw.write("This is the response"+response.getSOAPBody().getTextContent());
      fw.close();
      return response;}catch(Exception e){return request;}


   }
}

Lo publicas como lo harías con un SEI,

public class ServerJSFB {

    protected ServerJSFB() throws Exception {
        System.out.println("Starting Server");
        System.out.println("Starting SoapService1");

        Object implementor = new Provider1();//create implementor
        String address = "http://localhost:8123/SoapContext/SoapPort1";

        JaxWsServerFactoryBean svrFactory = new JaxWsServerFactoryBean();//create serverfactorybean

        svrFactory.setAddress(address);
        svrFactory.setServiceBean(implementor);

        svrFactory.create();//create the server. equivalent to publishing the endpoint
        System.out.println("Starting SoapService1");
  }

public static void main(String args[]) throws Exception {
    new ServerJSFB();
    System.out.println("Server ready...");

    Thread.sleep(10 * 60 * 1000);
    System.out.println("Server exiting");
    System.exit(0);
}
}

O puede usar una clase Endpoint para ello. Espero que haya sido útil.

Y, si lo desea, no necesita ocuparse de los encabezados y demás, si cambia el modo de servicio a PAYLOAD (solo obtendrá el cuerpo del jabón).

con los archivos de configuración logback.xml, puede hacer:

<logger name="com.sun.xml.internal.ws.transport.http.client.HttpTransportPipe" level="trace" additivity="false">
    <appender-ref ref="STDOUT"/>
</logger>

Eso registrará la solicitud y la respuesta de esta manera (dependiendo de su configuración para la salida del registro):

09:50:23.266 [qtp1068445309-21] DEBUG c.s.x.i.w.t.h.c.HttpTransportPipe - ---[HTTP request - http://xyz:8081/xyz.svc]---
Accept: application/soap+xml, multipart/related
Content-Type: application/soap+xml; charset=utf-8;action="http://xyz.Web.Services/IServiceBase/GetAccessTicket"
User-Agent: JAX-WS RI 2.2.9-b130926.1035 svn-revision#5f6196f2b90e9460065a4c2f4e30e065b245e51e
<?xml version="1.0" ?><S:Envelope xmlns:S="http://www.w3.org/2003/05/soap-envelope">[CONTENT REMOVED]</S:Envelope>--------------------

09:50:23.312 [qtp1068445309-21] DEBUG c.s.x.i.w.t.h.c.HttpTransportPipe - ---[HTTP response - http://xyz:8081/xyz.svc - 200]---
null: HTTP/1.1 200 OK
Content-Length: 792
Content-Type: application/soap+xml; charset=utf-8
Date: Tue, 12 Feb 2019 14:50:23 GMT
Server: Microsoft-IIS/10.0
X-Powered-By: ASP.NET
<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://www.w3.org/2005/08/addressing">[CONTENT REMOVED]</s:Envelope>--------------------

Había estado tratando de encontrar alguna biblioteca de marco para registrar la solicitud y respuesta del servicio web durante un par de días. El siguiente código solucionó el problema para mí:

System.setProperty("com.sun.xml.ws.transport.http.client.HttpTransportPipe.dump", "true");
        System.setProperty("com.sun.xml.ws.transport.http.HttpAdapter.dump", "true");
        System.setProperty("com.sun.xml.internal.ws.transport.http.client.HttpTransportPipe.dump", "true");
        System.setProperty("com.sun.xml.internal.ws.transport.http.HttpAdapter.dump", "true");

Una forma de hacerlo es no usar su código, sino usar rastreadores de paquetes de red como Etheral o WireShark, que pueden capturar el paquete HTTP con el mensaje XML como carga útil y puede seguir registrándolos en un archivo más o menos.

Pero el enfoque más sofisticado es escribir sus propios manejadores de mensajes. Puedes echarle un vistazo aquí .

Realmente. Si observa las fuentes de HttpClientTransport, notará que también está escribiendo mensajes en java.util.logging.Logger. Lo que significa que también puede ver esos mensajes en sus registros.

Por ejemplo, si está utilizando Log4J2, todo lo que necesita hacer es lo siguiente:

• agregue el puente JUL-Log4J2 en su ruta de clase
• establezca el nivel TRACE para el paquete com.sun.xml.internal.ws.transport.http.client.
• agregue -Djava.util.logging.manager = org.apache.logging.log4j.jul.LogManager propiedad del sistema a la línea de comando de inicio de su aplicación

Después de estos pasos, comenzará a ver mensajes SOAP en sus registros.

Hay un par de respuestas usando SoapHandlers en este hilo. Debe saber que SoapHandlers modifica el mensaje si writeTo(out)se llama.

Llamar al writeTo(out)método SOAPMessage saveChanges()también llama automáticamente al método. Como resultado, se pierden todos los datos binarios MTOM / XOP adjuntos en un mensaje.

No estoy seguro de por qué sucede esto, pero parece ser una característica documentada.

Además, este método marca el punto en el que los datos de todos los objetos AttachmentPart constituyentes se introducen en el mensaje.

https://docs.oracle.com/javase/7/docs/api/javax/xml/soap/SOAPMessage.html#saveChanges ()

Si ejecuta un servidor de aplicaciones IBM Liberty, simplemente agregue ibm-ws-bnd.xml en el directorio WEB-INF.

<?xml version="1.0" encoding="UTF-8"?>
<webservices-bnd
    xmlns="http://websphere.ibm.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://websphere.ibm.com/xml/ns/javaee http://websphere.ibm.com/xml/ns/javaee/ibm-ws-bnd_1_0.xsd"
    version="1.0">
    <webservice-endpoint-properties
        enableLoggingInOutInterceptor="true" />
</webservices-bnd>