Tracciare richieste / risposte XML con JAX-WS

Esiste un modo semplice (ovvero: non utilizzare un proxy) per accedere all'XML di richiesta / risposta non elaborato per un servizio Web pubblicato con l'implementazione di riferimento JAX-WS (quella inclusa in JDK 1.5 e versioni successive)? Essere in grado di farlo tramite il codice è ciò che devo fare. Il solo fatto di averlo registrato su un file con configurazioni di registrazione intelligenti sarebbe bello ma sufficiente.

So che esistono altri framework più complessi e completi che potrebbero farlo, ma vorrei mantenerlo il più semplice possibile e assi, cxf, ecc. Aggiungono tutti un notevole sovraccarico che voglio evitare.

Grazie!

Le seguenti opzioni consentono la registrazione di tutte le comunicazioni alla console (tecnicamente, è necessaria solo una di queste, ma ciò dipende dalle librerie che si utilizzano, quindi l'impostazione di tutte e quattro è un'opzione più sicura). Puoi impostarlo nel codice come nell'esempio o come parametro della riga di comando usando -D o come variabile d'ambiente come ha scritto 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");

Vedere la domanda Traccia di richieste / risposte XML con JAX-WS quando si verificano errori per i dettagli.

Ecco la soluzione in codice raw (messa insieme grazie a stjohnroe e Shamik):

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

Dove si trova SOAPLoggingHandler (strappato da esempi collegati):

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);
        }
    }
}

Prima di avviare Tomcat, impostare JAVA_OPTScome sotto in Linux envs. Quindi avviare Tomcat. Vedrai la richiesta e la risposta nel catalina.outfile.

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

Impostare le seguenti proprietà di sistema, questo abiliterà la registrazione xml. Puoi impostarlo in java o nel file di configurazione.

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");
    }

registri della console:

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
--------------------------------------

Iniettare SOAPHandlernell'interfaccia dell'endpoint. possiamo tracciare la richiesta e la risposta SOAP

Implementazione di 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);

Dichiarativo aggiungendo @HandlerChain(file = "handlers.xml")annotazione all'interfaccia dell'endpoint.

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) {
    }

}

Esistono vari modi per farlo programmaticamente, come descritto nelle altre risposte, ma sono meccanismi piuttosto invasivi. Tuttavia, se sai che stai utilizzando JAX-WS RI (aka "Metro"), puoi farlo a livello di configurazione. Vedi qui per istruzioni su come farlo. Non c'è bisogno di scherzare con la tua applicazione.

// Questa soluzione fornisce un modo per aggiungere programmaticamente un gestore al client del servizio Web senza la configurazione XML

// Vedi il documento completo qui: http://docs.oracle.com/cd/E17904_01//web.1111/e13734/handlers.htm#i222476

// Crea una nuova classe che 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) {
}
}

// Aggiunge programmaticamente 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);

Sto pubblicando una nuova risposta, in quanto non ho abbastanza reputazione per commentare quella fornita da Antonio (vedi: https://stackoverflow.com/a/1957777 ).

Nel caso in cui desideri che il messaggio SOAP venga stampato in un file (ad es. Tramite Log4j), puoi utilizzare:

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());

In determinate circostanze, la chiamata al metodo writeTo () potrebbe non funzionare come previsto (consultare: https://community.oracle.com/thread/1123104?tstart=0 o https://www.java.net/node / 691073 ), quindi il codice seguente farà il trucco:

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());

È necessario implementare un javax.xml.ws.handler.LogicalHandler, questo gestore deve quindi essere referenziato in un file di configurazione del gestore, a sua volta referenziato da un'annotazione @HandlerChain nell'endpoint del servizio (interfaccia o implementazione). È quindi possibile emettere il messaggio tramite system.out o un logger nell'implementazione di processMessage.

Vedere

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

Le risposte elencate qui che ti guidano da usare SOAPHandlersono completamente corrette. Il vantaggio di questo approccio è che funzionerà con qualsiasi implementazione JAX-WS, poiché SOAPHandler fa parte delle specifiche JAX-WS. Tuttavia, il problema con SOAPHandler è che tenta implicitamente di rappresentare l'intero messaggio XML in memoria. Ciò può comportare un enorme utilizzo della memoria. Varie implementazioni di JAX-WS hanno aggiunto le proprie soluzioni alternative per questo. Se lavori con richieste di grandi dimensioni o risposte di grandi dimensioni, devi esaminare uno degli approcci proprietari.

Dato che chiedi "quello incluso in JDK 1.5 o superiore", risponderò rispetto a ciò che è formalmente noto come RI JAX-WS (aka Metro), che è incluso in JDK.

JAX-WS RI ha una soluzione specifica per questo che è molto efficiente in termini di utilizzo della memoria.

Vedi https://javaee.github.io/metro/doc/user-guide/ch02.html#efficient-handlers-in-jax-ws-ri . Sfortunatamente quel link ora è rotto ma lo puoi trovare su WayBack Machine. Darò i punti salienti di seguito:

La gente della Metro nel 2007 ha introdotto un ulteriore tipo di gestore MessageHandler<MessageHandlerContext>, che è proprietario di Metro. È molto più efficiente di SOAPHandler<SOAPMessageContext>come non tenta di eseguire la rappresentazione DOM in memoria.

