17023139374

Committed 17 Aug 2025 09:39AM UTC coverage: 44.094% (-0.08%) from 44.169%

Build # 17023139374

Build Type

push

github

Committed by

wuwen5

Commit Message

refactor: code clean,fix sonar check

Run Details

1203 of 2989 branches covered (40.25%)

Branch coverage included in aggregate %.

2903 of 6323 relevant lines covered (45.91%)

1.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

3.05

hessian2-codec/src/main/java/io/github/wuwen5/hessian/io/FieldDeserializer2Factory.java

/*
 * Copyright (c) 2001-2008 Caucho Technology, Inc.  All rights reserved.
 *
 * The Apache Software License, Version 1.1
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution, if
 *    any, must include the following acknowlegement:
 *       "This product includes software developed by the
 *        Caucho Technology (http://www.caucho.com/)."
 *    Alternately, this acknowlegement may appear in the software itself,
 *    if and wherever such third-party acknowlegements normally appear.
 *
 * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
 *    endorse or promote products derived from this software without prior
 *    written permission. For written permission, please contact
 *    info@caucho.com.
 *
 * 5. Products derived from this software may not be called "Resin"
 *    nor may "Resin" appear in their names without prior written
 *    permission of Caucho Technology.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL CAUCHO TECHNOLOGY OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * @author Scott Ferguson
 */

package io.github.wuwen5.hessian.io;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import lombok.extern.slf4j.Slf4j;

/**
 * Serializing an object for known object types.
 */
@Slf4j
public class FieldDeserializer2Factory {
    public static FieldDeserializer2Factory create() {
        boolean isEnableUnsafeSerializer = (UnsafeSerializer.isEnabled() && UnsafeDeserializer.isEnabled());

        if (isEnableUnsafeSerializer) {
            return new FieldDeserializer2FactoryUnsafe();
        } else {
            return new FieldDeserializer2Factory();
        }
    }

    /**
     * Creates a map of the classes fields.
     */
    FieldDeserializer2 create(Field field) {
        if (Modifier.isTransient(field.getModifiers()) || Modifier.isStatic(field.getModifiers())) {
            return NullFieldDeserializer.DESER;
        }

        // XXX: could parameterize the handler to only deal with public
        try {
            field.setAccessible(true);
        } catch (Throwable e) {
            log.trace("Unable to set field to accessible", e);
        }

        Class<?> type = field.getType();
        FieldDeserializer2 deser;

        if (String.class.equals(type)) {
            deser = new StringFieldDeserializer(field);
        } else if (byte.class.equals(type)) {
            deser = new ByteFieldDeserializer(field);
        } else if (short.class.equals(type)) {
            deser = new ShortFieldDeserializer(field);
        } else if (int.class.equals(type)) {
            deser = new IntFieldDeserializer(field);
        } else if (long.class.equals(type)) {
            deser = new LongFieldDeserializer(field);
        } else if (float.class.equals(type)) {
            deser = new FloatFieldDeserializer(field);
        } else if (double.class.equals(type)) {
            deser = new DoubleFieldDeserializer(field);
        } else if (boolean.class.equals(type)) {
            deser = new BooleanFieldDeserializer(field);
        } else if (java.sql.Date.class.equals(type)) {
            deser = new SqlDateFieldDeserializer(field);
        } else if (java.sql.Timestamp.class.equals(type)) {
            deser = new SqlTimestampFieldDeserializer(field);
        } else if (java.sql.Time.class.equals(type)) {
            deser = new SqlTimeFieldDeserializer(field);
        } else {
            deser = new ObjectFieldDeserializer(field);
        }

        return deser;
    }

    /**
     * Creates a map of the classes fields.
     */
    protected static Object getParamArg(Class<?> cl) {
        if (!cl.isPrimitive()) {
            return null;
        } else if (boolean.class.equals(cl)) {
            return Boolean.FALSE;
        } else if (byte.class.equals(cl)) {
            return new Byte((byte) 0);
        } else if (short.class.equals(cl)) {
            return new Short((short) 0);
        } else if (char.class.equals(cl)) {
            return new Character((char) 0);
        } else if (int.class.equals(cl)) {
            return Integer.valueOf(0);
        } else if (long.class.equals(cl)) {
            return Long.valueOf(0);
        } else if (float.class.equals(cl)) {
            return Float.valueOf(0);
        } else if (double.class.equals(cl)) {
            return Double.valueOf(0);
        } else {
            throw new UnsupportedOperationException();
        }
    }

