soapservice.java

Java有关XML编程需要用到axis 的源代码 把里面bin下的包导入相应的Java工程 进行使用

/*
 * Copyright 2001-2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.axis.handlers.soap;

import org.apache.axis.AxisEngine;
import org.apache.axis.AxisFault;
import org.apache.axis.Constants;
import org.apache.axis.Handler;
import org.apache.axis.Message;
import org.apache.axis.MessageContext;
import org.apache.axis.SimpleTargetedChain;
import org.apache.axis.attachments.Attachments;
import org.apache.axis.components.logger.LogFactory;
import org.apache.axis.description.JavaServiceDesc;
import org.apache.axis.description.ServiceDesc;
import org.apache.axis.encoding.TypeMappingRegistry;
import org.apache.axis.encoding.TypeMapping;
import org.apache.axis.constants.Style;
import org.apache.axis.constants.Use;
import org.apache.axis.handlers.HandlerChainImpl;
import org.apache.axis.handlers.HandlerInfoChainFactory;
import org.apache.axis.message.SOAPEnvelope;
import org.apache.axis.message.SOAPFault;
import org.apache.axis.providers.BasicProvider;
import org.apache.axis.session.Session;
import org.apache.axis.utils.LockableHashtable;
import org.apache.axis.utils.Messages;
import org.apache.axis.utils.XMLUtils;
import org.apache.axis.utils.ClassUtils;
import org.apache.commons.logging.Log;
import org.w3c.dom.Document;

import javax.xml.rpc.soap.SOAPFaultException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.WeakHashMap;

/** A <code>SOAPService</code> is a Handler which encapsulates a SOAP
 * invocation.  It has an request chain, an response chain, and a pivot-point,
 * and handles the SOAP semantics when invoke()d.
 *
 * @author Glen Daniels ([e-mail])
 * @author Doug Davis ([e-mail])
 */
public class SOAPService extends SimpleTargetedChain
{
    private static Log log =
        LogFactory.getLog(SOAPService.class.getName());

    /** Valid transports for this service
     * (server side only!)
     *
     * !!! For now, if this is null, we assume all
     * transports are valid.
     */
    private Vector validTransports = null;

    /**
     * Does this service require a high-fidelity SAX recording of messages?
     * (default is true)
     */
    private boolean highFidelityRecording = true;

    /**
     * How does this service wish data which would normally be sent as
     * an attachment to be sent?  Default for requests is
     * org.apache.axis.attachments.Attachments.SEND_TYPE_DEFAULT,
     * and the default for responses is to match the request.
     */
    private int sendType = Attachments.SEND_TYPE_NOTSET;

    /**
     * Our ServiceDescription.  Holds pretty much all the interesting
     * metadata about this service.
     */
    private ServiceDesc serviceDescription = new JavaServiceDesc();
    private AxisEngine engine;

    /**
     * A list of our active service objects (these can have lifetimes and
     * be reaped)
     */
    public Map serviceObjects = new HashMap();
    public int nextObjectID = 1;

    /**
     * List of sessions (for all services), key=serviceName, value=Service
     */
    static private Hashtable sessions = new Hashtable();

    private boolean isRunning = true;
    
    /** 
     * Add this passed in Session to this Service's list of sessions
     */
    public void addSession(Session session) {
      WeakHashMap map = (WeakHashMap) sessions.get( this.getName() );
      if ( map == null )  {
        map = new WeakHashMap();
        sessions.put( this.getName(), map);
      }
      if ( !map.containsKey(session) ) map.put(session, null);
    }

    /** 
     * Remove all of this Service's serviceObjects from it known sessions
     */
    public void clearSessions() {
      WeakHashMap map = (WeakHashMap) sessions.get( this.getName() );
      if ( map == null ) return ;
      Iterator iter = map.keySet().iterator();
      while ( iter.hasNext() ) {
        Session session = (Session) iter.next();
        session.remove( this.getName() );
      }
    }

    /**
     * Actor list - these are just the service-specific ones
     */
    ArrayList actors = new ArrayList();

    /**
     * Get the service-specific actor list
     * @return
     */
    public ArrayList getServiceActors() {
        return actors;
    }

    /**
     * Get the merged actor list for this service, including engine-wide
     * actor URIs.
     *
     * @return
     */
    public ArrayList getActors() {
        ArrayList acts = (ArrayList)actors.clone();  // ??? cache this?

        if (engine != null) {
            acts.addAll(engine.getActorURIs());
        }

        return acts;
    }
    
    public List getRoles() {
        return getActors();
    }

    /**
     * Set the service-specific role list
     *
     * @param roles a List of Strings, each containing a role URI
     */
    public void setRoles(List roles) {
        actors = new ArrayList(roles);
    }

    /** Standard, no-arg constructor.
     */
    public SOAPService()
    {
        setOptionsLockable(true);
        initHashtable();

        // For now, always assume we're the ultimate destination.
        actors.add("");
    }

    /** Constructor with real or null request, pivot, and response
     *  handlers. A special request handler is specified to inject
     *  SOAP semantics.
     */
    public SOAPService(Handler reqHandler, Handler pivHandler,
                       Handler respHandler) {
        this();
        init(reqHandler, new MustUnderstandChecker(this), pivHandler, null, respHandler);
    }

    public TypeMappingRegistry getTypeMappingRegistry()
    {
        return serviceDescription.getTypeMappingRegistry();
    }

    /** Convenience constructor for wrapping SOAP semantics around
     * "service handlers" which actually do work.
     */
    public SOAPService(Handler serviceHandler)
    {
        this();
        init(null, new MustUnderstandChecker(this), serviceHandler, null, null);
    }
    
    /** Tell this service which engine it's deployed to.
     *
     */
    public void setEngine(AxisEngine engine)
    {
        if (engine == null)
            throw new IllegalArgumentException(
                    Messages.getMessage("nullEngine"));

        this.engine = engine;
        ((LockableHashtable)options).setParent(engine.getOptions());
        TypeMappingRegistry tmr = engine.getTypeMappingRegistry();
        getTypeMappingRegistry().delegate(tmr);
    }

    public AxisEngine getEngine() {
        return engine;
    }

    public boolean availableFromTransport(String transportName)
    {
        if (validTransports != null) {
            for (int i = 0; i < validTransports.size(); i++) {
                if (validTransports.elementAt(i).equals(transportName))
                    return true;
            }
            return false;
        }