Streaming mule esb中数据映射器中的流

我需要从一个大小为100MB-200MB的文件中获取数据（input.xml），并需要根据某种逻辑写入四个不同的文件

输入xml:

            <?xml version="1.0"?>
            <Orders>
                 <Order><OrderId>1</OrderId><Total>10</Total><Name>jon1</Name></Order>
                <Order><OrderId>2</OrderId><Total>20</Total><Name>jon2</Name></Order>
                <Order><OrderId>3</OrderId><Total>30</Total><Name>jon3</Name></Order>
                <Order><OrderId>4</OrderId><Total>40</Total><Name>jon4</Name></Order>
            <Orders>

110jon1
2202
330jon3
4404

逻辑是如果总数为1-10，则写入文件1；如果总数为11-20，则写入文件2

预期产出：

1 10 jon1-->写入文件1

2 20 jon2-->写入文件2

3 30 jon3-->写入文件3

4 40 jon4-->写入文件4

在这里，我已经在datamapper中启用了流，它正在配置中，但是我没有得到正确的输出。问题是我只把一些代码记录到一个文件中，在满足条件后应该进入该文件

但若我禁用datamapper中的流按钮，它就可以正常工作了。由于有大量的记录，我必须使用流媒体选项

是否有其他方法配置datamapper以启用流选项

---

请就此向我提出建议。谢谢。，

如果不详细说明您正在做的工作，很难看到问题。 然而，我认为这可能会帮助你尝试另一种方法

数据映射器将把完整的XML文档加载到内存中，尽管您激活了流，但它必须这样做才能支持XPATH（它将完整的XML输入加载到DOM中）。 所以，如果您负担不起将200Mb文档加载到内存中，您需要尝试一种解决方法

我之前所做的是创建一个java组件，在stax解析器的帮助下将输入流转换为迭代器。通过一个非常简单的实现，您可以编写一个迭代器，该迭代器从流中提取来创建下一个元素（pojo、映射、字符串……）。在mule流中，在“java组件”之后，您应该能够使用“for each”和“choice”，并应用您的逻辑

您的数据的一个快速示例：

package tests;

import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import javax.xml.stream.FactoryConfigurationError;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class OrdersStreamIterator implements Iterator<Map<String,String>> {

    final static Log LOGGER = LogFactory.getLog(OrdersStreamIterator.class);

    final InputStream is;
    final XMLStreamReader xmlReader;

    boolean end = false;
    HashMap<String,String> next;

    public OrdersStreamIterator(InputStream is)
            throws XMLStreamException, FactoryConfigurationError {
        this.is = is;
        xmlReader = XMLInputFactory.newInstance().createXMLStreamReader(is);
    }

    protected HashMap<String,String> _next() throws XMLStreamException {
        int event;
        HashMap<String,String> order = null;
        String orderChild = null;
        String orderChildValue = null;
        while (xmlReader.hasNext()) {
            event = xmlReader.getEventType();
            if (event == XMLStreamConstants.START_ELEMENT) {
                if (order==null) {
                    if (checkOrder()) {
                        order = new HashMap<String,String>();
                    }
                }
                else {
                    orderChild = xmlReader.getLocalName();
                }
            }
            else if (event == XMLStreamConstants.END_ELEMENT) {
                if (checkOrders()) {
                    end = true;
                    return null;
                }
                else if (checkOrder()) {
                    xmlReader.next();
                    return order;
                }
                else if (order!=null) {
                    order.put(orderChild, orderChildValue);
                    orderChild = null;
                    orderChildValue = null;
                }
            }
            else if (order!=null && orderChild!=null){
                switch (event) {
                case XMLStreamConstants.SPACE:
                case XMLStreamConstants.CHARACTERS:
                case XMLStreamConstants.CDATA:
                    int start = xmlReader.getTextStart();
                    int length = xmlReader.getTextLength();
                    if (orderChildValue==null) {
                        orderChildValue = new String(xmlReader.getTextCharacters(), start, length);
                    }
                    else {
                        orderChildValue += new String(xmlReader.getTextCharacters(), start, length);
                    }
                    break;
                }
            }
            xmlReader.next();
        }
        end = true;
        return null;
    }

    protected boolean checkOrder() {
        return "Order".equals(xmlReader.getLocalName());
    }

    protected boolean checkOrders() {
        return "Orders".equals(xmlReader.getLocalName());
    }

    @Override
    public boolean hasNext() {
        if (end) {
            return false;
        }
        else if (next==null) {
            try {
                next = _next();
            } catch (XMLStreamException e) {
                LOGGER.error(e.getMessage(), e);
                end = true;
            }
            return !end;
        }
        else {
            return true;
        }
    }


    @Override
    public Map<String,String> next() {
        if (hasNext()) {
            final HashMap<String,String> n = next;
            next = null;
            return n;
        }
        else {
            return null;
        }
    }


    @Override
    public void remove() {
        throw new RuntimeException("ReadOnly!");
    }

    // Test

    public static String dump(Map<String,String> o) {
        String s = "{";
        for (Entry<String,String> e : o.entrySet()) {
            if (s.length()>1) {
                s+=", ";
            }
            s+= "\"" + e.getKey() + "\" : \"" + e.getValue() + "\"";
        }
        return s + "}";
    }

    public static void main(String[] argv) throws XMLStreamException, FactoryConfigurationError {
        final InputStream is = OrdersStreamIterator.class.getClassLoader().getResourceAsStream("orders.xml");
        final OrdersStreamIterator i = new OrdersStreamIterator(is);
        while (i.hasNext()) {
            System.out.println(dump(i.next()));
        }
    }
}

