Rastreando Solicitações / Respostas XML com JAX-WS

Existe uma maneira fácil (também conhecida como: não usar um proxy) para obter acesso ao XML de solicitação / resposta bruta de um serviço da web publicado com a implementação de referência JAX-WS (a incluída no JDK 1.5 e melhor)? Ser capaz de fazer isso via código é o que eu preciso fazer. Apenas registrá-lo em um arquivo com configurações inteligentes de log seria bom, mas suficiente.

Eu sei que existem outras estruturas mais complexas e completas que podem fazer isso, mas eu gostaria de mantê-lo o mais simples possível e o eixo, o cxf, etc, acrescentam uma sobrecarga considerável que eu quero evitar.

Obrigado!

As opções a seguir habilitam o log de todas as comunicações no console (tecnicamente, você só precisa de uma delas, mas isso depende das bibliotecas usadas, portanto, a configuração das quatro é a opção mais segura). Você pode configurá-lo no código como no exemplo, ou como parâmetro de linha de comando usando -D ou como variável de ambiente, como Upendra escreveu.

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 a pergunta Rastreando Solicitações / Respostas XML com JAX-WS quando ocorrer um erro para obter detalhes.

Aqui está a solução no código bruto (reunido graças 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);

Onde está SOAPLoggingHandler (extraído de exemplos 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 o tomcat, defina JAVA_OPTScomo abaixo nos envs do Linux. Então inicie o Tomcat. Você verá a solicitação e a resposta no catalina.outarquivo.

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

Defina as seguintes propriedades do sistema, isso habilitará o log xml. Você pode configurá-lo em java ou arquivo de configuração.

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

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

Injetar SOAPHandlerna interface do nó de extremidade. podemos rastrear a solicitação e resposta SOAP

Implementando SOAPHandler com 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 incluindo @HandlerChain(file = "handlers.xml")anotação em sua interface do terminal.

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

}

Existem várias maneiras de fazer isso programaticamente, conforme descrito nas outras respostas, mas são mecanismos bastante invasivos. No entanto, se você souber que está usando o JAX-WS RI (também conhecido como "Metro"), poderá fazer isso no nível de configuração. Veja aqui para obter instruções sobre como fazer isso. Não há necessidade de mexer com seu aplicativo.

// Esta solução fornece uma maneira de adicionar programaticamente um manipulador ao cliente de serviços da Web sem a configuração XML

// Consulte o documento completo aqui: http://docs.oracle.com/cd/E17904_01//web.1111/e13734/handlers.htm#i222476

// Crie uma nova classe 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) {
}
}

// Adicione programaticamente seu 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);

Estou postando uma nova resposta, pois não tenho reputação suficiente para comentar a fornecida por Antonio (consulte: https://stackoverflow.com/a/1957777 ).

Caso deseje que a mensagem SOAP seja impressa em um arquivo (por exemplo, via Log4j), você pode 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());

Observe que, em determinadas circunstâncias, a chamada de método writeTo () pode não se comportar conforme o esperado (consulte: https://community.oracle.com/thread/1123104?tstart=0 ou https://www.java.net/node / 691073 ), portanto, o seguinte código fará o truque:

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

Você precisa implementar um javax.xml.ws.handler.LogicalHandler, esse manipulador precisa ser referenciado em um arquivo de configuração do manipulador, que por sua vez é referenciado por uma anotação @HandlerChain no terminal de serviço (interface ou implementação). Em seguida, você pode enviar a mensagem por system.out ou por um criador de logs em sua implementação processMessage.

Vejo

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

As respostas listadas aqui que o orientam a usar SOAPHandlerestão totalmente corretas. O benefício dessa abordagem é que ela funcionará com qualquer implementação JAX-WS, pois SOAPHandler faz parte da especificação JAX-WS. No entanto, o problema com o SOAPHandler é que ele tenta implicitamente representar a mensagem XML inteira na memória. Isso pode levar a um enorme uso de memória. Várias implementações do JAX-WS incluíram suas próprias soluções alternativas para isso. Se você trabalha com solicitações ou respostas grandes, precisa analisar uma das abordagens proprietárias.

Como você pergunta sobre "o incluído no JDK 1.5 ou melhor", responderei com relação ao que é formalmente conhecido como JAX-WS RI (também conhecido como Metro), que é o que está incluído no JDK.

O JAX-WS RI possui uma solução específica para isso, que é muito eficiente em termos de uso de memória.

Consulte https://javaee.github.io/metro/doc/user-guide/ch02.html#efficient-handlers-in-jax-ws-ri . Infelizmente, esse link está quebrado agora, mas você pode encontrá-lo no WayBack Machine. Vou dar os destaques abaixo:

O pessoal do Metro em 2007 introduziu um tipo de manipulador adicional MessageHandler<MessageHandlerContext>, proprietário do Metro. É muito mais eficiente do SOAPHandler<SOAPMessageContext>que não tenta fazer representação DOM na memória.

Aqui está o texto crucial do artigo original do blog:

MessageHandler:

Utilizando a estrutura extensível de manipulador fornecida pela especificação JAX-WS e a melhor abstração de mensagens no RI, introduzimos um novo manipulador chamado MessageHandlerpara estender seus aplicativos de serviço da Web. MessageHandler é semelhante ao SOAPHandler, exceto que as implementações dele obtêm acesso aMessageHandlerContext(uma extensão do MessageContext). Através do MessageHandlerContext, é possível acessar a mensagem e processá-la usando a API da mensagem. Como eu coloquei no título do blog, esse manipulador permite que você trabalhe na Mensagem, que fornece maneiras eficientes de acessar / processar a mensagem, não apenas uma mensagem baseada em DOM. O modelo de programação dos manipuladores é o mesmo e os manipuladores de mensagens podem ser combinados com os manipuladores lógicos e SOAP padrão. Adicionei uma amostra no JAX-WS RI 2.1.3 mostrando o uso do MessageHandler para registrar mensagens e aqui está um trecho da amostra:

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ção final da publicação no blog de 2007)

