コード例 #1
0
  /**
   * Will dispatch an application event through Mule
   *
   * @param applicationEvent the Spring event to be dispatched
   * @throws ApplicationEventException if the event cannot be dispatched i.e. if the underlying
   *     transport throws an exception
   */
  protected void dispatchEvent(MuleApplicationEvent applicationEvent)
      throws ApplicationEventException {
    UMOEndpoint endpoint = null;
    try {
      endpoint =
          MuleEndpoint.getOrCreateEndpointForUri(
              applicationEvent.getEndpoint(), UMOEndpoint.ENDPOINT_TYPE_SENDER);
    } catch (UMOException e) {
      throw new ApplicationEventException(
          "Failed to get endpoint for endpointUri: " + applicationEvent.getEndpoint(), e);
    }
    if (endpoint != null) {
      try {
        // if (applicationEvent.getEndpoint() != null) {
        // endpoint.setEndpointURI(applicationEvent.getEndpoint());
        // }

        MuleMessage message =
            new MuleMessage(applicationEvent.getSource(), applicationEvent.getProperties());
        // has dispatch been triggered using beanFactory.publish()
        // without a current event
        if (applicationEvent.getMuleEventContext() != null) {
          // tell mule not to try and route this event itself
          applicationEvent.getMuleEventContext().setStopFurtherProcessing(true);
          applicationEvent.getMuleEventContext().dispatchEvent(message, endpoint);
        } else {
          UMOSession session =
              new MuleSession(
                  message,
                  ((AbstractConnector) endpoint.getConnector()).getSessionHandler(),
                  component);
          RequestContext.setEvent(new MuleEvent(message, endpoint, session, false));
          // transform if necessary
          if (endpoint.getTransformer() != null) {
            message =
                new MuleMessage(
                    endpoint.getTransformer().transform(applicationEvent.getSource()),
                    applicationEvent.getProperties());
          }
          endpoint.dispatch(new MuleEvent(message, endpoint, session, false));
        }
      } catch (Exception e1) {
        throw new ApplicationEventException("Failed to dispatch event: " + e1.getMessage(), e1);
      }
    } else {
      throw new ApplicationEventException(
          "Failed endpoint using name: " + applicationEvent.getEndpoint());
    }
  }
コード例 #2
0
  /**
   * Method is used to dispatch events to listeners registered with the EventManager or dispatches
   * events to Mule depending on the type and state of the event received. If the event is not a
   * Mule event it will be dispatched to any listeners registered that are NOT MuleEventListeners.
   * If the event is a Mule event and there is no source event attached to it, it is assumed that
   * the event was dispatched by an object in the context using context.publishEvent() and will be
   * dispatched by Mule. If the event does have a source event attached to it, it is assumed that
   * the event was dispatched by Mule and will be delivered to any listeners subscribed to the
   * event.
   *
   * @param e application event received by the context
   */
  public void multicastEvent(ApplicationEvent e) {
    MuleApplicationEvent muleEvent = null;
    // if the context gets refreshed we need to reinitialise
    if (e instanceof ContextRefreshedEvent) {
      // If the manager is being initialised from another context
      // don't try and initialise Mule
      if (MuleManager.isInstanciated() && !MuleManager.getInstance().isInitialised()) {
        try {
          registerMulticasterDescriptor();
        } catch (UMOException ex) {
          throw new MuleRuntimeException(SpringMessages.failedToReinitMule(), ex);
        }
      } else {
        initMule();
      }
    } else if (e instanceof ContextClosedEvent) {
      MuleManager.getInstance().dispose();
      return;
    } else if (e instanceof MuleApplicationEvent) {
      muleEvent = (MuleApplicationEvent) e;
      // If there is no Mule event the event didn't originate from Mule
      // so its an outbound event
      if (muleEvent.getMuleEventContext() == null) {
        try {
          dispatchEvent(muleEvent);
        } catch (ApplicationEventException e1) {
          exceptionListener.exceptionThrown(e1);
        }
        return;
      }
    }

    for (Iterator iterator = listeners.iterator(); iterator.hasNext(); ) {
      ApplicationListener listener = (ApplicationListener) iterator.next();
      if (muleEvent != null) {
        // As the asynchronous listener wraps the real listener we need to
        // check the
        // type of the wrapped listener, but invoke the Async listener
        if (listener instanceof AsynchronousEventListener) {
          AsynchronousEventListener asyncListener = (AsynchronousEventListener) listener;
          if (asyncListener.getListener() instanceof MuleSubscriptionEventListener) {
            if (isSubscriptionMatch(
                muleEvent.getEndpoint(),
                ((MuleSubscriptionEventListener) asyncListener.getListener()).getSubscriptions())) {
              asyncListener.onApplicationEvent(muleEvent);
            }
          } else if (asyncListener.getListener() instanceof MuleEventListener) {
            asyncListener.onApplicationEvent(muleEvent);
          } else if (!(asyncListener.getListener() instanceof MuleEventListener)) {
            asyncListener.onApplicationEvent(e);
          }
          // Synchronous Event listener Checks
        } else if (listener instanceof MuleSubscriptionEventListener) {
          if (isSubscriptionMatch(
              muleEvent.getEndpoint(),
              ((MuleSubscriptionEventListener) listener).getSubscriptions())) {
            listener.onApplicationEvent(muleEvent);
          }
        } else if (listener instanceof MuleEventListener) {
          listener.onApplicationEvent(muleEvent);
        }
      } else if (listener instanceof AsynchronousEventListener
          && !(((AsynchronousEventListener) listener).getListener() instanceof MuleEventListener)) {
        listener.onApplicationEvent(e);
      } else if (!(listener instanceof MuleEventListener)) {
        listener.onApplicationEvent(e);
      } else {
        // Finally only propagate the Application event if the
        // ApplicationEvent interface is explicitly implemented
        for (int i = 0; i < listener.getClass().getInterfaces().length; i++) {
          if (listener.getClass().getInterfaces()[i].equals(ApplicationListener.class)) {
            listener.onApplicationEvent(e);
            break;
          }
        }
      }
    }
  }