hessian 源代码与jar包

/* * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved. * * The Apache Software License, Version 1.1 * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. The end-user documentation included with the redistribution, if * any, must include the following acknowlegement: * "This product includes software developed by the * Caucho Technology (http://www.caucho.com/)." * Alternately, this acknowlegement may appear in the software itself, * if and wherever such third-party acknowlegements normally appear. * * 4. The names "Hessian", "Resin", and "Caucho" must not be used to * endorse or promote products derived from this software without prior * written permission. For written permission, please contact * info@caucho.com. * * 5. Products derived from this software may not be called "Resin" * nor may "Resin" appear in their names without prior written * permission of Caucho Technology. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL CAUCHO TECHNOLOGY OR ITS CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * @author Scott Ferguson */ package com.caucho.hessian.io; import java.io.*; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.logging.*; /** * Input stream for Hessian requests. * * <p>HessianInput is unbuffered, so any client needs to provide * its own buffering. * * <pre> * InputStream is = ...; // from http connection * HessianInput in = new HessianInput(is); * String value; * * in.startReply(); // read reply header * value = in.readString(); // read string value * in.completeReply(); // read reply footer * </pre> */ public class Hessian2Input extends AbstractHessianInput implements Hessian2Constants { private static final Logger log = Logger.getLogger(Hessian2Input.class.getName()); private static final double D_256 = 1.0 / 256.0; private static final int END_OF_DATA = -2; private static Field _detailMessageField; private static final int SIZE = 256; private static final int GAP = 16; // factory for deserializing objects in the input stream protected SerializerFactory _serializerFactory; private static boolean _isCloseStreamOnClose; protected ArrayList _refs; protected ArrayList _classDefs; protected ArrayList _types; // the underlying input stream private InputStream _is; private final byte []_buffer = new byte[SIZE]; // a peek character private int _offset; private int _length; // true for streaming data private boolean _isStreaming; // the method for a call private String _method; private Reader _chunkReader; private InputStream _chunkInputStream; private Throwable _replyFault; private StringBuffer _sbuf = new StringBuffer(); // true if this is the last chunk private boolean _isLastChunk; // the chunk length private int _chunkLength; /** * Creates a new Hessian input stream, initialized with an * underlying input stream. * * @param is the underlying input stream. */ public Hessian2Input(InputStream is) { _is = is; } /** * Sets the serializer factory. */ public void setSerializerFactory(SerializerFactory factory) { _serializerFactory = factory; } /** * Gets the serializer factory. */ public SerializerFactory getSerializerFactory() { return _serializerFactory; } /** * Gets the serializer factory, creating a default if necessary. */ public final SerializerFactory findSerializerFactory() { SerializerFactory factory = _serializerFactory; if (factory == null) _serializerFactory = factory = new SerializerFactory(); return factory; } public void setCloseStreamOnClose(boolean isClose) { _isCloseStreamOnClose = isClose; } public boolean isCloseStreamOnClose() { return _isCloseStreamOnClose; } /** * Returns the calls method */ public String getMethod() { return _method; } /** * Returns any reply fault. */ public Throwable getReplyFault() { return _replyFault; } /** * Starts reading the call * * <pre> * c major minor * </pre> */ public int readCall() throws IOException { int tag = read(); if (tag != 'c') throw error("expected hessian call ('c') at " + codeName(tag)); int major = read(); int minor = read(); return (major << 16) + minor; } /** * Starts reading the envelope * * <pre> * E major minor * </pre> */ public int readEnvelope() throws IOException { int tag = read(); if (tag != 'E') throw error("expected hessian Envelope ('E') at " + codeName(tag)); int major = read(); int minor = read(); return (major << 16) + minor; } /** * Completes reading the envelope * * <p>A successful completion will have a single value: * * <pre> * z * </pre> */ public void completeEnvelope() throws IOException { int tag = read(); if (tag != 'z') error("expected end of envelope at " + codeName(tag)); } /** * Starts reading the call * * <p>A successful completion will have a single value: * * <pre> * m b16 b8 method * </pre> */ public String readMethod() throws IOException { int tag = read(); if (tag != 'm') throw error("expected hessian method ('m') at " + codeName(tag)); int d1 = read(); int d2 = read(); _isLastChunk = true; _chunkLength = d1 * 256 + d2; _sbuf.setLength(0); int ch; while ((ch = parseChar()) >= 0) _sbuf.append((char) ch); _method = _sbuf.toString(); return _method; } /** * Starts reading the call, including the headers. * * <p>The call expects the following protocol data * * <pre> * c major minor * m b16 b8 method * </pre> */ public void startCall() throws IOException { readCall(); while (readHeader() != null) { readObject(); } readMethod(); } /** * Completes reading the call * * <p>A successful completion will have a single value: * * <pre> * z * </pre> */ public void completeCall() throws IOException { int tag = read(); if (tag == 'z') { } else if (tag < 0) throw error("expected end of call ('z') at end of stream."); else throw error("expected end of call ('z') at " + codeName(tag) + ". Check method arguments and ensure method overloading is enabled if necessary"); } /** * Reads a reply as an object. * If the reply has a fault, throws the exception. */ @Override public Object readReply(Class expectedClass) throws Throwable { int tag = read(); if (tag != 'r') { StringB