Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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.axis2.context.externalize; import org.apache.axis2.AxisFault; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInput; import java.io.ObjectInputStream; import java.io.ObjectStreamConstants; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; /** * A SafeObjectInputStream reads data that was written by SafeObjectOutputStream * * @see SafeObjectInput */ public class SafeObjectInputStream implements ObjectInput, ObjectStreamConstants { private static final Log log = LogFactory.getLog(SafeObjectInputStream.class); private static final boolean isDebug = log.isDebugEnabled(); // All data is read from the delegated ObjectInput ObjectInput in = null; final ObjectInput original; // A buffer is used when Object is persisted as bytes private byte[] buffer = null; private static final int BUFFER_MIN_SIZE = 4096; /** * Add the SafeObjectInputStream if necessary * @param in * @return */ public static SafeObjectInputStream install(ObjectInput in) { if (in instanceof SafeObjectInputStream) { return (SafeObjectInputStream) in; } return new SafeObjectInputStream(in); } /** * Intentionally private. Callers should use the install method to add the SafeObjectInputStream * into the stream. * @param in */ private SafeObjectInputStream(ObjectInput in) { original = in; if (log.isDebugEnabled()) { this.in = new DebugObjectInput(original); } else { this.in = original; } } // Delegated Methods public int available() throws IOException { return in.available(); } public void close() throws IOException { in.close(); } public int read() throws IOException { return in.read(); } public int read(byte[] b, int off, int len) throws IOException { return in.read(b, off, len); } public int read(byte[] b) throws IOException { return in.read(b); } public boolean readBoolean() throws IOException { return in.readBoolean(); } public byte readByte() throws IOException { return in.readByte(); } public char readChar() throws IOException { return in.readChar(); } public double readDouble() throws IOException { return in.readDouble(); } public float readFloat() throws IOException { return in.readFloat(); } public void readFully(byte[] b, int off, int len) throws IOException { in.readFully(b, off, len); } public void readFully(byte[] b) throws IOException { in.readFully(b); } public int readInt() throws IOException { return in.readInt(); } public String readLine() throws IOException { return in.readLine(); } public long readLong() throws IOException { return in.readLong(); } public Object readObject() throws ClassNotFoundException, IOException { return readObjectOverride(); } public short readShort() throws IOException { return in.readShort(); } public int readUnsignedByte() throws IOException { return in.readUnsignedByte(); } public int readUnsignedShort() throws IOException { return in.readUnsignedShort(); } public String readUTF() throws IOException { return in.readUTF(); } public long skip(long n) throws IOException { return in.skip(n); } public int skipBytes(int n) throws IOException { return in.skipBytes(n); } // Value Add Methods /** * Read the input stream and place the key/value pairs in a hashmap * @return HashMap or null * @throws IOException * @see SafeObjectOutputStream.writeMap() */ public HashMap readHashMap() throws IOException { HashMap hashMap = new HashMap(); return (HashMap) readMap(hashMap); } /** * Read the input stream and place the key/value pairs in the * indicated Map * @param map input map * @return map or null * @throws IOException * @see SafeObjectOutputStream.writeMap() */ public Map readMap(Map map) throws IOException { boolean isActive = in.readBoolean(); if (!isActive) { return null; } while (in.readBoolean()) { Object key = null; Object value = null; boolean isObjectForm = in.readBoolean(); try { if (isObjectForm) { if (isDebug) { log.debug(" reading using object form"); } // Read the key and value directly key = in.readObject(); value = in.readObject(); } else { if (isDebug) { log.debug(" reading using byte form"); } // Get the byte stream ByteArrayInputStream bais = getByteStream(in); // Now get the real key and value ObjectInputStream tempOIS = createObjectInputStream(bais); key = tempOIS.readObject(); value = tempOIS.readObject(); tempOIS.close(); bais.close(); } // Put the key and value in the map if (isDebug) { log.debug("Read key=" + valueName(key) + " value=" + valueName(value)); } map.put(key, value); } catch (ClassNotFoundException e) { // Swallow the error and try to continue log.error(e); } catch (IOException e) { throw e; } catch (Exception e) { throw AxisFault.makeFault(e); } } return map; } /** * Read the input stream and place objects in an ArrayList * @return ArrayList or null * @throws IOException * @see SafeObjectInputStream.writeList() */ public ArrayList readArrayList() throws IOException { List ll = new ArrayList(); return (ArrayList) readList(ll); } /** * Read the input stream and place objects in a LinkedList * @return LinkedList or null * @throws IOException * @see SafeObjectInputStream.writeList() */ public LinkedList readLinkedList() throws IOException { List ll = new LinkedList(); return (LinkedList) readList(ll); } /** * Read hte input stream and place objects in the specified List * @param list List * @return List or null * @throws IOException * @see SafeObjectInputStream.writeList() */ public List readList(List list) throws IOException { boolean isActive = in.readBoolean(); if (!isActive) { return null; } while (in.readBoolean()) { Object value; boolean isObjectForm = in.readBoolean(); try { if (isObjectForm) { if (isDebug) { log.debug(" reading using object form"); } // Read the value directly value = in.readObject(); } else { if (isDebug) { log.debug(" reading using byte form"); } // Get the byte stream ByteArrayInputStream bais = getByteStream(in); // Now get the real key and value ObjectInputStream tempOIS = createObjectInputStream(bais); value = tempOIS.readObject(); tempOIS.close(); bais.close(); } // Put the key and value in the list if (isDebug) { log.debug("Read value=" + valueName(value)); } list.add(value); } catch (IOException e) { throw e; } catch (Exception e) { throw AxisFault.makeFault(e); } } return list; } /** * Reads the object using the same format that was written. * * EXPECTED FORMATS * boolean=false * return null Object * * * boolean=true * boolean=true * return Object read from inputStream * * * boolean=true * boolean=false * int=nuber of bytes * bytes * return Object read from bytes * * @return Object or null * @throws IOException * @throws ClassNotFoundException */ private Object readObjectOverride() throws IOException, ClassNotFoundException { boolean isActive = in.readBoolean(); if (!isActive) { if (isDebug) { log.debug("Read object=null"); } return null; } Object obj = null; boolean isObjectForm = in.readBoolean(); if (isObjectForm) { // Read the object directly if (isDebug) { log.debug(" reading using object form"); } obj = in.readObject(); } else { if (isDebug) { log.debug(" reading using byte form"); } // Get the byte stream ByteArrayInputStream bais = getByteStream(in); // Now get the real object ObjectInputStream tempOIS = createObjectInputStream(bais); obj = tempOIS.readObject(); tempOIS.close(); bais.close(); } if (isDebug) { log.debug("Read object=" + valueName(obj)); } return obj; } private String valueName(Object obj) { if (obj == null) { return "null"; } else if (obj instanceof String) { return (String) obj; } else { return "Object of class = " + obj.getClass().getName(); } } /** * Get the byte stream for an object that is written using the * byte format. * EXPECTED format * int (number of bytes) * bytes * * @param in * @return * @throws IOException * @throws ClassNotFoundException */ private ByteArrayInputStream getByteStream(ObjectInput in) throws IOException, ClassNotFoundException { // Read the length int size = in.readInt(); // Fill our temporary buffer if (buffer == null || buffer.length < size) { int allocSize = (size > BUFFER_MIN_SIZE) ? size : BUFFER_MIN_SIZE; buffer = new byte[allocSize]; } in.readFully(buffer, 0, size); // Return a stream backed by the buffer return new ByteArrayInputStream(buffer, 0, size); } private ObjectInputStream createObjectInputStream(InputStream is) throws IOException { // The created ObjectInputStream must use the same class/object resolution // code that is used by the original ObjectInput return new ObjectInputStreamWithCL(is); } }