Mule

Question

使用 Mule，有没有办法拦截所有流量？我的用例是查看流名称，如果流名称与 http 请求中的特定参数匹配，我需要采取一些措施。我不想为每个流编写拦截器配置。那太乏味而且不理想。

我想要类似 Spring AOP 横切应用程序中所有流程的东西，然后编写一个 java class 可以在流程之前由 Mule 调用的东西执行。我会在那里检查流程名称，如果它与请求中的参数匹配，我可以采取行动，否则，我不需要做任何事情。

我是 Mule 新手。有人可以给我指出正确的方向吗？

Answer 1

我想向您推荐一种满足要求的方法。

定义一个以 http 作为入口点的公共流，然后定义一个选择路由器，该路由器评估所考虑的参数。因此，基于条件评估，使用 flow-ref 调用相应的流程。

Answer 2

建议可行！

但是，根据您对场景的描述，在我看来您最好使用 API 工具包。

当然它可能有很多你需要的功能，但简而言之，基于 REST API 定义（这是 http 请求的一部分）它会自动将它路由到实现的流程API.

的那部分

很棒的是，您只需编写 RAML，工作室就会为您生成流程。

希望对您有所帮助 ;)

Answer 3

你为什么不使用简单的 "Choice router"。根据您在输入中设置的请求参数，可以调用与条件相匹配的适当流程。

Answer 4

因此，如果您想基于 http url 控制流量，您可以使用通用流量并使用如下选择：-

 <http:listener-config name="HTTP_Listener_Configuration" protocol="HTTP" host="0.0.0.0" port="${port}" basePath="mainpath" doc:name="HTTP Listener Configuration"/>
   <flow  name="Entry_Point">
        <http:listener config-ref="HTTP_Listener_Configuration" path="/*" doc:name="HTTP" parseRequest="false">
            <http:error-response-builder statusCode="404" reasonPhrase="Path Not Found"/>
        </http:listener>

        <set-variable variableName="requestUri" value="#[message.inboundProperties['http.request.uri'].replace('/mainpath/','')]" doc:name="Variable"/>
        <logger level="INFO" message="PATH :-> #[requestUri]" doc:name="Logger" />

        <choice doc:name="Route Message By Path">
            <when
                expression="#[regex('service/.+', requestUri, java.util.regex.Pattern.CASE_INSENSITIVE)]">
                <flow-ref name="flow1" doc:name="flow1" />
            </when>

            <when
                expression="#[regex('audit/.+', requestUri, java.util.regex.Pattern.CASE_INSENSITIVE)]">
                <flow-ref name="flow2" doc:name="flow2" />
            </when>
            //////////// so on

但是如果你想根据 HTTP 请求 来控制你的流量，那么根据请求你可以使用 XPATH(incase XML 请求）或 JSON 到对象 转换器（在 JSON 请求的情况下）并提取元素值，并根据元素值你可以路由到使用Choice router

的流

Answer 5

您可以使用服务器通知来执行此操作，我已经实施了一个类似的方法来侦听 PRE/AFTER 调用 HTTP 端点。

这是代码：

    <spring:beans>
        <spring:bean name="MuleMessageProcessorNoticationBean" class="com.alexfrndz.MPLogger"></spring:bean>
    </spring:beans>

    package com.alexfrndz;

    import org.mule.api.MuleEvent;
    import org.mule.api.MuleMessage;
    import org.mule.api.context.notification.MessageProcessorNotificationListener;
    import org.mule.api.processor.LoggerMessageProcessor; 
    import org.mule.api.processor.MessageProcessor;
    import org.mule.context.notification.MessageProcessorNotification;
    import org.mule.endpoint.AbstractEndpoint;
    import org.mule.endpoint.DefaultOutboundEndpoint;
    import org.mule.processor.AsyncDelegateMessageProcessor;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.apache.log4j.Logger;

    public class MPLogger implements        MessageProcessorNotificationListener<MessageProcessorNotification> {
    private Logger log = Logger.getLogger(MPLogger.class);

    private  long startTime = System.currentTimeMillis();
    private  long endTime = System.currentTimeMillis();


    @Override
    public void onNotification(MessageProcessorNotification m) {
        MuleEvent ev = m.getSource();
        MuleMessage msg = ev.getMessage();
        Object payload = msg.getPayload();
        String ref = payload != null ? payload.toString() : "null";

        MessageProcessor proc = m.getProcessor();

        boolean inc = true;

        if (m.getAction() == MessageProcessorNotification.MESSAGE_PROCESSOR_PRE_INVOKE) {
               startTime = System.currentTimeMillis();
        }

        if (m.getAction() == MessageProcessorNotification.MESSAGE_PROCESSOR_POST_INVOKE) {
              long executionTime = System.currentTimeMillis() - startTime;
              AbstractEndpoint ep = (AbstractEndpoint) proc;
              log.info("Http call to : "+ ep.getName() + " took " + executionTime + "ms response time");
        }

        boolean outgoing = proc instanceof DefaultOutboundEndpoint;


        if (inc) {
          if (outgoing) {
            AbstractEndpoint ep = (AbstractEndpoint) proc;
            log.warn(msg.getMessageRootId() + " [OUTBOUND] Message " + ref + " -> " + ep.getEndpointURI());
            ep.getResponseTimeout();

          } else {
            log.warn(msg.getMessageRootId() + " [PROCESSING] Message " + ref + " <> " + proc.getClass().getSimpleName());
          }
        }
      }

}

从上面的代码中，您可以尝试获取消息处理器或流的名称并拦截负载。

这有什么帮助

Mule - 拦截所有流量

Mule - Intercept all flows