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    }