Comment Modifier Le XML Brut, message d'un émetteur CXF Demande?

Je voudrais modifier un sortant une Requête SOAP.
Je voudrais enlever 2 nœuds xml à partir de l'Enveloppe du corps.
J'ai réussi à mettre en place un Intercepteur et obtenir le générés Chaîne de valeur de l'ensemble de messages au point de terminaison.

Cependant, le code suivant ne semble pas fonctionner tant que le message sortant est pas modifié comme prévu. Quelqu'un aurait-il un code ou des idées sur comment faire cela?

public class MyOutInterceptor extends AbstractSoapInterceptor {

public MyOutInterceptor() {
        super(Phase.SEND); 
}

public void handleMessage(SoapMessage message) throws Fault { 
        //Get message content for dirty editing...
        StringWriter writer = new StringWriter();
        CachedOutputStream cos  = (CachedOutputStream)message.getContent(OutputStream.class); 
        InputStream inputStream = cos.getInputStream();
        IOUtils.copy(inputStream, writer, "UTF-8");
        String content = writer.toString();

        //remove the substrings from envelope...
        content = content.replace("<idJustification>0</idJustification>", "");
        content = content.replace("<indicRdv>false</indicRdv>", "");
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        outputStream.write(content.getBytes(Charset.forName("UTF-8")));
        message.setContent(OutputStream.class, outputStream);
}

OriginalL'auteur kiwifrog | 2011-08-02

  1. 17

    J'ai eu ce problème aujourd'hui. Après bien des pleurs et des grincements de dents, j'ai été en mesure de modifier la StreamInterceptor classe dans le configuration_interceptor démo qui vient avec le CXF source:

