xmlrpcworker.java

xmlrpc-2.0-src.zip java程序

/*
 * Copyright 1999,2005 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.xmlrpc;

import java.io.InputStream;

/**
 * Tie together the XmlRequestProcessor and XmlResponseProcessor to handle
 * a request serially in a single thread.
 *
 * @author <a href="mailto:[e-mail]">Hannes Wallnoefer</a>
 * @author Daniel L. Rall
 * @author <a href="mailto:[e-mail]">Andrew Evers</a>
 * @see org.apache.xmlrpc.XmlRpcServer
 * @since 1.2
 */
public class XmlRpcWorker
{
    protected XmlRpcRequestProcessor requestProcessor;
    protected XmlRpcResponseProcessor responseProcessor;
    protected XmlRpcHandlerMapping handlerMapping;

    /**
     * Create a new instance that will use the specified mapping.
     */
    public XmlRpcWorker(XmlRpcHandlerMapping handlerMapping)
    {
      requestProcessor = new XmlRpcRequestProcessor();
      responseProcessor = new XmlRpcResponseProcessor();
      this.handlerMapping = handlerMapping;
    }

    /**
     * Pass the specified request to the handler. The handler should be an
     * instance of {@link org.apache.xmlrpc.XmlRpcHandler} or
     * {@link org.apache.xmlrpc.AuthenticatedXmlRpcHandler}.
     *
     * @param handler the handler to call.
     * @param request the request information to use.
     * @param context the context information to use.
     * @return Object the result of calling the handler.
     * @throws ClassCastException if the handler is not of an appropriate type.
     * @throws NullPointerException if the handler is null.
     * @throws Exception if the handler throws an exception.
     */
    protected static Object invokeHandler(Object handler, XmlRpcServerRequest request, XmlRpcContext context)
        throws Exception
    {
        long now = 0;

        try
        {
            if (XmlRpc.debug)
            {
                now = System.currentTimeMillis();
            }
            if (handler == null)
            {
              throw new NullPointerException
                  ("Null handler passed to XmlRpcWorker.invokeHandler");
            }
            else if (handler instanceof ContextXmlRpcHandler)
            {
                return ((ContextXmlRpcHandler) handler).execute
                    (request.getMethodName(), request.getParameters(), context);
            }
            else if (handler instanceof XmlRpcHandler)
            {
                return ((XmlRpcHandler) handler).execute
                    (request.getMethodName(), request.getParameters());
            }
            else if (handler instanceof AuthenticatedXmlRpcHandler)
            {
                return ((AuthenticatedXmlRpcHandler) handler)
                    .execute(request.getMethodName(), request.getParameters(),
                             context.getUserName(), context.getPassword());
            }
            else
            {
               throw new ClassCastException("Handler class " +
                                            handler.getClass().getName() +
                                            " is not a valid XML-RPC handler");
            }
        }
        finally
        {
            if (XmlRpc.debug)
            {
                 System.out.println("Spent " + (System.currentTimeMillis() - now)
                         + " millis processing request");
            }
        }
    }

    /**
     * Decode, process and encode the response or exception for an XML-RPC
     * request. This method executes the handler method with the default context.
     */
    public byte[] execute(InputStream is, String user, String password)
    {
        return execute(is, defaultContext(user, password));
    }

    /**
     * Decode, process and encode the response or exception for an XML-RPC
     * request. This method executes will pass the specified context to the
     * handler if the handler supports context.
     *
     * @param is the InputStream to read the request from.
     * @param context the context for the request (may be null).
     * @return byte[] the response.
     * @throws org.apache.xmlrpc.ParseFailed if the request could not be parsed.
     * @throws org.apache.xmlrpc.AuthenticationFailed if the handler for the
     * specific method required authentication and insufficient credentials were
     * supplied.
     */
    public byte[] execute(InputStream is, XmlRpcContext context)
    {
        long now = 0;

        if (XmlRpc.debug)
        {
            now = System.currentTimeMillis();
        }

        try
        {
            XmlRpcServerRequest request = requestProcessor.decodeRequest(is);
            Object handler = handlerMapping.getHandler(request.
                                                       getMethodName());
            Object response = invokeHandler(handler, request, context);
            return responseProcessor.encodeResponse
                (response, requestProcessor.getEncoding());
        }
        catch (AuthenticationFailed alertCallerAuth)
        {
            throw alertCallerAuth;
        }
        catch (ParseFailed alertCallerParse)
        {
            throw alertCallerParse;
        }
        catch (Exception x)
        {
            if (XmlRpc.debug)
            {
                x.printStackTrace();
            }
            return responseProcessor.encodeException
                (x, requestProcessor.getEncoding());
        }
        finally
        {
            if (XmlRpc.debug)
            {
                System.out.println("Spent " + (System.currentTimeMillis() - now)
                                   + " millis in request/process/response");
            }
        }
    }

    /**
     * Factory method to return a default context object for the execute() method.
     * This method can be overridden to return a custom sub-class of XmlRpcContext.
     *
     * @param user the username of the user making the request.
     * @param password the password of the user making the request.
     * @return XmlRpcContext the context for the reqeust.
     */
    protected XmlRpcContext defaultContext(String user, String password)
    {
        return new DefaultXmlRpcContext(user, password, handlerMapping);
    }
}