如迭代更改消息并完全发送（wso2esb）

我收到来自

AAA

嵌套子项的消息。我希望每个孩子

BBB

替换

CCC

的值。然后在

AAA

<AAA>
    <BBB>
        <CCC>test1</CCC>
        <DDD>testing</DDD>
    </BBB>
    <BBB>
        <CCC>test2</CCC>
        <DDD>testing</DDD>
    </BBB>
    <BBB>
        <CCC>test3</CCC>
        <DDD>testing</DDD>
    </BBB>
    <BBB>
        <CCC>test4</CCC>
        <DDD>testing</DDD>
    </BBB>
    <BBB>
        <CCC>test5</CCC>
        <DDD>testing</DDD>
    </BBB>
</AAA>

测试1
测试
测试2
测试
测试3
测试
测试4
测试
测试5
测试

我这样做：

<iterate continueParent="true" expression="/AAA/BBB">
    <target>
        <sequence>
            <property name="newValue" value="chang testing" scope="default" type="STRING"/>
            <enrich>
                <source clone="false" type="custom" xpath="get-property('newValue')"/>
                <target action="replace" type="custom" xpath="//DDD"/>
            </enrich>
         </sequence>
    </target>
</iterate>

---

但是更改消息不会存储在

上。如果使用迭代中介，则必须聚合结果以获得修改的消息。如何通过使用xslt中介实现这一点。示例代理配置如下所示

<proxy name="yourpproxy" transports="https http" startOnLoad="true"   trace="disable">
      <description/>
      <target>
         <inSequence>
            <xslt key="yourxsltkey"/> 
            <send/>
         </inSequence>
         <outSequence>
            <send/>
         </outSequence>
      </target>
</proxy>

其中，yourxsltkey是xslt定义的关键。这可以声明为本地条目，也可以在注册表中声明。作为这里的一个示例，我将其定义为本地条目

<localEntry key="yourxsltkey">
    <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0">
        <xsl:output method="xml" omit-xml-declaration="yes" indent="yes"/>

       <xsl:template match="/">
        <AAA xmlns="http://ws.apache.org/ns/synapse">
          <xsl:for-each select="AAA/BBB">
            <BBB><xsl:value-of select="CCC"/></BBB>
          </xsl:for-each>
        </AAA>
       </xsl:template>
    </xsl:stylesheet>

 </localEntry>

---

我编写了我的中介并将其用于此目的

import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMNode;
import org.apache.axiom.om.impl.dom.NamespaceImpl;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axis2.AxisFault;
import org.apache.synapse.Mediator;
import org.apache.synapse.MessageContext;
import org.apache.synapse.mediators.AbstractMediator;
import org.apache.synapse.mediators.eip.EIPUtils;
import org.apache.synapse.util.MessageHelper;
import org.apache.synapse.util.xpath.SynapseXPath;
import org.jaxen.JaxenException;

import java.util.List;


public class SplitMediator extends AbstractMediator {

    private String sequenceRef = null;
    private String xpathString = null;
    private String attachPathString = null;
    private String uri = null;
    private String prefix = null;

    public boolean mediate(MessageContext synCtx) {
        if (sequenceRef == null || xpathString == null || attachPathString == null) {
            handleException("Error creating a mediate due to sequenceRef or xpathString  attachPathString is null", synCtx);
            return false;
        }

        try {
            SOAPEnvelope envelope = synCtx.getEnvelope();
            Mediator sequenceMediator = synCtx.getSequence(sequenceRef);

            SynapseXPath expression = new SynapseXPath(xpathString);
            if (uri != null && prefix != null)
                expression.addNamespace(new NamespaceImpl(uri, prefix));
            SynapseXPath attachPath = new SynapseXPath(attachPathString);
            if (uri != null && prefix != null)
                attachPath.addNamespace(new NamespaceImpl(uri, prefix));

            List<OMNode> splitElements = EIPUtils.getDetachedMatchingElements(envelope, synCtx, expression);
            MessageContext templateMessageContext = MessageHelper.cloneMessageContext(synCtx);
            OMElement omElement = getOMElementByXPath(attachPath, envelope, synCtx);

            for (OMNode o : splitElements) {
                 MessageContext changeCtx = getNewMessageContextToSequence(templateMessageContext, o, attachPath);
                sequenceMediator.mediate(changeCtx);
                List elementList = EIPUtils.getMatchingElements(changeCtx.getEnvelope(), expression);
                OMNode changeElement = (OMNode) elementList.get(0);
                omElement.addChild(changeElement);
            }
        } catch (JaxenException e) {
            handleException("Error evaluating split XPath expression : " + xpathString, e, synCtx);
        } catch (AxisFault af) {
            handleException("Error creating an iterated copy of the message", af, synCtx);
        }
        return true;
    }

    private MessageContext getNewMessageContextToSequence(MessageContext templateMessageContext, OMNode o, SynapseXPath attachPath) throws AxisFault, JaxenException {
        MessageContext synCtx = MessageHelper.cloneMessageContext(templateMessageContext);
        SOAPEnvelope envelope = synCtx.getEnvelope();
        OMElement omElement = getOMElementByXPath(attachPath, envelope, synCtx);
        omElement.addChild(o);
        return synCtx;
    }

