Question

我想使用VM端点来实现mule流程中的并行处理。作为骡子的初学者，我不太确定这样做的含义。我读到了mule 3中的私有流，但不确定，如果我可以在这种情况下用私有流替换vm端点，并且如果有的话，我可以获得任何优势。有人可以告诉我使用VM的优缺点。这是我想用于并行处理的示例。

<flow name="forkAndJoinFlow">
    <http:inbound-endpoint exchange-pattern="request-response" host="localhost" port="81" path="lowestprice" />
    <not-filter>
        <wildcard-filter pattern="*favicon*" />
    </not-filter>
    <request-reply>
        <all>
            <vm:outbound-endpoint path="shop1"/>
            <vm:outbound-endpoint path="shop2"/>
        </all>
        <vm:inbound-endpoint path="response">
            <message-properties-transformer>
                <add-message-property key="MULE_CORRELATION_GROUP_SIZE" value="2" />
            </message-properties-transformer>
            <collection-aggregator />
        </vm:inbound-endpoint>
    </request-reply>
    <expression-transformer evaluator="groovy" expression="java.util.Collections.min(payload)" />
    <object-to-string-transformer/>
    <logger level="WARN" message="#[string:Lowest price: #[payload]]" />
</flow>

<flow name="shop1Flow">

    <vm:inbound-endpoint path="shop1"/>
    <logger level="INFO" message="SHOP1 Flow..." />
    <expression-transformer evaluator="groovy" expression="new java.lang.Double(1000.0 * Math.random()).intValue()" />
    <logger level="WARN" message="#[string:Price from shop 1: #[payload]]" />
</flow>

<flow name="shop2Flow">

    <vm:inbound-endpoint path="shop2" />
    <logger level="INFO" message="SHOP2 Flow..." />
    <expression-transformer evaluator="groovy" expression="new java.lang.Double(1000.0 * Math.random()).intValue()" />
    <logger level="WARN" message="#[string:Price from shop 2: #[payload]]" />
</flow>

Answer 1

vm:endpoints是one-way和asynchronous，这意味着您不会收到他们的回复。

Private flows可以是synchronous，也可以是asynchronous，这意味着如果exchange-pattern为request-response，他们也可以返回回复。

此外，在private flow中，与variables或任何其他headers {{1} }}和vm 不传播，调用者流程的JMS在被调用的流程中变为variables

Answer 2

Private flows可用作VM的替换。

根据流程的private flows，Synchronus可以是Asynchronous或processingStrategy。

我认为您以异步方式使用私有流来实现并行处理，然后确保在每个私有流的末尾将响应发布回响应VM。

我也使用子流实现了并行处理的fork-join模式。试试这个。

    <set-property propertyName="MULE_CORRELATION_GROUP_SIZE" value="1" />
    <all enableCorrelation="IF_NOT_SET">
        <async>
            <set-property propertyName="MULE_CORRELATION_SEQUENCE" value="1" />
            <flow-ref name="parallel-flow1"></flow-ref>
        </async>
        <async>
            <set-property propertyName="MULE_CORRELATION_SEQUENCE"  value="2" />
            <flow-ref name="parallel-flow2"></flow-ref>
        </async>
    </all>

分流如下。

    <sub-flow name="parallel-flow1">    
        ....
        ....
        <flow-ref name="join-flow" />       
    </sub-flow>

    <sub-flow name="parallel-flow2">    
        ....
        ....
        <flow-ref name="join-flow" />       
    </sub-flow>

    <sub-flow name="join-flow">
        <collection-aggregator  timeout="10000"   failOnTimeout="true"  />          
        <combine-collections-transformer />
        ....
        ....
    </sub-flow>

您可以使用私人资源进行尝试。

希望这有帮助。

Vm终点在骡子的利弊

2 个答案: