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.processor.chain
Class AbstractMessageProcessorChain

    java.lang.Object
      org.mule.processor.AbstractInterceptingMessageProcessor
          org.mule.processor.chain.AbstractMessageProcessorChain

All Implemented Interfaces:
  FlowConstructAware, MuleContextAware, Disposable, Initialisable, Lifecycle, Startable, Stoppable, InterceptingMessageProcessor, MessageProcessor, MessageProcessorChain, MessageSource

Direct Known Subclasses:
  DefaultMessageProcessorChain, InterceptingChainLifecycleWrapper

    public abstract class AbstractMessageProcessorChain

extends AbstractInterceptingMessageProcessor
implements MessageProcessorChain, Lifecycle, FlowConstructAware, MuleContextAware

Builder needs to return a composite rather than the first MessageProcessor in the chain. This is so that if this chain is nested in another chain the next MessageProcessor in the parent chain is not injected into the first in the nested chain.

Field Summary
`protected Log` | `log`
`protected String` | `name`
`protected List<MessageProcessor>` | `processors`

Fields inherited from class org.mule.processor.AbstractInterceptingMessageProcessor
`logger, muleContext, next, notificationHandler`

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
`AbstractMessageProcessorChain(String name, List<MessageProcessor> processors)`

Method Summary
`void` | `dispose()` A lifecycle method where implementor should free up any resources.
`protected abstract MuleEvent` | `doProcess(MuleEvent event)`
`List<MessageProcessor>` | `getMessageProcessors()`
`String` | `getName()`
`Policies` | `getPolicies()`
`void` | `initialise()` Method used to perform any initialisation work.
`MuleEvent` | `process(MuleEvent event)` Invokes the MessageProcessor.
`void` | `setFlowConstruct(FlowConstruct flowConstruct)`
`void` | `setMuleContext(MuleContext context)`
`void` | `start()`
`void` | `stop()`
`String` | `toString()`

Methods inherited from class org.mule.processor.AbstractInterceptingMessageProcessor
`fireNotification, getMuleContext, processNext, setListener`

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

Field Detail

### log

    protected final transient Log log

### name

    protected String name

### processors

    protected List<MessageProcessor> processors

Constructor Detail

### AbstractMessageProcessorChain

    public AbstractMessageProcessorChain(String name,
                                         List<MessageProcessor> processors)

Method Detail

### process

    public MuleEvent process(MuleEvent event)
                      throws MuleException

  Description copied from interface: `MessageProcessor`
  Invokes the MessageProcessor.

  Specified by:
    `process` in interface `MessageProcessor`
  Parameters:
    `event` - MuleEvent to be processed
  Returns:
    optional response MuleEvent
  Throws:
    `MuleException`

### doProcess

    protected abstract MuleEvent doProcess(MuleEvent event)
                                    throws MuleException

  Throws:
    `MuleException`

### initialise

    public void initialise()
                    throws InitialisationException

  Description copied from interface: `Initialisable`
  Method used to perform any initialisation work. If a fatal error occurs during initialisation an `InitialisationException` should be thrown, causing the Mule instance to shutdown. If the error is recoverable, say by retrying to connect, a `RecoverableException` should be thrown. There is no guarantee that by throwing a Recoverable exception that the Mule instance will not shut down.

  Specified by:
    `initialise` in interface `Initialisable`
  Throws:
    `InitialisationException` - if a fatal error occurs causing the Mule instance to shutdown
    `RecoverableException` - if an error occurs that can be recovered from

### start

    public void start()
               throws MuleException

  Specified by:
    `start` in interface `Startable`
  Throws:
    `MuleException`

### stop

    public void stop()
              throws MuleException

  Specified by:
    `stop` in interface `Stoppable`
  Throws:
    `MuleException`

### 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`

### setFlowConstruct

    public void setFlowConstruct(FlowConstruct flowConstruct)

  Specified by:
    `setFlowConstruct` in interface `FlowConstructAware`

### setMuleContext

    public void setMuleContext(MuleContext context)

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

### getName

    public String getName()

  Specified by:
    `getName` in interface `MessageProcessorChain`

### toString

    public String toString()

  Overrides:
    `toString` in class `AbstractInterceptingMessageProcessor`

### getMessageProcessors

    public List<MessageProcessor> getMessageProcessors()

  Specified by:
    `getMessageProcessors` in interface `MessageProcessorChain`

### getPolicies

    public Policies getPolicies()

  Specified by:
    `getPolicies` in interface `MessageProcessorChain`

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.