handlerpipeline.java

Xfire文件 用于开发web service 的一个开源工具 很好用的

package org.codehaus.xfire.handler;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Stack;

import javax.xml.namespace.QName;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.codehaus.xfire.MessageContext;
import org.codehaus.xfire.fault.XFireFault;

/**
 * @author <a href="mailto:[e-mail]">Dan Diephouse</a>
 */
public class HandlerPipeline
    implements Handler
{
    private static final Log log = LogFactory.getLog(HandlerPipeline.class);
    
    private List phases;
    private Map handlers;
    private boolean paused = false;
    private Phase currentPhase;
    
    // Store this as a variable for performance
    private String INVOKED_INTERCEPTORS = this.toString();
    
    public HandlerPipeline(List phases)
    {
        super();
        
        handlers = new HashMap();

        // Order the phases correctly based on priority
        this.phases = phases;
        
        for (Iterator itr = phases.iterator(); itr.hasNext();)
        {
            Phase phase = (Phase) itr.next();
            
            handlers.put(phase.getName(), new HandlerOrderer());
        }
    }
    
    public void addHandlers(List newhandlers)
    {
        if (newhandlers == null) return;
        
        for (Iterator itr = newhandlers.iterator(); itr.hasNext();)
        {
            Handler handler = (Handler) itr.next();

            addHandler(handler);
        }
    }

    public void addHandler(Handler handler)
    {
        if (log.isDebugEnabled())
            log.debug("adding handler " + handler + " to phase " + handler.getPhase());
        
        HandlerOrderer phaseHandlers = getPhaseHandlers(handler.getPhase());
        
        if (phaseHandlers == null) 
        {
            if (log.isDebugEnabled())
                log.debug("Phase " + handler.getPhase() + " does not exist. Skipping handler " + handler.getClass().getName());
        }
        else
        {
            phaseHandlers.insertHandler(handler);
        }
    }

    public HandlerOrderer getPhaseHandlers(String phase)
    {
        return (HandlerOrderer) handlers.get(phase);
    }
    
    /**
     * Invokes each phase's handler in turn.
     * 
     * @param context The context containing current message 
     *      and this <code>HandlerPipeline</code>.
     * @throws Exception
     */
    public void invoke(MessageContext context)
    	throws Exception
    {
        if (paused) return;
        context.setCurrentPipeline(this);
        Stack invoked = (Stack) context.getProperty(INVOKED_INTERCEPTORS);
        
        if (invoked == null) 
        {
            invoked = new Stack();
            context.setProperty(INVOKED_INTERCEPTORS, invoked);
        }

        for (Iterator itr = phases.iterator(); itr.hasNext();)
        {
            Phase phase = (Phase) itr.next();
            
            // If resuming, won't enter phases already completed
            if (currentPhase != null && phase.compareTo(currentPhase) < 0)
                continue;
  
            currentPhase = phase;
 
            if (log.isDebugEnabled())
                log.debug("Invoking phase " + phase.getName());
            
            List phaseHandlers = getPhaseHandlers(phase.getName()).getHandlers();
            for (int i = 0; i < phaseHandlers.size(); i++ )
            {
                Handler h = (Handler) phaseHandlers.get(i);
                
                //If handler instance has been invoked, continue to next handler
                if (invoked.contains(h))
                    continue;
                
                try
                {
                    if (log.isDebugEnabled())
                        log.debug("Invoking handler " + h.getClass().getName() + 
                                  " in phase " + phase.getName());                    
                    h.invoke(context);
                }
                finally
                {
                    // Add the invoked handler to the stack so we can come
                    // back to it later if a fault occurs.
                    invoked.push(h);
                    if (paused) return;
                }
            }
        }
    }
    
    /**
     * Takes a fault, creates a fault message and sends it via the fault channel.
     * 
     * @param fault
     * @param context
     */
    public void handleFault(XFireFault fault, MessageContext context) 
    {
        Stack invoked = (Stack) context.getProperty(this.toString());

		if ( null != invoked )
		{
			while (invoked.size() > 0)
			{
				Handler h = (Handler) invoked.pop();
				h.handleFault(fault, context);
			}
		}
	}
    
    /**
     * Determines whether or not this Pipeline "understands" a particular header.
     * @param name
     * @return true if pipeline understands a header
     */
    public boolean understands(QName name)
    {
        for (Iterator itr = phases.iterator(); itr.hasNext();)
        {
            Phase phase = (Phase) itr.next();
            
            List phaseHandlers = getPhaseHandlers(phase.getName()).getHandlers();
            for (int i = 0; i < phaseHandlers.size(); i++ )
            {
                Handler h = (Handler) phaseHandlers.get(i);
                QName[] understoodQs = h.getUnderstoodHeaders();

                if (understoodQs != null)
                {
                    for (int j = 0; j < understoodQs.length; j++)
                    {
                        if (understoodQs[j].equals(name))
                            return true;
                    }
                }
            }
        }

        return false;
    }
    
    public void pause() {
        paused = true;
    }
    
    public void resume(MessageContext context) throws Exception {
        if (!paused) return;
        
        paused = false;
        invoke(context);
    }

    public List getAfter()
    {
        return null;
    }

    public List getBefore()
    {
        return null;
    }

    public String getPhase()
    {
        return null;
    }

    public String[] getRoles()
    {
        return null;
    }

    public QName[] getUnderstoodHeaders()
    {
        return null;
    }
    
}