包测试；
导入java.io.InputStream；
导入java.util.HashMap；
导入java.util.Iterator；
导入java.util.Map；
导入java.util.Map.Entry；
导入javax.xml.stream.FactoryConfigurationError；
导入javax.xml.stream.XMLInputFactory；
导入javax.xml.stream.XMLStreamConstants；
导入javax.xml.stream.XMLStreamException；
导入javax.xml.stream.XMLStreamReader；
导入org.apache.commons.logging.Log；
导入org.apache.commons.logging.LogFactory；
公共类OrdersStreamiter实现迭代器{
最终静态日志记录器=LogFactory.getLog（OrdersStreamIterator.class）；
最终输入流为；
最终XMLStreamReader xmlReader；
布尔结束=假；
HashMap-next；
public OrdersStreamizer（InputStream为）
引发XMLStreamException，FactoryConfigurationError{
this.is=is；
xmlReader=XMLInputFactory.newInstance（）.createXMLStreamReader（is）；
}
受保护的HashMap_next（）抛出XMLStreamException{
int事件；
HashMap顺序=null；
字符串orderChild=null；
字符串orderChildValue=null；
while（xmlReader.hasNext（））{
event=xmlReader.getEventType（）；
if（event==XMLStreamConstants.START_元素）{
if（order==null）{
if（checkOrder（））{
order=新的HashMap（）；
}
}
否则{
orderChild=xmlReader.getLocalName（）；
}
}
else if（event==XMLStreamConstants.END_元素）{
if（checkOrders（））{
结束=真；
返回null；
}
else if（checkOrder（））{
xmlReader.next（）；
退货单；
}
else if（订单！=null）{
order.put（orderChild，orderChildValue）；
orderChild=null；
orderChildValue=null；
}
}
else if（order！=null&&orderChild！=null）{
开关（事件）{
案例XMLStreamConstants.SPACE：
大小写XMLStreamConstants.CHARACTERS：
案例XMLStreamConstants.CDATA：
int start=xmlReader.getTextStart（）；
int length=xmlReader.getTextLength（）；
if（orderChildValue==null）{
orderChildValue=新字符串（xmlReader.getTextCharacters（），开始，长度）；
}
否则{
orderChildValue+=新字符串（xmlReader.getTextCharacters（），开始，长度）；
}
打破
}
}
xmlReader.next（）；
}
结束=真；
返回null；
}
受保护的布尔检查顺序（）{
返回“Order”.equals（xmlReader.getLocalName（））；
}
受保护的布尔检查顺序（）{
返回“Orders.equals（xmlReader.getLocalName（））；
}
@凌驾
公共布尔hasNext（）{
若(完){
返回false；
}
else if（next==null）{
试一试{
下一步=_下一步（）；
}捕获（XMLStreamException e）{
LOGGER.error（e.getMessage（），e）；
结束=真；
}
返回！结束；
}
否则{
返回true；
}
}
@凌驾
公共地图下一页（）{
if（hasNext（））{
最终HashMap n=next；
next=null；
返回n；
}
否则{
返回null；
}
}
@凌驾
公共空间删除（）{
抛出新的RuntimeException（“只读！”）；
}
//试验
公共静态字符串转储（映射o）{
字符串s=“{”；
对于（条目e:o.entrySet（））{
如果（s.长度（）>1）{
s+=“，”；
 <flow name="testsFlow">
        <http:listener config-ref="HTTP_Listener_Configuration" path="/" doc:name="HTTP"/>
        <scripting:component doc:name="Groovy">
            <scripting:script engine="Groovy"><![CDATA[return tests.OrdersStreamIterator.class.getClassLoader().getResourceAsStream("orders.xml");]]></scripting:script>
        </scripting:component>
        <set-payload value="#[new tests.OrdersStreamIterator(payload)]" doc:name="Iterator"/>
        <foreach doc:name="For Each">
            <logger message="#[tests.OrdersStreamIterator.dump(payload)]" level="INFO" doc:name="Logger"/>
        </foreach>
    </flow>