Package org.apache.axis

Class FaultableHandler

java.lang.Object
org.apache.axis.handlers.BasicHandler
org.apache.axis.FaultableHandler
All Implemented Interfaces:
Serializable, Handler
public class FaultableHandler extends BasicHandler
A FaultableHandler is essentially a wrapper for any other Handler which provides flexible fault handling semantics.
Author:
Doug Davis (dug@us.ibm.com), Glen Daniels (gdaniels@apache.org)
See Also:

  • Field Details

    • log

      protected static org.apache.commons.logging.Log log
      The Log used to log all events that would be of general interest.

    • entLog

      protected static org.apache.commons.logging.Log entLog
      The Log used for enterprise-centric logging. The enterprise category is for stuff that an enterprise product might want to track, but in a simple environment (like the AXIS build) would be nothing more than a nuisance.

    • workHandler

      protected Handler workHandler
      The Handler that will do the actual work of handeling the fault.

  • Constructor Details

    • FaultableHandler

      public FaultableHandler(Handler workHandler)
      Create a new FaultHandler.
      Parameters:
      workHandler - the Handler we're going to wrap with Fault semantics.

  • Method Details

    • init

      public void init()
      Description copied from class: BasicHandler
      Stubbed-out methods. Override in your child class to implement any real behavior. Note that there is NOT a stub for invoke(), since we require any Handler derivative to implement that.
      Specified by:
      init in interface Handler
      Overrides:
      init in class BasicHandler

    • cleanup

      public void cleanup()
      Description copied from interface: Handler
      Cleanup is called when the chain containing this Handler object is done processing the chain.
      Specified by:
      cleanup in interface Handler
      Overrides:
      cleanup in class BasicHandler

    • invoke

      public void invoke(MessageContext msgContext) throws AxisFault
      Invokes the specified handler. If there's a fault the appropriate key will be calculated and used to find the fault chain to be invoked. This assumes that the workHandler has caught the exception and already done its fault processing - as needed.
      Parameters:
      msgContext - the MessageContext to process
      Throws:
      AxisFault - if anything goes terminally wrong

    • onFault

      public void onFault(MessageContext msgContext)
      Some handler later on has faulted so we need to process the fault.
      Specified by:
      onFault in interface Handler
      Overrides:
      onFault in class BasicHandler
      Parameters:
      msgContext - the context to process

    • canHandleBlock

      public boolean canHandleBlock(QName qname)
      Description copied from interface: Handler
      Indicate if this handler can process qname.
      Specified by:
      canHandleBlock in interface Handler
      Overrides:
      canHandleBlock in class BasicHandler
      Parameters:
      qname - the QName to check
      Returns:
      true if this Handler can handle qname, false otherwise