    private OMElement getOMElementByXPath(SynapseXPath attachPath, SOAPEnvelope envelope, MessageContext synCtx) {
        Object attachElem = attachPath.evaluate(envelope, synCtx);
        if (attachElem != null &&
                attachElem instanceof List && !((List) attachElem).isEmpty()) {
            attachElem = ((List) attachElem).get(0);
        }
        // for the moment attaching element should be an OMElement
        if (attachElem != null && attachElem instanceof OMElement) {
            return ((OMElement) attachElem);
        } else {
            handleException("Error in attaching the splitted elements :: " +
                    "Unable to get the attach path specified by the expression " +
                    attachPath, synCtx);
        }
        return null;
    }


    ///////////////////////////////////////////////////////////////////////////////////////
    //                        Getters and Setters                                        //
    ///////////////////////////////////////////////////////////////////////////////////////


    public String getXpathString() {
        return xpathString;
    }

    public void setXpathString(String xpathString) {
        this.xpathString = xpathString;
    }

    public String getAttachPathString() {
        return attachPathString;
    }

    public void setAttachPathString(String attachPathString) {
        this.attachPathString = attachPathString;
    }

    public String getUri() {
        return uri;
    }

    public void setUri(String uri) {
        this.uri = uri;
    }

    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    public String getSequenceRef() {
        return sequenceRef;
    }

    public void setSequenceRef(String sequenceRef) {
        this.sequenceRef = sequenceRef;
    }
}

import org.apache.axiom.om.OMElement；
导入org.apache.axiom.om.OMNode；
导入org.apache.axiom.om.impl.dom.NamespaceImpl；
导入org.apache.axiom.soap.SOAPEnvelope；
导入org.apache.axis2.AxisFault；
导入org.apache.synapse.Mediator；
导入org.apache.synapse.MessageContext；
导入org.apache.synapse.mediators.AbstractMediator；
导入org.apache.synapse.mediators.eip.EIPUtils；
导入org.apache.synapse.util.MessageHelper；
导入org.apache.synapse.util.xpath.synapsepath；
导入org.jaxen.JaxenException；
导入java.util.List；
公共类SplitMediator扩展了AbstractMediator{
私有字符串sequenceRef=null；
私有字符串xpathString=null；
私有字符串attachPathString=null；
私有字符串uri=null；
私有字符串前缀=null；
公共布尔中介（MessageContext synCtx）{
如果（sequenceRef==null | | xpathString==null | | attachPathString==null）{
handleException（“由于sequenceRef或xpathString attachPathString为空而创建中介时出错”，synCtx）；
返回false；
}
试一试{
SOAPEnvelope信封=synCtx.getEnvelope（）；
Mediator sequenceMediator=synCtx.getSequence（sequenceRef）；
SynapseXPath表达式=新的SynapseXPath（xpathString）；
if（uri！=null&&prefix！=null）
addNamespace（新名称空间impl（uri，前缀））；
SynapsePath attachPath=新的SynapsePath（attachPathString）；
if（uri！=null&&prefix！=null）
addNamespace（新的NamespaceImpl（uri，前缀））；
List splitElements=EIPUtils.getDetachedMatchingElements（信封、synCtx、表达式）；
MessageContext templateMessageContext=MessageHelper.cloneMessageContext（synCtx）；
OMElement=getOMElementByXPath（附件路径、信封、synCtx）；
for（OMNode o:splitElements）{
MessageContext changeCtx=getNewMessageContextToSequence（templateMessageContext，o，attachPath）；
sequenceMediator.mediate（changeCtx）；
List elementList=EIPUtils.getMatchingElements（changeCtx.getEnvelope（），表达式）；
OMNode changelement=（OMNode）elementList.get（0）；
OmeElement.addChild（changeElement）；
}
}catch（JaxenException e）{
handleException（“计算拆分XPath表达式时出错：“+xpathString，e，synCtx”）；
}捕捉（AxisFault af）{
handleException（“创建消息的迭代副本时出错”，af，synCtx）；
}
返回true；
}
private MessageContext getNewMessageContextToSequence（MessageContext templateMessageContext，OMNode o，SynapsePath attachPath）抛出AxisFault、JaxenException{
MessageContext synCtx=MessageHelper.cloneMessageContext（templateMessageContext）；
SOAPEnvelope信封=synCtx.getEnvelope（）；
OMElement=getOMElementByXPath（附件路径、信封、synCtx）；
omElement.addChild（o）；
返回synCtx；
}
私有OMElement getOMElementByXPath（SynapseXPath attachPath、SOAPEnvelope信封、MessageContext synCtx）{
objectattachelem=attachPath.evaluate（信封，synCtx）；
if（attachElem！=null&&
attachElem List&！的实例（（List）attachElem.isEmpty（））{
attachElem=（（列表）attachElem.get（0）；
}
//目前，连接元件应为OmeElement
if（attachElem！=null&&attachElem实例OmeElement）{
返回（（OmeElement）附件）；
}否则{
handleException（“附加拆分元素时出错：”+
“无法获取表达式指定的附加路径”+
附件路径（synCtx）；
}
返回null；
}
///////////////////////////////////////////////////////////////////////////////////////
//接球手和接球手//
///////////////////////////////////////////////////////////////////////////////////////
公共字符串getXpathString（）{
返回xpathString；
}
公共void setXpathString（字符串xpathString）{
this.xpathString=xpathString；
}
公共字符串getAttachPathString（）{
返回attachPathString；
}
public void setAttachPathString（字符串attachPathString）{
this.attachPathString=attachPathString；
}
公共字符串getUri（）{
返回uri；
}
公共void setUri（字符串uri）{
this.uri=uri；
}
公共字符串getP