Feat/sb compatible

src/main/java/com/caucho/hessian/io/AbstractFieldAdaptorSerializer.java

@@ -93,17 +93,27 @@ public void writeInstance(Object obj, AbstractHessianOutput out)
      * @return
      */
     protected Field[] getFieldsForSerialize(Class cl) {
-        List<Field> fields = new ArrayList<Field>();
+        ArrayList primitiveFields = new ArrayList();
+        ArrayList compoundFields = new ArrayList();
         for (; cl != null; cl = cl.getSuperclass()) {
             Field[] originFields = cl.getDeclaredFields();
             for (int i = 0; i < originFields.length; i++) {
                 Field field = originFields[i];
                 if (Modifier.isTransient(field.getModifiers()) || Modifier.isStatic(field.getModifiers())) {
                     continue;
                 }
-                fields.add(field);
+
+                if (field.getType().isPrimitive() ||
+                    field.getType().getName().startsWith("java.lang.") &&
+                    !field.getType().equals(Object.class))
+                    primitiveFields.add(field);
+                else
+                    compoundFields.add(field);
             }
         }
+        List<Field> fields = new ArrayList<Field>();
+        fields.addAll(primitiveFields);
+        fields.addAll(compoundFields);
         return fields.toArray(new Field[0]);
     }
 }

src/main/java/com/caucho/hessian/io/AbstractStringBuilderDeserializer.java

