Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.mule
Class RouteableExceptionStrategy

    java.lang.Object
      org.mule.processor.AbstractMessageProcessorOwner
          org.mule.exception.AbstractExceptionListener
              org.mule.exception.AbstractMessagingExceptionStrategy
                  org.mule.RouteableExceptionStrategy

All Implemented Interfaces:
  FlowConstructAware, MuleContextAware, MessagingExceptionHandler, Disposable, Initialisable, Lifecycle, Startable, Stoppable

    public class RouteableExceptionStrategy

extends AbstractMessagingExceptionStrategy
implements FlowConstructAware, Lifecycle

`RouteableExceptionStrategy` allows transforming and routing exceptions to outbound routers. This exception strategy does not take into account any defined endpoints in its instance variable.

Since:
  2.2.6
Author:
  estebanroblesluna

Field Summary

Fields inherited from class org.mule.exception.AbstractExceptionListener
`commitTxFilter, enableNotifications, initialised, logger, messageProcessors, rollbackTxFilter`

Fields inherited from class org.mule.processor.AbstractMessageProcessorOwner
`flowConstruct, muleContext`

Fields inherited from interface org.mule.api.lifecycle.Initialisable
`PHASE_NAME`

Fields inherited from interface org.mule.api.lifecycle.Startable
`PHASE_NAME`

Fields inherited from interface org.mule.api.lifecycle.Stoppable
`PHASE_NAME`

Fields inherited from interface org.mule.api.lifecycle.Disposable
`PHASE_NAME`

Constructor Summary
`RouteableExceptionStrategy()`

Method Summary
`protected void` | `defaultHandler(MuleMessage message, Throwable t)`
`void` | `dispose()` A lifecycle method where implementor should free up any resources.
`protected void` | `doInitialise(MuleContext muleContext)`
`protected MuleMessage` | `getMessageFromContext(MuleMessage message)`
`OutboundRouter` | `getRouter()`
`MuleEvent` | `handleException(Exception e, MuleEvent event)` Take some action when a messaging exception has occurred (i.e., there was a message in play when the exception occurred).
`void` | `handleLifecycleException(Object component, Throwable t)`
`void` | `handleMessagingException(MuleMessage message, Throwable t)`
`void` | `handleRoutingException(MuleMessage message, ImmutableEndpoint endpoint, Throwable t)`
`void` | `handleStandardException(Throwable t)`
`boolean` | `isStopFurtherProcessing()`
`protected void` | `routeException(MuleMessage msg, ImmutableEndpoint failedEndpoint, Throwable t)`
`void` | `setFlowConstruct(FlowConstruct flowConstruct)`
`void` | `setMuleContext(MuleContext context)`
`void` | `setRouter(OutboundRouter router)`
`void` | `setStopFurtherProcessing(boolean stopFurtherProcessing)`
`void` | `start()`
`void` | `stop()`

Methods inherited from class org.mule.exception.AbstractMessagingExceptionStrategy
`defaultHandler, handleRoutingException, messageFromContextIfAvailable`

Methods inherited from class org.mule.exception.AbstractExceptionListener
`addEndpoint, closeStream, createOutboundRouter, fireNotification, getCommitTxFilter, getExceptionType, getMessageProcessors, getMessageProcessors, getOwnedMessageProcessors, getRollbackTxFilter, handleTransaction, initialise, isEnableNotifications, isInitialised, logException, logFatal, removeMessageProcessor, rollbackTransaction, routeException, setCommitTxFilter, setEnableNotifications, setMessageProcessors, setRollbackTxFilter`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface org.mule.api.lifecycle.Initialisable
`initialise`

Constructor Detail

### RouteableExceptionStrategy

    public RouteableExceptionStrategy()

Method Detail

### handleException

    public MuleEvent handleException(Exception e,
                                     MuleEvent event)

  Take some action when a messaging exception has occurred (i.e., there was a message in play when the exception occurred).

  Specified by:
    `handleException` in interface `MessagingExceptionHandler`
  Overrides:
    `handleException` in class `AbstractMessagingExceptionStrategy`
  Parameters:
    `e` - which occurred
    `event` - which was being processed when the exception occurred
  Returns:
    new event to route on to the rest of the flow, generally with ExceptionPayload set on the message

### handleMessagingException

    public void handleMessagingException(MuleMessage message,
                                         Throwable t)

  Overrides:
    `handleMessagingException` in class `AbstractMessagingExceptionStrategy`

### handleRoutingException

    public void handleRoutingException(MuleMessage message,
                                       ImmutableEndpoint endpoint,
                                       Throwable t)

### handleLifecycleException

    public void handleLifecycleException(Object component,
                                         Throwable t)

  Overrides:
    `handleLifecycleException` in class `AbstractMessagingExceptionStrategy`

### handleStandardException

    public void handleStandardException(Throwable t)

  Overrides:
    `handleStandardException` in class `AbstractMessagingExceptionStrategy`

### defaultHandler

    protected void defaultHandler(MuleMessage message,
                                  Throwable t)

### getMessageFromContext

    protected MuleMessage getMessageFromContext(MuleMessage message)

### routeException

    protected void routeException(MuleMessage msg,
                                  ImmutableEndpoint failedEndpoint,
                                  Throwable t)

### getRouter

    public OutboundRouter getRouter()

### setRouter

    public void setRouter(OutboundRouter router)

### isStopFurtherProcessing

    public boolean isStopFurtherProcessing()

### setStopFurtherProcessing

    public void setStopFurtherProcessing(boolean stopFurtherProcessing)

### setFlowConstruct

    public void setFlowConstruct(FlowConstruct flowConstruct)

  Specified by:
    `setFlowConstruct` in interface `FlowConstructAware`
  Overrides:
    `setFlowConstruct` in class `AbstractMessageProcessorOwner`

### setMuleContext

    public void setMuleContext(MuleContext context)

  Specified by:
    `setMuleContext` in interface `MuleContextAware`
  Overrides:
    `setMuleContext` in class `AbstractMessageProcessorOwner`

### doInitialise

    protected void doInitialise(MuleContext muleContext)
                         throws InitialisationException

  Overrides:
    `doInitialise` in class `AbstractExceptionListener`
  Throws:
    `InitialisationException`

### dispose

    public void dispose()

  Description copied from interface: `Disposable`
  A lifecycle method where implementor should free up any resources. If an exception is thrown it should just be logged and processing should continue. This method should not throw Runtime exceptions.

  Specified by:
    `dispose` in interface `Disposable`
  Overrides:
    `dispose` in class `AbstractMessageProcessorOwner`

### stop

    public void stop()
              throws MuleException

  Specified by:
    `stop` in interface `Stoppable`
  Overrides:
    `stop` in class `AbstractMessageProcessorOwner`
  Throws:
    `MuleException`

### start

    public void start()
               throws MuleException

  Specified by:
    `start` in interface `Startable`
  Overrides:
    `start` in class `AbstractMessageProcessorOwner`
  Throws:
    `MuleException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2003-2010 MuleSoft, Inc.. All Rights Reserved.