    static class NullFieldDeserializer implements FieldDeserializer2 {
        static NullFieldDeserializer DESER = new NullFieldDeserializer();

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            in.readObject();
        }
    }

    static class ObjectFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        ObjectFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            Object value = null;

            try {
                value = in.readObject(field.getType());

                field.set(obj, value);
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class BooleanFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        BooleanFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            boolean value = false;

            try {
                value = in.readBoolean();

                field.setBoolean(obj, value);
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class ByteFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        ByteFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            int value = 0;

            try {
                value = in.readInt();

                field.setByte(obj, (byte) value);
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class ShortFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        ShortFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            int value = 0;

            try {
                value = in.readInt();

                field.setShort(obj, (short) value);
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class IntFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        IntFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            int value = 0;

            try {
                value = in.readInt();

                field.setInt(obj, value);
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class LongFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        LongFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            long value = 0;

            try {
                value = in.readLong();

                field.setLong(obj, value);
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class FloatFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        FloatFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            double value = 0;

            try {
                value = in.readDouble();

                field.setFloat(obj, (float) value);
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class DoubleFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        DoubleFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            double value = 0;

            try {
                value = in.readDouble();

                field.setDouble(obj, value);
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class StringFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        StringFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            String value = null;

            try {
                value = in.readString();

                field.set(obj, value);
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class SqlDateFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        SqlDateFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            java.sql.Date value = null;

            try {
                java.util.Date date = (java.util.Date) in.readObject();

                if (date != null) {
                    value = new java.sql.Date(date.getTime());

                    field.set(obj, value);
                } else {
                    field.set(obj, null);
                }
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class SqlTimestampFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        SqlTimestampFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            java.sql.Timestamp value = null;

            try {
                java.util.Date date = (java.util.Date) in.readObject();

                if (date != null) {
                    value = new java.sql.Timestamp(date.getTime());

                    field.set(obj, value);
                } else {
                    field.set(obj, null);
                }
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static class SqlTimeFieldDeserializer implements FieldDeserializer2 {
        private final Field field;

        SqlTimeFieldDeserializer(Field field) {
            this.field = field;
        }

        @Override
        public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
            java.sql.Time value = null;

            try {
                java.util.Date date = (java.util.Date) in.readObject();

                if (date != null) {
                    value = new java.sql.Time(date.getTime());

                    field.set(obj, value);
                } else {
                    field.set(obj, null);
                }
            } catch (Exception e) {
                logDeserializeError(field, obj, value, e);
            }
        }
    }

    static void logDeserializeError(Field field, Object obj, Object value, Throwable e) throws IOException {
        String fieldName = (field.getDeclaringClass().getName() + "." + field.getName());

        if (e instanceof HessianFieldException) {
            throw (HessianFieldException) e;
        } else if (e instanceof IOException) {
            throw new HessianFieldException(fieldName + ": " + e.getMessage(), e);
        }

        if (value != null) {
            throw new HessianFieldException(
                    fieldName + ": " + value.getClass().getName() + " (" + value + ")" + " cannot be assigned to '"
                            + field.getType().getName() + "'",
                    e);
        } else {
            throw new HessianFieldException(
                    fieldName + ": " + field.getType().getName() + " cannot be assigned from null", e);
        }
    }
}

1	/*
2	* Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
3	*
4	* The Apache Software License, Version 1.1
5	*
6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions
8	* are met:
9	*
10	* 1. Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.
12	*
13	* 2. Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in
15	* the documentation and/or other materials provided with the
16	* distribution.
17	*
18	* 3. The end-user documentation included with the redistribution, if
19	* any, must include the following acknowlegement:
20	* "This product includes software developed by the
21	* Caucho Technology (http://www.caucho.com/)."
22	* Alternately, this acknowlegement may appear in the software itself,
23	* if and wherever such third-party acknowlegements normally appear.
24	*
25	* 4. The names "Burlap", "Resin", and "Caucho" must not be used to
26	* endorse or promote products derived from this software without prior
27	* written permission. For written permission, please contact
28	* info@caucho.com.
29	*
30	* 5. Products derived from this software may not be called "Resin"
31	* nor may "Resin" appear in their names without prior written
32	* permission of Caucho Technology.
33	*
34	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
35	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
36	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
37	* DISCLAIMED. IN NO EVENT SHALL CAUCHO TECHNOLOGY OR ITS CONTRIBUTORS
38	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
39	* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
40	* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
41	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
42	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
43	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
44	* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45	*
46	* @author Scott Ferguson
47	*/
48
49	package io.github.wuwen5.hessian.io;
50
51	import java.io.IOException;
52	import java.lang.reflect.Field;
53	import java.lang.reflect.Modifier;
54	import lombok.extern.slf4j.Slf4j;
55
56	/**
57	* Serializing an object for known object types.
58	*/
59	@Slf4j	4✔
60	public class FieldDeserializer2Factory {	3✔
61	public static FieldDeserializer2Factory create() {
62	boolean isEnableUnsafeSerializer = (UnsafeSerializer.isEnabled() && UnsafeDeserializer.isEnabled());	7!
63
64	if (isEnableUnsafeSerializer) {	2!
65	return new FieldDeserializer2FactoryUnsafe();	4✔
66	} else {
67	return new FieldDeserializer2Factory();	×
68	}
69	}
70
71	/**
72	* Creates a map of the classes fields.
73	*/
74	FieldDeserializer2 create(Field field) {
75	if (Modifier.isTransient(field.getModifiers()) \|\| Modifier.isStatic(field.getModifiers())) {	×
76	return NullFieldDeserializer.DESER;	×
77	}
78
79	// XXX: could parameterize the handler to only deal with public
80	try {
81	field.setAccessible(true);	×
82	} catch (Throwable e) {	×
83	log.trace("Unable to set field to accessible", e);	×
84	}	×
85
86	Class<?> type = field.getType();	×
87	FieldDeserializer2 deser;
88
89	if (String.class.equals(type)) {	×
90	deser = new StringFieldDeserializer(field);	×
91	} else if (byte.class.equals(type)) {	×
92	deser = new ByteFieldDeserializer(field);	×
93	} else if (short.class.equals(type)) {	×
94	deser = new ShortFieldDeserializer(field);	×
95	} else if (int.class.equals(type)) {	×
96	deser = new IntFieldDeserializer(field);	×
97	} else if (long.class.equals(type)) {	×
98	deser = new LongFieldDeserializer(field);	×
99	} else if (float.class.equals(type)) {	×
100	deser = new FloatFieldDeserializer(field);	×
101	} else if (double.class.equals(type)) {	×
102	deser = new DoubleFieldDeserializer(field);	×
103	} else if (boolean.class.equals(type)) {	×
104	deser = new BooleanFieldDeserializer(field);	×
105	} else if (java.sql.Date.class.equals(type)) {	×
106	deser = new SqlDateFieldDeserializer(field);	×
107	} else if (java.sql.Timestamp.class.equals(type)) {	×
108	deser = new SqlTimestampFieldDeserializer(field);	×
109	} else if (java.sql.Time.class.equals(type)) {	×
110	deser = new SqlTimeFieldDeserializer(field);	×
111	} else {
112	deser = new ObjectFieldDeserializer(field);	×
113	}
114
115	return deser;	×
116	}
117
118	/**
119	* Creates a map of the classes fields.
120	*/
121	protected static Object getParamArg(Class<?> cl) {
122	if (!cl.isPrimitive()) {	×
123	return null;	×
124	} else if (boolean.class.equals(cl)) {	×
125	return Boolean.FALSE;	×
126	} else if (byte.class.equals(cl)) {	×
127	return new Byte((byte) 0);	×
128	} else if (short.class.equals(cl)) {	×
129	return new Short((short) 0);	×
130	} else if (char.class.equals(cl)) {	×
131	return new Character((char) 0);	×
132	} else if (int.class.equals(cl)) {	×
133	return Integer.valueOf(0);	×
134	} else if (long.class.equals(cl)) {	×
135	return Long.valueOf(0);	×
136	} else if (float.class.equals(cl)) {	×
137	return Float.valueOf(0);	×
138	} else if (double.class.equals(cl)) {	×
139	return Double.valueOf(0);	×
140	} else {
141	throw new UnsupportedOperationException();	×
142	}
143	}
144
145	static class NullFieldDeserializer implements FieldDeserializer2 {	×
146	static NullFieldDeserializer DESER = new NullFieldDeserializer();	×
147
148	@Override
149	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
150	in.readObject();	×
151	}	×
152	}
153
154	static class ObjectFieldDeserializer implements FieldDeserializer2 {
155	private final Field field;
156
157	ObjectFieldDeserializer(Field field) {	×
158	this.field = field;	×
159	}	×
160
161	@Override
162	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
163	Object value = null;	×
164
165	try {
166	value = in.readObject(field.getType());	×
167
168	field.set(obj, value);	×
169	} catch (Exception e) {	×
170	logDeserializeError(field, obj, value, e);	×
171	}	×
172	}	×
173	}
174
175	static class BooleanFieldDeserializer implements FieldDeserializer2 {
176	private final Field field;
177
178	BooleanFieldDeserializer(Field field) {	×
179	this.field = field;	×
180	}	×
181
182	@Override
183	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
184	boolean value = false;	×
185
186	try {
187	value = in.readBoolean();	×
188
189	field.setBoolean(obj, value);	×
190	} catch (Exception e) {	×
191	logDeserializeError(field, obj, value, e);	×
192	}	×
193	}	×
194	}
195
196	static class ByteFieldDeserializer implements FieldDeserializer2 {
197	private final Field field;
198
199	ByteFieldDeserializer(Field field) {	×
200	this.field = field;	×
201	}	×
202
203	@Override
204	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
205	int value = 0;	×
206
207	try {
208	value = in.readInt();	×
209
210	field.setByte(obj, (byte) value);	×
211	} catch (Exception e) {	×
212	logDeserializeError(field, obj, value, e);	×
213	}	×
214	}	×
215	}
216
217	static class ShortFieldDeserializer implements FieldDeserializer2 {
218	private final Field field;
219
220	ShortFieldDeserializer(Field field) {	×
221	this.field = field;	×
222	}	×
223
224	@Override
225	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
226	int value = 0;	×
227
228	try {
229	value = in.readInt();	×
230
231	field.setShort(obj, (short) value);	×
232	} catch (Exception e) {	×
233	logDeserializeError(field, obj, value, e);	×
234	}	×
235	}	×
236	}
237
238	static class IntFieldDeserializer implements FieldDeserializer2 {
239	private final Field field;
240
241	IntFieldDeserializer(Field field) {	×
242	this.field = field;	×
243	}	×
244
245	@Override
246	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
247	int value = 0;	×
248
249	try {
250	value = in.readInt();	×
251
252	field.setInt(obj, value);	×
253	} catch (Exception e) {	×
254	logDeserializeError(field, obj, value, e);	×
255	}	×
256	}	×
257	}
258
259	static class LongFieldDeserializer implements FieldDeserializer2 {
260	private final Field field;
261
262	LongFieldDeserializer(Field field) {	×
263	this.field = field;	×
264	}	×
265
266	@Override
267	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
268	long value = 0;	×
269
270	try {
271	value = in.readLong();	×
272
273	field.setLong(obj, value);	×
274	} catch (Exception e) {	×
275	logDeserializeError(field, obj, value, e);	×
276	}	×
277	}	×
278	}
279
280	static class FloatFieldDeserializer implements FieldDeserializer2 {
281	private final Field field;
282
283	FloatFieldDeserializer(Field field) {	×
284	this.field = field;	×
285	}	×
286
287	@Override
288	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
289	double value = 0;	×
290
291	try {
292	value = in.readDouble();	×
293
294	field.setFloat(obj, (float) value);	×
295	} catch (Exception e) {	×
296	logDeserializeError(field, obj, value, e);	×
297	}	×
298	}	×
299	}
300
301	static class DoubleFieldDeserializer implements FieldDeserializer2 {
302	private final Field field;
303
304	DoubleFieldDeserializer(Field field) {	×
305	this.field = field;	×
306	}	×
307
308	@Override
309	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
310	double value = 0;	×
311
312	try {
313	value = in.readDouble();	×
314
315	field.setDouble(obj, value);	×
316	} catch (Exception e) {	×
317	logDeserializeError(field, obj, value, e);	×
318	}	×
319	}	×
320	}
321
322	static class StringFieldDeserializer implements FieldDeserializer2 {
323	private final Field field;
324
325	StringFieldDeserializer(Field field) {	×
326	this.field = field;	×
327	}	×
328
329	@Override
330	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
331	String value = null;	×
332
333	try {
334	value = in.readString();	×
335
336	field.set(obj, value);	×
337	} catch (Exception e) {	×
338	logDeserializeError(field, obj, value, e);	×
339	}	×
340	}	×
341	}
342
343	static class SqlDateFieldDeserializer implements FieldDeserializer2 {
344	private final Field field;
345
346	SqlDateFieldDeserializer(Field field) {	×
347	this.field = field;	×
348	}	×
349
350	@Override
351	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
352	java.sql.Date value = null;	×
353
354	try {
355	java.util.Date date = (java.util.Date) in.readObject();	×
356
357	if (date != null) {	×
358	value = new java.sql.Date(date.getTime());	×
359
360	field.set(obj, value);	×
361	} else {
362	field.set(obj, null);	×
363	}
364	} catch (Exception e) {	×
365	logDeserializeError(field, obj, value, e);	×
366	}	×
367	}	×
368	}
369
370	static class SqlTimestampFieldDeserializer implements FieldDeserializer2 {
371	private final Field field;
372
373	SqlTimestampFieldDeserializer(Field field) {	×
374	this.field = field;	×
375	}	×
376
377	@Override
378	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
379	java.sql.Timestamp value = null;	×
380
381	try {
382	java.util.Date date = (java.util.Date) in.readObject();	×
383
384	if (date != null) {	×
385	value = new java.sql.Timestamp(date.getTime());	×
386
387	field.set(obj, value);	×
388	} else {
389	field.set(obj, null);	×
390	}
391	} catch (Exception e) {	×
392	logDeserializeError(field, obj, value, e);	×
393	}	×
394	}	×
395	}
396
397	static class SqlTimeFieldDeserializer implements FieldDeserializer2 {
398	private final Field field;
399
400	SqlTimeFieldDeserializer(Field field) {	×
401	this.field = field;	×
402	}	×
403
404	@Override
405	public void deserialize(AbstractHessianDecoder in, Object obj) throws IOException {
406	java.sql.Time value = null;	×
407
408	try {
409	java.util.Date date = (java.util.Date) in.readObject();	×
410
411	if (date != null) {	×
412	value = new java.sql.Time(date.getTime());	×
413
414	field.set(obj, value);	×
415	} else {
416	field.set(obj, null);	×
417	}
418	} catch (Exception e) {	×
419	logDeserializeError(field, obj, value, e);	×
420	}	×
421	}	×
422	}
423
424	static void logDeserializeError(Field field, Object obj, Object value, Throwable e) throws IOException {
425	String fieldName = (field.getDeclaringClass().getName() + "." + field.getName());	×
426
427	if (e instanceof HessianFieldException) {	×
428	throw (HessianFieldException) e;	×
429	} else if (e instanceof IOException) {	×
430	throw new HessianFieldException(fieldName + ": " + e.getMessage(), e);	×
431	}
432
433	if (value != null) {	×
434	throw new HessianFieldException(	×
435	fieldName + ": " + value.getClass().getName() + " (" + value + ")" + " cannot be assigned to '"	×
436	+ field.getType().getName() + "'",	×
437	e);
438	} else {
439	throw new HessianFieldException(	×
440	fieldName + ": " + field.getType().getName() + " cannot be assigned from null", e);	×
441	}
442	}
443	}

wuwen5 / hessian / 17023139374

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous