fix: utf 16 support

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

@@ -20,24 +20,38 @@ public class AbstractStringBuilderDeserializer extends JavaDeserializer {
     private static final Logger  log    = Logger.getLogger(AbstractStringBuilderDeserializer.class.getName());
 
     private static final boolean ENABLE = judgeAvailability();
+    /** String 的 value field, 用以判断是否需要用当前 deserializer */
+    private static Field         stringValueField;
+    /** String 的 coder field, 用以从中间 String 变量中获取 coder */
+    private static Field         stringCoderField;
+
+    static {
+        try {
+            stringCoderField = String.class.getDeclaredField("coder");
+            stringCoderField.setAccessible(true);
+        } catch (Throwable t) {
+            log.log(Level.WARNING,
+                "coder field not found or not accessible, will skip coder check, error is " + t.getMessage());
+        }
+    }
 
     /**
-     * 判断是否要使用该反序列化器, 当 String.value 类型为 byte[] 时需要使用
+     * 判断是否要使用该反序列化器, 当 String.value 类型不为 char[] 时需要使用
      * @return
      */
     private static boolean judgeAvailability() {
-        Field field;
         try {
-            field = String.class.getDeclaredField("value");
+            stringValueField = String.class.getDeclaredField("value");
+            stringValueField.setAccessible(true);
         } catch (Throwable t) {
             return false;
         }
 
-        if (byte[].class.equals(field.getType())) {
-            return true;
+        if (char[].class.equals(stringValueField.getType())) {
+            return false;
         }
 
-        return false;
+        return true;
     }
 
     public static boolean isEnable() {
@@ -52,27 +66,57 @@ public AbstractStringBuilderDeserializer(Class<?> cl) {
     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);
+        valueField = getAbstractStringBuilderField(cl, "value");
+        if (valueField == null) {
+            log.log(Level.WARNING, "get value field failed");
             return fieldMap;
         }
 
-        fieldMap.put("value", new StringBuilderValueFieldDeserializer(valueField));
+        Field coderField = null;
+        if (fieldMap.containsKey("coder")) {
+            coderField = getAbstractStringBuilderField(cl, "coder");
+        }
+
+        fieldMap.put("value", new StringBuilderValueFieldDeserializer(valueField, coderField));
         return fieldMap;
     }
 
+    /**
+     * 获取 AbstractStingBuilder 类内的 field
+     * @param cl
+     * @param fieldName
+     * @return
+     */
+    private Field getAbstractStringBuilderField(Class cl, String fieldName) {
+        Field field = null;
+        try {
+            field = cl.getSuperclass().getDeclaredField(fieldName);
+            field.setAccessible(true);
+        } catch (Throwable t) {
+            log.log(Level.WARNING, "get " + fieldName + " field failed", t);
+            return null;
+        }
+        return field;
+    }
+
     /**
      * 针对 value field 定制的 field deserializer
      * 读取 value field 时, 根据传入数据进行读取, 读取到值后进行转换
      */
     static class StringBuilderValueFieldDeserializer extends FieldDeserializer {
+        /**
+         * 这个 _field 会是 AbstractStringBuilder.value
+         */
         private final Field _field;
 
-        StringBuilderValueFieldDeserializer(Field field) {
-            _field = field;
+        /**
+         * _coderField 会是 AbstractStringBuilder.coder 字段
+         */
+        private final Field _coderField;
+
+        StringBuilderValueFieldDeserializer(Field value, Field coder) {
+            _field = value;
+            _coderField = coder;
         }
 
         @Override
@@ -88,8 +132,7 @@ void deserialize(AbstractHessianInput in, Object obj) throws IOException {
 
                 // 理论上获取到的值有两种情况: String 或者 byte[]
                 if (value instanceof String) {
-                    byte[] res = hessianString2Bytes((String) value);
-                    _field.set(obj, res);
+                    dealWithStringValue((String) value, obj);
                 } else if (value instanceof byte[]) {
                     _field.set(obj, value);
                 } else {
@@ -101,28 +144,20 @@ void deserialize(AbstractHessianInput in, Object obj) throws IOException {
         }
 
         /**
-         * 按照 hessian 序列化的处理方式将 String 还原为 byte[]
-         * {@link Hessian2Output#printString(java.lang.String, int, int)}
-         * @param str
-         * @return
+         * 如果读取到的是 String, 需要通过 String.coder 进行编码
          */
-        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));
+        public void dealWithStringValue(String value, Object obj) {
+            try {
+                byte[] res = (byte[]) stringValueField.get(value);
+                _field.set(obj, res);
+
+                if (stringCoderField != null) {
+                    byte coder = (byte) stringCoderField.getByte(value);
+                    _coderField.set(obj, coder);
                 }
+            } catch (Throwable t) {
+
             }
-            return buffer;
         }
     }
 

src/test/java/com/caucho/hessian/io/java17/lang/AbstractStringBuilderEncodeTest.java

@@ -0,0 +1,168 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.caucho.hessian.io.java17.lang;
+
+import com.caucho.hessian.io.Hessian2Input;
+import com.caucho.hessian.io.Hessian2Output;
+import com.caucho.hessian.io.SerializerFactory;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+
+/**
+ *  <ol>
+ *    <li>确保新老两种序列化方式内容一致(由于类实现有变动, 无法保证 jdk17 和 jdk8 序列化结果完全一致)</li>
+ *    <li>确保 jdk8 下的序列化结果能被 jdk8 下的反序列化器正确解析</li>
+ *  </ol>
+ *
+ *
+ * @author junyuan
+ * @version AbstractStringBuilderEncodeTest.java, v 0.1 2023年10月20日 10:07 junyuan Exp $
+ */
+public class AbstractStringBuilderEncodeTest {
+
+    private static SerializerFactory     factory;
+    private static SerializerFactory     previousVersionFactory;
+    private static ByteArrayOutputStream os;
+
+    @BeforeClass
+    public static void setUp() {
+        factory = new SerializerFactory();
+        previousVersionFactory = new StringBuilderJavaSerializeFactory();
+
+        os = new ByteArrayOutputStream();
+    }
+
+    private void compatibleTest(Object inputData, SerializerFactory newFactory, SerializerFactory oldFactory) {
+        byte[] resNew = new byte[0];
+        byte[] resOld = new byte[0];
+
+        try {
+            resNew = doEncodeWithStringBuilder(inputData, newFactory);
+            resOld = doEncodeWithStringBuilder(inputData, oldFactory);
+        } catch (Throwable e) {
+            e.printStackTrace();
+            Assert.fail();
+        }
+
+        boolean result = Arrays.equals(resNew, resOld);
+        Assert.assertTrue(result);
+    }
+
+    @Test
+    public void compatibleTest_short_no_warpper() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("test");
+
+        compatibleTest(sb, factory, previousVersionFactory);
+    }
+
+    @Test
+    public void compatibleTest_long_no_warpper() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("100000000020000000003000000000400000000050000000006000000000");
+
+        compatibleTest(sb, factory, previousVersionFactory);
+    }
+
+    /**
+     * short string with length lt 16
+     */
+    @Test
+    public void compatibleTest_short_wrapper() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("test");
+        StringBuilderWrapper sbw = new StringBuilderWrapper();
+        sbw.setStringBuilder(sb);
+        sbw.setStr(sb.toString());
+
+        compatibleTest(sbw, factory, previousVersionFactory);
+    }
+
+    /**
+     * long string with length gt 31
+     */
+    @Test
+    public void compatibleTest_long_wrapper() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("100000000020000000003000000000400000000050000000006000000000");
+        StringBuilderWrapper sbw = new StringBuilderWrapper();
+        sbw.setStringBuilder(sb);
+        sbw.setStr(sb.toString());
+
+        compatibleTest(sbw, factory, previousVersionFactory);
+    }
+
+    /**
+     * UTF16
+     */
+    @Test
+    public void compatibleTest_wrapper_short_utf16() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("test测试");
+        StringBuilderWrapper sbw = new StringBuilderWrapper();
+        sbw.setStringBuilder(sb);
+        sbw.setStr(sb.toString());
+
+        compatibleTest(sbw, factory, previousVersionFactory);
+    }
+
+    /**
+     * UTF16
+     */
+    @Test
+    public void compatibleTest_wrapper_long_utf16() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeefffffffffftest测试");
+        StringBuilderWrapper sbw = new StringBuilderWrapper();
+        sbw.setStringBuilder(sb);
+        sbw.setStr(sb.toString());
+
+        compatibleTest(sbw, factory, previousVersionFactory);
+    }
+
+    protected byte[] doEncodeWithStringBuilder(Object data, SerializerFactory factory)
+        throws IOException {
+        os.reset();
+        Hessian2Output out = new Hessian2Output(os);
+        out.setSerializerFactory(factory);
+        out.writeObject(data);
+        out.flush();
+
+        return os.toByteArray();
+    }
+
+    /*
+     *打印byte[],以逗号分隔
+     */
+    private static void printBytes(byte[] bytes) {
+        if (bytes == null || bytes.length == 0) {
+            System.out.println("null");
+            return;
+        }
+
+        for (int i = 0; i < bytes.length; i++) {
+            System.out.print(bytes[i] + ",");
+        }
+        System.out.println();
+    }
+}