@@ -0,0 +1,129 @@
+/*
+ * Ant Group
+ * Copyright (c) 2004-2023 All Rights Reserved.
+ */
+package com.caucho.hessian.io;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ *
+ * @author junyuan
+ * @version AbstractStringBuilderDeserializer.java, v 0.1 2023年10月20日 11:31 junyuan Exp $
+ */
+public class AbstractStringBuilderDeserializer extends JavaDeserializer {
+    private static final Logger  log    = Logger.getLogger(AbstractStringBuilderDeserializer.class.getName());
+
+    private static final boolean ENABLE = judgeAvailability();
+
+    /**
+     * 判断是否要使用该反序列化器, 当 String.value 类型不为 char[] 时需要使用
+     * @return
+     */
+    private static boolean judgeAvailability() {
+        Field field;
+        try {
+            field = String.class.getDeclaredField("value");
+        } catch (Throwable t) {
+            return false;
+        }
+
+        if (char[].class.equals(field.getType())) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public static boolean isEnable() {
+        return ENABLE;
+    }
+
+    public AbstractStringBuilderDeserializer(Class<?> cl) {
+        super(cl);
+    }
+
+    @Override
+    protected HashMap getFieldMap(Class cl) {
+        HashMap fieldMap = super.getFieldMap(cl);
+        Field valueField = null;
+        try {
+            valueField = cl.getSuperclass().getDeclaredField("value");
+            valueField.setAccessible(true);
+        } catch (Throwable t) {
+            log.log(Level.WARNING, "get value field failed", t);
+            return fieldMap;
+        }
+
+        fieldMap.put("value", new StringBuilderValueFieldDeserializer(valueField));
+        return fieldMap;
+    }
+
+    /**
+     * 针对 value field 定制的 field deserializer
+     * 读取 value field 时, 根据传入数据进行读取, 读取到值后进行转换
+     */
+    static class StringBuilderValueFieldDeserializer extends FieldDeserializer {
+        private final Field _field;
+
+        StringBuilderValueFieldDeserializer(Field field) {
+            _field = field;
+        }
+
+        @Override
+        void deserialize(AbstractHessianInput in, Object obj) throws IOException {
+            Object value = null;
+
+            try {
+                // hessian 在读取 char 时会用 utf-8 编码
+                value = in.readObject();
+                if (value == null) {
+                    return;
+                }
+
+                // 理论上获取到的值有两种情况: String 或者 byte[]
+                if (value instanceof String) {
+                    byte[] res = hessianString2Bytes((String) value);
+                    _field.set(obj, res);
+                } else if (value instanceof byte[]) {
+                    _field.set(obj, value);
+                } else {
+                    throw new UnsupportedEncodingException("未知的编码类型" + value.getClass());
+                }
+            } catch (Exception e) {
+                logDeserializeError(_field, obj, value, e);
+            }
+        }
+
+        /**
+         * 按照 hessian 序列化的处理方式将 String 还原为 byte[]
+         * {@link Hessian2Output#printString(java.lang.String, int, int)}
+         * @param str
+         * @return
+         */
+        private byte[] hessianString2Bytes(String str) {
+            byte[] buffer = new byte[str.length()];
+            for (int i = 0; i < str.length(); i++) {
+                char ch = str.charAt(i);
+
+                if (ch < 0x80)
+                    buffer[i] = (byte) (ch);
+                else if (ch < 0x800) {
+                    buffer[i] = (byte) (0xc0 + ((ch >> 6) & 0x1f));
+                    buffer[i] = (byte) (0x80 + (ch & 0x3f));
+                } else {
+                    buffer[i] = (byte) (0xe0 + ((ch >> 12) & 0xf));
+                    buffer[i] = (byte) (0x80 + ((ch >> 6) & 0x3f));
+                    buffer[i] = (byte) (0x80 + (ch & 0x3f));
+                }
+            }
+            return buffer;
+        }
+    }
+
+}

src/main/java/com/caucho/hessian/io/AbstractStringBuilderSerializer.java

@@ -0,0 +1,111 @@
+/*
+ * Ant Group
+ * Copyright (c) 2004-2023 All Rights Reserved.
+ */
+package com.caucho.hessian.io;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.logging.Level;
+
+/**
+ *
+ * @author junyuan
+ * @version AbstractStringBuilderSerializer.java, v 0.1 2023年10月20日 11:31 junyuan Exp $
+ */
+public class AbstractStringBuilderSerializer extends AbstractFieldAdaptorSerializer {
+
+    private static final boolean ENABLE = judgeAvailability();
+
+    public static boolean isEnable() {
+        return ENABLE;
+    }
+
+    public AbstractStringBuilderSerializer(Class cl) {
+        super(cl);
+        for (Field field : _fields) {
+            try {
+                field.setAccessible(true);
+            } catch (Throwable t) {
+                log.log(Level.INFO, "unable to set field {} accessible", field.getName());
+            }
+        }
+
+    }
+
+    @Override
+    protected void serializeField(AbstractHessianOutput out, Object obj, Field field)
+        throws IOException {
+        if ("value".equals(field.getName())) {
+            serializeValueArray(out, obj);
+        } else {
+            serializeNormalField(out, obj, field);
+        }
+    }
+
+    /**
+     * 将底层 value 数组转为 char数组, 并以 writeString 方式进行序列化
+     * 保证序列化结果与普通 JavaSerializer 保持一致
+     *
+     * @param out
+     * @param obj
+     * @throws IOException
+     */
+    protected void serializeValueArray(AbstractHessianOutput out, Object obj)
+        throws IOException {
+        if (obj instanceof StringBuilder) {
+            StringBuilder sb = (StringBuilder) obj;
+            // 要用实际底层 value 数据的长度以保持一致
+            char[] dst = new char[sb.capacity()];
+            sb.getChars(0, sb.length(), dst, 0);
+
+            out.writeString(dst, 0, dst.length);
+        } else if (obj instanceof StringBuffer) {
+            StringBuffer sb = (StringBuffer) obj;
+            char[] dst = new char[sb.capacity()];
+            sb.getChars(0, sb.length(), dst, 0);
+
+            out.writeString(dst, 0, dst.length);
+        } else {
+            throw new UnsupportedOperationException("only support AbstractStringBuilder but got " + obj.getClass());
+        }
+    }
+
+    /**
+     * 常规字段以 object 的方式序列化
+     * @param out
+     * @param obj
+     * @param field
+     * @throws IOException
+     */
+    private void serializeNormalField(AbstractHessianOutput out, Object obj, Field field) throws IOException {
+        Object value = null;
+
+        try {
+            value = field.get(obj);
+        } catch (IllegalAccessException e) {
+            log.log(Level.FINE, e.toString(), e);
+        }
+
+        out.writeObject(value);
+    }
+
+    /**
+     * 判断是否要使用该反序列化器, 当 String.value 类型不为 char[] 时需要使用
+     * @return
+     */
+    private static boolean judgeAvailability() {
+        Field field = null;
+        try {
+            field = String.class.getDeclaredField("value");
+        } catch (Throwable t) {
+            return false;
+        }
+
+        if (char[].class.equals(field.getType())) {
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/com/caucho/hessian/io/SerializerFactory.java

@@ -707,6 +707,8 @@
             addCurrencySupport();
         }
 
+        addAbstractStringBuilderSupport();
+
     }
 
     /**
@@ -740,6 +742,24 @@
         }
     }
 
+    protected static void addAbstractStringBuilderSupport() {
+        try {
+            if (AbstractStringBuilderSerializer.isEnable()) {
+                _staticSerializerMap.put(StringBuilder.class, new AbstractStringBuilderSerializer(StringBuilder.class));
+                _staticSerializerMap.put(StringBuffer.class, new AbstractStringBuilderSerializer(StringBuffer.class));
+            }
+
+            if (AbstractStringBuilderDeserializer.isEnable()) {
+                _staticDeserializerMap.put(StringBuilder.class, new AbstractStringBuilderDeserializer(
+                    StringBuilder.class));
+                _staticDeserializerMap.put(StringBuffer.class,
+                    new AbstractStringBuilderDeserializer(StringBuffer.class));
+            }
+        } catch (Throwable t) {
+            log.info(String.valueOf(t.getCause()));
+        }
+    }
+
     private static boolean isZoneId(Class cl) {
         try {
             return isHigherThanJdk8 && Class.forName("java.time.ZoneId").isAssignableFrom(cl);

src/main/java/com/caucho/hessian/io/throwable/StackTraceElementSerializer.java

@@ -90,7 +90,8 @@
 
     @Override
     protected Field[] getFieldsForSerialize(Class cl) {
-        List<Field> fields = new ArrayList<Field>();
+        ArrayList primitiveFields = new ArrayList();
+        ArrayList compoundFields = new ArrayList();
         for (; cl != null; cl = cl.getSuperclass()) {
             Field[] originFields = cl.getDeclaredFields();
             for (int i = 0; i < originFields.length; i++) {
@@ -102,9 +103,18 @@
                 if ("format".equals(field.getName())) {
                     continue;
                 }
-                fields.add(field);
+
+                if (field.getType().isPrimitive() ||
+                    field.getType().getName().startsWith("java.lang.") &&
+                    !field.getType().equals(Object.class))
+                    primitiveFields.add(field);
+                else
+                    compoundFields.add(field);
             }
         }
+        List<Field> fields = new ArrayList<Field>();
+        fields.addAll(primitiveFields);
+        fields.addAll(compoundFields);
         return fields.toArray(new Field[0]);
     }
 }