1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package com.foxinmy.weixin4j.util;
18
19 import java.io.ByteArrayInputStream;
20 import java.io.ByteArrayOutputStream;
21 import java.io.IOException;
22 import java.io.InputStream;
23 import java.io.ObjectInputStream;
24 import java.io.ObjectOutputStream;
25 import java.io.ObjectStreamClass;
26 import java.io.OutputStream;
27 import java.io.Serializable;
28 import java.util.HashMap;
29 import java.util.Map;
30
31 /**
32 * <p>Assists with the serialization process and performs additional functionality based
33 * on serialization.</p>
34 *
35 * <ul>
36 * <li>Deep clone using serialization
37 * <li>Serialize managing finally and IOException
38 * <li>Deserialize managing finally and IOException
39 * </ul>
40 *
41 * <p>This class throws exceptions for invalid {@code null} inputs.
42 * Each method documents its behaviour in more detail.</p>
43 *
44 * <p>#ThreadSafe#</p>
45 * @since 1.0
46 * @version $Id: SerializationUtils.java 1583482 2014-03-31 22:54:57Z niallp $
47 */
48 public class SerializationUtils {
49
50 /**
51 * <p>SerializationUtils instances should NOT be constructed in standard programming.
52 * Instead, the class should be used as {@code SerializationUtils.clone(object)}.</p>
53 *
54 * <p>This constructor is public to permit tools that require a JavaBean instance
55 * to operate.</p>
56 * @since 2.0
57 */
58 public SerializationUtils() {
59 super();
60 }
61
62 // Clone
63 //-----------------------------------------------------------------------
64 /**
65 * <p>Deep clone an {@code Object} using serialization.</p>
66 *
67 * <p>This is many times slower than writing clone methods by hand
68 * on all objects in your object graph. However, for complex object
69 * graphs, or for those that don't support deep cloning this can
70 * be a simple alternative implementation. Of course all the objects
71 * must be {@code Serializable}.</p>
72 *
73 * @param <T> the type of the object involved
74 * @param object the {@code Serializable} object to clone
75 * @return the cloned object
76 * @throws SerializationException (runtime) if the serialization fails
77 */
78 public static <T extends Serializable> T clone(final T object) {
79 if (object == null) {
80 return null;
81 }
82 final byte[] objectData = serialize(object);
83 final ByteArrayInputStream bais = new ByteArrayInputStream(objectData);
84
85 ClassLoaderAwareObjectInputStream in = null;
86 try {
87 // stream closed in the finally
88 in = new ClassLoaderAwareObjectInputStream(bais, object.getClass().getClassLoader());
89 /*
90 * when we serialize and deserialize an object,
91 * it is reasonable to assume the deserialized object
92 * is of the same type as the original serialized object
93 */
94 @SuppressWarnings("unchecked") // see above
95 final
96 T readObject = (T) in.readObject();
97 return readObject;
98
99 } catch (final ClassNotFoundException ex) {
100 throw new RuntimeException("ClassNotFoundException while reading cloned object data", ex);
101 } catch (final IOException ex) {
102 throw new RuntimeException("IOException while reading cloned object data", ex);
103 } finally {
104 try {
105 if (in != null) {
106 in.close();
107 }
108 } catch (final IOException ex) {
109 throw new RuntimeException("IOException on closing cloned object data InputStream.", ex);
110 }
111 }
112 }
113
114 /**
115 * Performs a serialization roundtrip. Serializes and deserializes the given object, great for testing objects that
116 * implement {@link Serializable}.
117 *
118 * @param <T>
119 * the type of the object involved
120 * @param msg
121 * the object to roundtrip
122 * @return the serialized and deseralized object
123 * @since 3.3
124 */
125 public static <T extends Serializable> T roundtrip(final T msg) {
126 return SerializationUtils.deserialize(SerializationUtils.serialize(msg));
127 }
128
129 // Serialize
130 //-----------------------------------------------------------------------
131 /**
132 * <p>Serializes an {@code Object} to the specified stream.</p>
133 *
134 * <p>The stream will be closed once the object is written.
135 * This avoids the need for a finally clause, and maybe also exception
136 * handling, in the application code.</p>
137 *
138 * <p>The stream passed in is not buffered internally within this method.
139 * This is the responsibility of your application if desired.</p>
140 *
141 * @param obj the object to serialize to bytes, may be null
142 * @param outputStream the stream to write to, must not be null
143 * @throws IllegalArgumentException if {@code outputStream} is {@code null}
144 * @throws SerializationException (runtime) if the serialization fails
145 */
146 public static void serialize(final Serializable obj, final OutputStream outputStream) {
147 if (outputStream == null) {
148 throw new IllegalArgumentException("The OutputStream must not be null");
149 }
150 ObjectOutputStream out = null;
151 try {
152 // stream closed in the finally
153 out = new ObjectOutputStream(outputStream);
154 out.writeObject(obj);
155
156 } catch (final IOException ex) {
157 throw new RuntimeException(ex);
158 } finally {
159 try {
160 if (out != null) {
161 out.close();
162 }
163 } catch (final IOException ex) { // NOPMD
164 // ignore close exception
165 }
166 }
167 }
168
169 /**
170 * <p>Serializes an {@code Object} to a byte array for
171 * storage/serialization.</p>
172 *
173 * @param obj the object to serialize to bytes
174 * @return a byte[] with the converted Serializable
175 * @throws SerializationException (runtime) if the serialization fails
176 */
177 public static byte[] serialize(final Serializable obj) {
178 final ByteArrayOutputStream baos = new ByteArrayOutputStream(512);
179 serialize(obj, baos);
180 return baos.toByteArray();
181 }
182
183 // Deserialize
184 //-----------------------------------------------------------------------
185 /**
186 * <p>
187 * Deserializes an {@code Object} from the specified stream.
188 * </p>
189 *
190 * <p>
191 * The stream will be closed once the object is written. This avoids the need for a finally clause, and maybe also
192 * exception handling, in the application code.
193 * </p>
194 *
195 * <p>
196 * The stream passed in is not buffered internally within this method. This is the responsibility of your
197 * application if desired.
198 * </p>
199 *
200 * <p>
201 * If the call site incorrectly types the return value, a {@link ClassCastException} is thrown from the call site.
202 * Without Generics in this declaration, the call site must type cast and can cause the same ClassCastException.
203 * Note that in both cases, the ClassCastException is in the call site, not in this method.
204 * </p>
205 *
206 * @param <T> the object type to be deserialized
207 * @param inputStream
208 * the serialized object input stream, must not be null
209 * @return the deserialized object
210 * @throws IllegalArgumentException
211 * if {@code inputStream} is {@code null}
212 * @throws SerializationException
213 * (runtime) if the serialization fails
214 */
215 public static <T> T deserialize(final InputStream inputStream) {
216 if (inputStream == null) {
217 throw new IllegalArgumentException("The InputStream must not be null");
218 }
219 ObjectInputStream in = null;
220 try {
221 // stream closed in the finally
222 in = new ObjectInputStream(inputStream);
223 @SuppressWarnings("unchecked") // may fail with CCE if serialised form is incorrect
224 final T obj = (T) in.readObject();
225 return obj;
226
227 } catch (final ClassCastException ex) {
228 throw new RuntimeException(ex);
229 } catch (final ClassNotFoundException ex) {
230 throw new RuntimeException(ex);
231 } catch (final IOException ex) {
232 throw new RuntimeException(ex);
233 } finally {
234 try {
235 if (in != null) {
236 in.close();
237 }
238 } catch (final IOException ex) { // NOPMD
239 // ignore close exception
240 }
241 }
242 }
243
244 /**
245 * <p>
246 * Deserializes a single {@code Object} from an array of bytes.
247 * </p>
248 *
249 * <p>
250 * If the call site incorrectly types the return value, a {@link ClassCastException} is thrown from the call site.
251 * Without Generics in this declaration, the call site must type cast and can cause the same ClassCastException.
252 * Note that in both cases, the ClassCastException is in the call site, not in this method.
253 * </p>
254 *
255 * @param <T> the object type to be deserialized
256 * @param objectData
257 * the serialized object, must not be null
258 * @return the deserialized object
259 * @throws IllegalArgumentException
260 * if {@code objectData} is {@code null}
261 * @throws SerializationException
262 * (runtime) if the serialization fails
263 */
264 public static <T> T deserialize(final byte[] objectData) {
265 if (objectData == null) {
266 throw new IllegalArgumentException("The byte[] must not be null");
267 }
268 return SerializationUtils.<T>deserialize(new ByteArrayInputStream(objectData));
269 }
270
271 /**
272 * <p>Custom specialization of the standard JDK {@link java.io.ObjectInputStream}
273 * that uses a custom <code>ClassLoader</code> to resolve a class.
274 * If the specified <code>ClassLoader</code> is not able to resolve the class,
275 * the context classloader of the current thread will be used.
276 * This way, the standard deserialization work also in web-application
277 * containers and application servers, no matter in which of the
278 * <code>ClassLoader</code> the particular class that encapsulates
279 * serialization/deserialization lives. </p>
280 *
281 * <p>For more in-depth information about the problem for which this
282 * class here is a workaround, see the JIRA issue LANG-626. </p>
283 */
284 static class ClassLoaderAwareObjectInputStream extends ObjectInputStream {
285 private static final Map<String, Class<?>> primitiveTypes =
286 new HashMap<String, Class<?>>();
287 private final ClassLoader classLoader;
288
289 /**
290 * Constructor.
291 * @param in The <code>InputStream</code>.
292 * @param classLoader classloader to use
293 * @throws IOException if an I/O error occurs while reading stream header.
294 * @see java.io.ObjectInputStream
295 */
296 public ClassLoaderAwareObjectInputStream(final InputStream in, final ClassLoader classLoader) throws IOException {
297 super(in);
298 this.classLoader = classLoader;
299
300 primitiveTypes.put("byte", byte.class);
301 primitiveTypes.put("short", short.class);
302 primitiveTypes.put("int", int.class);
303 primitiveTypes.put("long", long.class);
304 primitiveTypes.put("float", float.class);
305 primitiveTypes.put("double", double.class);
306 primitiveTypes.put("boolean", boolean.class);
307 primitiveTypes.put("char", char.class);
308 primitiveTypes.put("void", void.class);
309 }
310
311 /**
312 * Overriden version that uses the parametrized <code>ClassLoader</code> or the <code>ClassLoader</code>
313 * of the current <code>Thread</code> to resolve the class.
314 * @param desc An instance of class <code>ObjectStreamClass</code>.
315 * @return A <code>Class</code> object corresponding to <code>desc</code>.
316 * @throws IOException Any of the usual Input/Output exceptions.
317 * @throws ClassNotFoundException If class of a serialized object cannot be found.
318 */
319 @Override
320 protected Class<?> resolveClass(final ObjectStreamClass desc) throws IOException, ClassNotFoundException {
321 final String name = desc.getName();
322 try {
323 return Class.forName(name, false, classLoader);
324 } catch (final ClassNotFoundException ex) {
325 try {
326 return Class.forName(name, false, Thread.currentThread().getContextClassLoader());
327 } catch (final ClassNotFoundException cnfe) {
328 final Class<?> cls = primitiveTypes.get(name);
329 if (cls != null) {
330 return cls;
331 } else {
332 throw cnfe;
333 }
334 }
335 }
336 }
337
338 }
339 }