Java ObjectStreamConstants.TC_REFERENCE属性代码示例

/*******************
 * Handle a string element.
 * 
 * @param obj The RMIObject to populate with class names.
 ******************/
private void handleStringElement(LinkedList<Byte> dataStack) throws BaRMIeInvalidReplyDataPacketException {
	//Handle a string based on the type
	switch(dataStack.pop()) {
		//Standard string
		case ObjectStreamConstants.TC_STRING:
			this.extractUtf8(dataStack);
			break;
			
		//Long string
		case ObjectStreamConstants.TC_LONGSTRING:
			this.extractLongUtf8(dataStack);
			break;
			
		//References
		case ObjectStreamConstants.TC_REFERENCE:
			this.extractInt(dataStack);
			break;
			
		//Invalid string type
		default:
			throw new BaRMIeInvalidReplyDataPacketException("Invalid string element type.");
	}
}
 

/*******************
 * Handle a classAnnotation element and return any string annotation
 * elements in the classAnnotation.
 * 
 * @param obj The RMIObject to populate with class names.
 * @param dataStack The remaining data in the ReplyData packet.
 * @return An ArrayList of strings representing any string annotations extracted from the stream.
 ******************/
private ArrayList<String> handleClassAnnotation(RMIObject obj, LinkedList<Byte> dataStack) throws BaRMIeInvalidReplyDataPacketException {
	ArrayList<String> stringAnnotations;
	byte b;
	
	//Create the arraylist
	stringAnnotations = new ArrayList<String>();
	
	//Read elements from the stream until a TC_ENDBLOCKDATA element is read
	while((b = dataStack.pop()) != ObjectStreamConstants.TC_ENDBLOCKDATA) {
		//Handle the annotation
		switch(b) {
			//Read string annotations into an array list to return
			case ObjectStreamConstants.TC_STRING:
				stringAnnotations.add(this.extractUtf8(dataStack));
				break;
				
			//Skip over reference annotations
			case ObjectStreamConstants.TC_REFERENCE:
				//Read past the reference handle
				this.extractInt(dataStack);
				break;
				
			//Ignore null annotations...
			case ObjectStreamConstants.TC_NULL:
				break;
				
			//Unknown annotation type
			default:
				throw new BaRMIeInvalidReplyDataPacketException("Unknown classAnnotation element type (0x" + String.format("%02x", b) + ").");
		}
	}
	
	//Return the string annotations
	return stringAnnotations;
}
 

public static void main(String[] args) {
    byte[] ref = new byte[4];
    ref[0] = ObjectStreamConstants.TC_BASE;
    ref[1] = ObjectStreamConstants.TC_NULL;
    ref[2] = ObjectStreamConstants.TC_REFERENCE;
    ref[3] = ObjectStreamConstants.TC_CLASSDESC;
    int version = ObjectStreamConstants.PROTOCOL_VERSION_1;
}
 

/**
 * <p>
 * Read the next object corresponding to the spec grammar rule "content", and return
 * an object of type content.
 * </p>
 *
 * <p>
 * Usually, there is a 1:1 mapping of content items and returned instances. The
 * one case where this isn't true is when an exception is embedded inside another
 * object. When this is encountered, only the serialized exception object is
 * returned; it's up to the caller to backtrack in order to gather any data from the
 * object that was being serialized when the exception was thrown.
 * </p>
 *
 * @param tc
 *            the last byte read from the stream; it must be one of the TC_* values
 *            within ObjectStreamConstants.*
 * @param dis
 *            the DataInputStream to read from
 * @param blockdata
 *            whether or not to read TC_BLOCKDATA (this is the difference
 *            between spec rules "object" and "content").
 * @return an object representing the last read item from the stream
 * @throws IOException
 *             when a validity or I/O error occurs while reading
 */
public Content read_Content( byte tc, DataInputStream dis, boolean blockdata ) throws IOException
{
	try {
		switch ( tc ) {
			case ObjectStreamConstants.TC_OBJECT:
				return read_newObject( dis );
			case ObjectStreamConstants.TC_CLASS:
				return read_newClass( dis );
			case ObjectStreamConstants.TC_ARRAY:
				return read_newArray( dis );
			case ObjectStreamConstants.TC_STRING:
			case ObjectStreamConstants.TC_LONGSTRING:
				return read_newString( tc, dis );
			case ObjectStreamConstants.TC_ENUM:
				return read_newEnum( dis );
			case ObjectStreamConstants.TC_CLASSDESC:
			case ObjectStreamConstants.TC_PROXYCLASSDESC:
				return handle_newClassDesc( tc, dis );
			case ObjectStreamConstants.TC_REFERENCE:
				return read_prevObject( dis );
			case ObjectStreamConstants.TC_NULL:
				return null;
			case ObjectStreamConstants.TC_EXCEPTION:
				return read_Exception( dis );
			case ObjectStreamConstants.TC_BLOCKDATA:
			case ObjectStreamConstants.TC_BLOCKDATALONG:
				if ( blockdata == false ) {
					throw new IOException( "got a blockdata TC_*, but not allowed here: " + hex( tc ) );
				}
				return read_blockdata( tc, dis );
			default:
				throw new IOException( "unknown content tc byte in stream: " + hex( tc ) );
		}
	}
	catch ( ReadException ere ) {
		return ere.getExceptionObject();
	}
}