Package org.apache.axis

Class FaultableHandler

  • All Implemented Interfaces:
    java.io.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:
    Serialized Form

    • Field Detail

      • 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 Detail

      • FaultableHandler

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

    • Method Detail

      • 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