Package org.apache.cxf.interceptor

## Interface InterceptorChain

- All Superinterfaces:
    `Iterable<Interceptor<? extends Message>>`
  All Known Implementing Classes:
    `PhaseInterceptorChain`

      public interface InterceptorChain
      extends Iterable<Interceptor<? extends Message>>

  Base interface for all interceptor chains. An interceptor chain is an ordered list of interceptors associated with one portion of the message processing pipeline. Interceptor chains are defined for a client's request processing, response processing, and incoming SOAP fault processing. Interceptor chains are defined for a service's request processing, response processing, and outgoing SOAP fault processing.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Interface | Description
    --- | --- | ---
    `static class` | `InterceptorChain.State` |

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static String` | `STARTING_AFTER_INTERCEPTOR_ID` |
    `static String` | `STARTING_AT_INTERCEPTOR_ID` |

  - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `abort()` |
    `void` | `add​(Collection<Interceptor<? extends Message>> i)` | Adds multiple interceptors to the interceptor chain.
    `void` | `add​(Interceptor<? extends Message> i)` | Adds a single interceptor to the interceptor chain.
    `boolean` | `doIntercept​(Message message)` |
    `boolean` | `doInterceptStartingAfter​(Message message, String startingAfterInterceptorID)` |
    `boolean` | `doInterceptStartingAt​(Message message, String startingAtInterceptorID)` |
    `MessageObserver` | `getFaultObserver()` |
    `ListIterator<Interceptor<? extends Message>>` | `getIterator()` |
    `InterceptorChain.State` | `getState()` |
    `void` | `pause()` | Pauses the current chain.
    `void` | `remove​(Interceptor<? extends Message> i)` |
    `void` | `reset()` |
    `void` | `resume()` | Resumes the chain.
    `void` | `setFaultObserver​(MessageObserver i)` |
    `void` | `suspend()` | Suspends the current chain.
    `void` | `unpause()` | If the chain is marked as paused, this will JUST mark the chain as in the EXECUTING phase.

    - ### Methods inherited from interface java.lang.Iterable

      `forEach, iterator, spliterator`

- - ### Field Detail

    - #### STARTING_AFTER_INTERCEPTOR_ID

          static final String STARTING_AFTER_INTERCEPTOR_ID

      See Also:
        Constant Field Values

    - #### STARTING_AT_INTERCEPTOR_ID

          static final String STARTING_AT_INTERCEPTOR_ID

      See Also:
        Constant Field Values

  - ### Method Detail

    - #### add

          void add​(Interceptor<? extends Message> i)

      Adds a single interceptor to the interceptor chain.
      Parameters:
        `i` - the interceptor to add

    - #### add

          void add​(Collection<Interceptor<? extends Message>> i)

      Adds multiple interceptors to the interceptor chain.
      Parameters:
        `i` - the interceptors to add to the chain

    - #### remove

          void remove​(Interceptor<? extends Message> i)

    - #### doIntercept

          boolean doIntercept​(Message message)

    - #### doInterceptStartingAfter

          boolean doInterceptStartingAfter​(Message message,
                                           String startingAfterInterceptorID)

    - #### doInterceptStartingAt

          boolean doInterceptStartingAt​(Message message,
                                        String startingAtInterceptorID)

    - #### pause

          void pause()

      Pauses the current chain. When the stack unwinds, the chain will just return from the doIntercept method normally.

    - #### suspend

          void suspend()

      Suspends the current chain. When the stack unwinds, the chain back up the iterator by one (so on resume, the interceptor that called pause will be re-entered) and then throw a SuspendedInvocationException to the caller

    - #### resume

          void resume()

      Resumes the chain. The chain will use the current thread to continue processing the last message that was passed into doIntercept

    - #### unpause

          void unpause()

      If the chain is marked as paused, this will JUST mark the chain as in the EXECUTING phase. This is useful if an interceptor pauses the chain, but then immediately decides it should not have done that. It can unpause the chain and return normally and the normal processing will continue.

    - #### reset

          void reset()

    - #### getState

          InterceptorChain.State getState()

    - #### getIterator

          ListIterator<Interceptor<? extends Message>> getIterator()

    - #### getFaultObserver

          MessageObserver getFaultObserver()

    - #### setFaultObserver

          void setFaultObserver​(MessageObserver i)

    - #### abort

          void abort()