Escusado será dizer que seu manipulador personalizado, LoggingHandlerno exemplo, precisa ser adicionado à sua cadeia de manipuladores para ter algum efeito. É o mesmo que adicionar qualquer outro Handler, para que você possa procurar nas outras respostas desta página como fazer isso.

Você pode encontrar um exemplo completo no repositório Metro GitHub .

Você pode tentar colocar um ServletFilterna frente do serviço da web e inspecionar a solicitação e resposta indo / retornando do serviço.

Embora você especificamente não tenha solicitado um proxy, às vezes acho que o tcptrace é suficiente para ver o que acontece em uma conexão. É uma ferramenta simples, sem instalação, mostra os fluxos de dados e também pode gravar em arquivo.

Em tempo de execução, você pode simplesmente executar

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

as dump é um var público definido na classe da seguinte maneira

public static boolean dump;

Estou certo ao entender que você deseja alterar / acessar a mensagem XML bruta?

Nesse caso, você (ou já que tem cinco anos, o próximo cara) pode querer dar uma olhada na interface do provedor que faz parte do JAXWS. A contraparte do cliente é feita usando a classe "Dispatch". De qualquer forma, você não precisa adicionar manipuladores ou interceptores. Você ainda pode, é claro. A desvantagem é que desta forma, você é COMPLETAMENTE responsável pela criação da mensagem SOAPMessage, mas é fácil, e se é isso que você deseja (como eu queria), isso é perfeito.

Aqui está um exemplo para o lado do servidor (um pouco desajeitado, era apenas 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;}


   }
}

Você publica como se fosse um 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);
}
}

Ou você pode usar uma classe Endpoint para isso. Espero que tenha sido útil.

Ah, se você quiser, não precisa lidar com cabeçalhos e outras coisas, se alterar o modo de serviço para PAYLOAD (você só obterá o corpo do sabão).

com os arquivos de configuração logback.xml, você pode:

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

Isso registrará a solicitação e a resposta assim (dependendo da sua configuração para a saída do log):

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

Eu estava tentando encontrar alguma biblioteca de estrutura para registrar a solicitação e resposta de sabão de serviço da web por alguns dias. O código abaixo corrigiu o problema para mim:

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

Uma maneira de fazer isso é não usar seu código, mas usar farejadores de pacotes de rede como Etheral ou WireShark, que podem capturar o pacote HTTP com a mensagem XML como carga útil e você pode continuar registrando-os em um arquivo.

Mas uma abordagem mais sofisticada é escrever seus próprios manipuladores de mensagens. Você pode dar uma olhada aqui .

Na realidade. Se você procurar nas fontes do HttpClientTransport, notará que ele também está gravando mensagens no java.util.logging.Logger. O que significa que você também pode ver essas mensagens nos seus logs.

Por exemplo, se você estiver usando o Log4J2, tudo o que você precisa fazer é o seguinte:

• adicione a ponte JUL-Log4J2 ao seu caminho de classe
• defina o nível TRACE para o pacote com.sun.xml.internal.ws.transport.http.client.
• adicione a propriedade do sistema -Djava.util.logging.manager = org.apache.logging.log4j.jul.LogManager à sua linha de comandos de início da aplicação

Após essas etapas, você começará a ver mensagens SOAP em seus logs.

Existem algumas respostas usando SoapHandlers neste tópico. Você deve saber que o SoapHandlers modifica a mensagem se writeTo(out)for chamada.

Chamar o writeTo(out)método de SOAPMessage chama automaticamente o saveChanges()método também. Como resultado, todos os dados binários MTOM / XOP anexados em uma mensagem são perdidos.

Não sei por que isso está acontecendo, mas parece ser um recurso documentado.

Além disso, esse método marca o ponto em que os dados de todos os objetos AttachmentPart constituintes são inseridos na mensagem.

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

Se você executar um servidor de aplicativos IBM Liberty, basta adicionar ibm-ws-bnd.xml no diretório 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>