Ecco il testo cruciale dell'articolo originale del blog:

messageHandler:

Utilizzando il framework estensibile del gestore fornito dalle specifiche JAX-WS e la migliore astrazione dei messaggi in RI, abbiamo introdotto un nuovo gestore chiamatoMessageHandler per estendere le applicazioni del servizio Web. MessageHandler è simile a SOAPHandler, tranne per il fatto che le sue implementazioni hanno accessoMessageHandlerContext(un'estensione di MessageContext). Tramite MessageHandlerContext è possibile accedere al Messaggio ed elaborarlo utilizzando l'API Message. Come ho inserito nel titolo del blog, questo gestore ti consente di lavorare su Message, che fornisce modi efficienti per accedere / elaborare il messaggio non solo un messaggio basato su DOM. Il modello di programmazione dei gestori è lo stesso e i gestori dei messaggi possono essere combinati con i gestori logici e SOAP standard. Ho aggiunto un esempio in JAX-WS RI 2.1.3 che mostra l'uso di MessageHandler per registrare i messaggi ed ecco un frammento dell'esempio:

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;
    }
}

(fine citazione dal post del blog 2007)

Inutile dire che il tuo gestore personalizzato, LoggingHandlernell'esempio, deve essere aggiunto alla catena del gestore per avere effetto. È come aggiungere qualsiasi altro Handler, quindi puoi cercare nelle altre risposte in questa pagina come farlo.

Puoi trovare un esempio completo nel repository Metro GitHub .

Potresti provare a mettere un ServletFilterdavanti al servizio web e ispezionare la richiesta e la risposta andando / restituito dal servizio.

Anche se in particolare non hai richiesto un proxy, a volte trovo che tcptrace sia sufficiente per vedere cosa succede su una connessione. È uno strumento semplice, senza installazione, mostra i flussi di dati e può anche scrivere su file.

In fase di esecuzione potresti semplicemente eseguire

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

come dump è una var pubblica definita nella classe come segue

public static boolean dump;

ho ragione nel capire che si desidera modificare / accedere al messaggio XML non elaborato?

In tal caso, tu (o dato che ha cinque anni, il prossimo) potresti voler dare un'occhiata all'interfaccia del provider che fa parte di JAXWS. La controparte del cliente viene eseguita utilizzando la classe "Dispatch". Ad ogni modo, non è necessario aggiungere gestori o intercettori. Puoi ancora, ovviamente. Il rovescio della medaglia è in questo modo, sei COMPLETAMENTE responsabile della creazione del messaggio SOAP, ma è facile, e se è quello che vuoi (come ho fatto io), questo è perfetto.

Ecco un esempio per il lato server (un po 'goffo, era solo per sperimentare) -

@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 pubblichi come faresti 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);
}
}

Oppure puoi usare una classe Endpoint per questo. Spero sia stato utile.

E oh, se vuoi, non devi occuparti di intestazioni e cose, se cambi la modalità di servizio in PAYLOAD (otterrai solo il Soap Body).

con i file di configurazione logback.xml, puoi fare:

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

Ciò registrerà la richiesta e la risposta in questo modo (a seconda della configurazione per l'output 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>--------------------

Avevo cercato di trovare una libreria di framework per registrare la richiesta e la risposta del sapone del servizio Web da un paio di giorni. Il codice seguente ha risolto il problema per me:

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");

Un modo di fare non è usare il tuo codice ma usare gli sniffer di pacchetti di rete come Etheral o WireShark che possono catturare il pacchetto HTTP con il messaggio XML come payload su di esso e puoi continuare a registrarli su un file o giù di lì.

Ma un approccio più sofisticato è quello di scrivere i tuoi gestori di messaggi. Puoi dare un'occhiata qui .

In realtà. Se cerchi le fonti di HttpClientTransport noterai che sta scrivendo anche messaggi in java.util.logging.Logger. Ciò significa che puoi anche vedere quei messaggi nei tuoi registri.

Ad esempio, se si utilizza Log4J2 tutto ciò che occorre fare è il seguente:

• aggiungi il bridge JUL-Log4J2 nel tuo percorso di classe
• imposta il livello TRACE per il pacchetto com.sun.xml.internal.ws.transport.http.client.
• aggiungi -Djava.util.logging.manager = org.apache.logging.log4j.jul.LogManager proprietà di sistema alla tua riga di comando di avvio dell'applicazione

Dopo questi passaggi inizi a vedere i messaggi SOAP nei tuoi registri.

Ci sono un paio di risposte usando SoapHandlers in questo thread. Dovresti sapere che SoapHandlers modifica il messaggio se writeTo(out)viene chiamato.

La chiamata al writeTo(out)metodo SOAPMessage chiama automaticamente saveChanges()anche il metodo. Di conseguenza, tutti i dati binari MTOM / XOP allegati in un messaggio vengono persi.

Non sono sicuro del perché questo accada, ma sembra essere una funzionalità documentata.

Inoltre, questo metodo segna il punto in cui i dati di tutti gli oggetti Component AttachmentPart vengono inseriti nel messaggio.

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

Se ti capita di eseguire un server di app IBM Liberty, aggiungi semplicemente ibm-ws-bnd.xml nella directory 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>