001 package org.apache.turbine.util;
002
003
004 /*
005 * Licensed to the Apache Software Foundation (ASF) under one
006 * or more contributor license agreements. See the NOTICE file
007 * distributed with this work for additional information
008 * regarding copyright ownership. The ASF licenses this file
009 * to you under the Apache License, Version 2.0 (the
010 * "License"); you may not use this file except in compliance
011 * with the License. You may obtain a copy of the License at
012 *
013 * http://www.apache.org/licenses/LICENSE-2.0
014 *
015 * Unless required by applicable law or agreed to in writing,
016 * software distributed under the License is distributed on an
017 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
018 * KIND, either express or implied. See the License for the
019 * specific language governing permissions and limitations
020 * under the License.
021 */
022
023
024 import java.io.BufferedInputStream;
025 import java.io.BufferedOutputStream;
026 import java.io.ByteArrayInputStream;
027 import java.io.ByteArrayOutputStream;
028 import java.io.IOException;
029 import java.io.ObjectInputStream;
030 import java.io.ObjectOutputStream;
031 import java.io.Serializable;
032 import java.util.Hashtable;
033 import java.util.Map;
034
035 /**
036 * This is where common Object manipulation routines should go.
037 *
038 * @author <a href="mailto:nissim@nksystems.com">Nissim Karpenstein</a>
039 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
040 * @version $Id: ObjectUtils.java 1073174 2011-02-21 22:18:45Z tv $
041 */
042 public abstract class ObjectUtils
043 {
044 /**
045 * Converts a hashtable to a byte array for storage/serialization.
046 *
047 * @param hash The Hashtable to convert.
048 *
049 * @return A byte[] with the converted Hashtable.
050 *
051 * @exception Exception A generic exception.
052 */
053 public static byte[] serializeHashtable(Hashtable<String, Object> hash)
054 throws Exception
055 {
056 Hashtable<String, Serializable> saveData =
057 new Hashtable<String, Serializable>(hash.size());
058 String key = null;
059 Object value = null;
060 byte[] byteArray = null;
061
062 for (Map.Entry<String, Object> entry : hash.entrySet())
063 {
064 key = entry.getKey();
065 value = entry.getValue();
066 if (value instanceof Serializable)
067 {
068 saveData.put (key, (Serializable)value);
069 }
070 }
071
072 ByteArrayOutputStream baos = null;
073 BufferedOutputStream bos = null;
074 ObjectOutputStream out = null;
075 try
076 {
077 // These objects are closed in the finally.
078 baos = new ByteArrayOutputStream();
079 bos = new BufferedOutputStream(baos);
080 out = new ObjectOutputStream(bos);
081
082 out.writeObject(saveData);
083 out.flush();
084 bos.flush();
085
086 byteArray = baos.toByteArray();
087 }
088 finally
089 {
090 if (out != null)
091 {
092 out.close();
093 }
094 if (bos != null)
095 {
096 bos.close();
097 }
098 if (baos != null)
099 {
100 baos.close();
101 }
102 }
103 return byteArray;
104 }
105
106 /**
107 * Deserializes a single object from an array of bytes.
108 *
109 * @param objectData The serialized object.
110 *
111 * @return The deserialized object, or <code>null</code> on failure.
112 */
113 public static Object deserialize(byte[] objectData)
114 {
115 Object object = null;
116
117 if (objectData != null)
118 {
119 // These streams are closed in finally.
120 ObjectInputStream in = null;
121 ByteArrayInputStream bin = new ByteArrayInputStream(objectData);
122 BufferedInputStream bufin = new BufferedInputStream(bin);
123
124 try
125 {
126 in = new ObjectInputStream(bufin);
127
128 // If objectData has not been initialized, an
129 // exception will occur.
130 object = in.readObject();
131 }
132 catch (Exception e)
133 {
134 // ignore
135 }
136 finally
137 {
138 try
139 {
140 if (in != null)
141 {
142 in.close();
143 }
144
145 bufin.close();
146 bin.close();
147 }
148 catch (IOException e)
149 {
150 // ignore
151 }
152 }
153 }
154 return object;
155 }
156 }