    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    }