    OutputStream os = message.getContent(OutputStream.class);
CachedStream cs = new CachedStream();
message.setContent(OutputStream.class, cs);

message.getInterceptorChain().doIntercept(message);

try {
    cs.flush();
    CachedOutputStream csnew = (CachedOutputStream) message.getContent(OutputStream.class);

    String soapMessage = IOUtils.toString(csnew.getInputStream());
    ...

    La soapMessage variable contiennent l'intégralité du message SOAP. Vous devriez être capable de manipuler le message de savon, rincer à un flux de sortie et de faire un message.setContent(OutputStream.class... appel pour mettre vos modifications sur le message. Ce n'est assorti d'aucune garantie, car je suis assez nouveau à CXF moi-même!

    Remarque: CachedStream est une classe privée dans le StreamInterceptor classe. N'oubliez pas de configurer votre intercepteur à exécuter dans le PRE_STREAM phase, de sorte que le SAVON d'intercepteurs ont une chance d'écrire le message SOAP.

    Merci pour vos commentaires Jean. D'autres éléments relatifs à cette question peut être trouvée ici: stackoverflow.com/questions/6906499/...
    Dans votre exemple, le OutputStream os est déclarée mais non utilisés: comment en avez-vous besoin dans ce code?

    OriginalL'auteur Jpnh

  2. 35

    Basé sur le premier commentaire, j'ai créé une classe abstraite qui peut facilement être utilisé pour modifier l'ensemble de l'enveloppe soap.

    Juste au cas où quelqu'un veut un prêt-à-utiliser le code de la partie.

    import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.apache.commons.io.IOUtils;
import org.apache.cxf.binding.soap.interceptor.SoapPreProtocolOutInterceptor;
import org.apache.cxf.io.CachedOutputStream;
import org.apache.cxf.message.Message;
import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;
import org.apache.log4j.Logger;
/**
* http://www.mastertheboss.com/jboss-web-services/apache-cxf-interceptors
* http://stackoverflow.com/questions/6915428/how-to-modify-the-raw-xml-message-of-an-outbound-cxf-request
* 
*/
public abstract class MessageChangeInterceptor extends AbstractPhaseInterceptor<Message> {
public MessageChangeInterceptor() {
super(Phase.PRE_STREAM);
addBefore(SoapPreProtocolOutInterceptor.class.getName());
}
protected abstract Logger getLogger();
protected abstract String changeOutboundMessage(String currentEnvelope);
protected abstract String changeInboundMessage(String currentEnvelope);
public void handleMessage(Message message) {
boolean isOutbound = false;
isOutbound = message == message.getExchange().getOutMessage()
|| message == message.getExchange().getOutFaultMessage();
if (isOutbound) {
OutputStream os = message.getContent(OutputStream.class);
CachedStream cs = new CachedStream();
message.setContent(OutputStream.class, cs);
message.getInterceptorChain().doIntercept(message);
try {
cs.flush();
IOUtils.closeQuietly(cs);
CachedOutputStream csnew = (CachedOutputStream) message.getContent(OutputStream.class);
String currentEnvelopeMessage = IOUtils.toString(csnew.getInputStream(), "UTF-8");
csnew.flush();
IOUtils.closeQuietly(csnew);
if (getLogger().isDebugEnabled()) {
getLogger().debug("Outbound message: " + currentEnvelopeMessage);
}
String res = changeOutboundMessage(currentEnvelopeMessage);
if (res != null) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Outbound message has been changed: " + res);
}
}
res = res != null ? res : currentEnvelopeMessage;
InputStream replaceInStream = IOUtils.toInputStream(res, "UTF-8");
IOUtils.copy(replaceInStream, os);
replaceInStream.close();
IOUtils.closeQuietly(replaceInStream);
os.flush();
message.setContent(OutputStream.class, os);
IOUtils.closeQuietly(os);
} catch (IOException ioe) {
getLogger().warn("Unable to perform change.", ioe);
throw new RuntimeException(ioe);
}
} else {
try {
InputStream is = message.getContent(InputStream.class);
String currentEnvelopeMessage = IOUtils.toString(is, "UTF-8");
IOUtils.closeQuietly(is);
if (getLogger().isDebugEnabled()) {
getLogger().debug("Inbound message: " + currentEnvelopeMessage);
}
String res = changeInboundMessage(currentEnvelopeMessage);
if (res != null) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Inbound message has been changed: " + res);
}
}
res = res != null ? res : currentEnvelopeMessage;
is = IOUtils.toInputStream(res, "UTF-8");
message.setContent(InputStream.class, is);
IOUtils.closeQuietly(is);
} catch (IOException ioe) {
getLogger().warn("Unable to perform change.", ioe);
throw new RuntimeException(ioe);
}
}
}
public void handleFault(Message message) {
}
private class CachedStream extends CachedOutputStream {
public CachedStream() {
super();
}
protected void doFlush() throws IOException {
currentStream.flush();
}
protected void doClose() throws IOException {
}
protected void onWrite() throws IOException {
}
}
}
    Cette solution fonctionne parfaitement merci une tonne 🙂
    Vraiment sympa! Merci!
    D'où vient CachedStream venir? Je ne vois pas une importation pour elle et ne peut pas le trouver.
    Si quelqu'un est intéressé comment faire pour la joindre à un générés Apache Cxf client, il faut simplement utiliser Client client = ClientProxy.getClient(someServicePort); client.getInInterceptors().add(new MessageChangeInterceptor() { .. }); de sorte qu'il sera possible de modifier RAW réponse
    Je suis désolé... C'est terriblement code cassé. travail, mais comme @shx expériences, c'est de la pure chance. D'entrée et les flux de Sortie sont créées pour des a pas de raisons, vidés quand ils sont vides, échangé dans le message pour aucune raison, fermé lorsque l'auteur n'a pas l'ouvrir (ce qui signifie qu'il est probablement le double de clôture de cours d'eau), et ainsi de suite. De Plus il ne fonctionne pas du tout si le message écrit est fait par le biais d'un écrivain au lieu d'un flux de sortie (par exemple, le SAVON sur JMS avec messageType = TEXTE). Le principe de base est bonne (à l'aide d'un intercepteur, l'accès au cours d'eau...), mais la mise en œuvre est vraiment mauvais.

    OriginalL'auteur snowindy

  3. 1

    La suite est capable de proposer du côté serveur exceptions. L'utilisation de l'os.close() à la place de IOUtils.closeQuietly(os) dans la solution précédente est également en mesure de proposer des exceptions.

    public class OutInterceptor extends AbstractPhaseInterceptor<Message> {     
public OutInterceptor() { 
super(Phase.PRE_STREAM); 
addBefore(StaxOutInterceptor.class.getName()); 
}   
public void handleMessage(Message message) { 
OutputStream os = message.getContent(OutputStream.class); 
CachedOutputStream cos = new CachedOutputStream(); 
message.setContent(OutputStream.class, cos); 
message.getInterceptorChain.aad(new PDWSOutMessageChangingInterceptor(os)); 
}
} 
public class OutMessageChangingInterceptor extends AbstractPhaseInterceptor<Message> {
private OutputStream os; 
public OutMessageChangingInterceptor(OutputStream os){
super(Phase.PRE_STREAM_ENDING); 
addAfter(StaxOutEndingInterceptor.class.getName()); 
this.os = os;
} 
public void handleMessage(Message message) { 
try { 
CachedOutputStream csnew = (CachedOutputStream) message .getContent(OutputStream.class);
String currentEnvelopeMessage = IOUtils.toString( csnew.getInputStream(), (String) message.get(Message.ENCODING)); 
csnew.flush(); 
IOUtils.closeQuietly(csnew); 
String res = changeOutboundMessage(currentEnvelopeMessage); 
res = res != null ? res : currentEnvelopeMessage; 
InputStream replaceInStream = IOUtils.tolnputStream(res, (String) message.get(Message.ENCODING)); 
IOUtils.copy(replaceInStream, os); 
replaceInStream.close(); 
IOUtils.closeQuietly(replaceInStream);
message.setContent(OutputStream.class, os);
} catch (IOException ioe) {
throw new RuntimeException(ioe);  
}
}
}
    Bienvenue à Débordement de Pile! Bien que cette réponse est probablement correct et utile, il est préférable, si vous incluez une explication avec elle pour expliquer comment elle aide à résoudre le problème. Ceci est particulièrement utile dans le futur, si il y a un changement (éventuellement sans rapport) qui provoque l'arrêt de travail et les utilisateurs doivent comprendre comment il a travaillé autrefois.

    OriginalL'auteur Md Atikur Rahman