json

src/main/java/org/redkale/convert/json/JsonByteBufferWriter.java

@@ -10,6 +10,7 @@ import java.nio.charset.Charset;
 import java.util.Objects;
 import java.util.function.Supplier;
 import org.redkale.convert.ConvertException;
+import org.redkale.convert.Encodeable;
 import org.redkale.util.*;
 
 /**
@@ -167,7 +168,7 @@ public class JsonByteBufferWriter extends JsonWriter {
         if (expandsize == 0) { // 只需要一个buffer
             final ByteBuffer buffer = this.buffers[currBufIndex];
             if (quote) {
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
             }
 
             if (charset == null) { // UTF-8
@@ -181,13 +182,13 @@ public class JsonByteBufferWriter extends JsonWriter {
                         buffer.put((byte) (0x80 | (c & 0x3f)));
                     } else if (Character.isSurrogate(c)) { // 连取两个
                         int uc = Character.toCodePoint(c, chs[i + 1]);
-                        buffer.put((byte) (0xf0 | ((uc >> 18))));
+                        buffer.put((byte) (0xf0 | (uc >> 18)));
                         buffer.put((byte) (0x80 | ((uc >> 12) & 0x3f)));
                         buffer.put((byte) (0x80 | ((uc >> 6) & 0x3f)));
                         buffer.put((byte) (0x80 | (uc & 0x3f)));
                         i++;
                     } else {
-                        buffer.put((byte) (0xe0 | ((c >> 12))));
+                        buffer.put((byte) (0xe0 | (c >> 12)));
                         buffer.put((byte) (0x80 | ((c >> 6) & 0x3f)));
                         buffer.put((byte) (0x80 | (c & 0x3f)));
                     }
@@ -197,7 +198,7 @@ public class JsonByteBufferWriter extends JsonWriter {
             }
 
             if (quote) {
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
             }
             return;
         }
@@ -206,7 +207,7 @@ public class JsonByteBufferWriter extends JsonWriter {
             if (!buffer.hasRemaining()) {
                 buffer = nextByteBuffer();
             }
-            buffer.put((byte) '"');
+            buffer.put(BYTE_DQUOTE);
         }
         if (charset == null) { // UTF-8
             final int limit = start + len;
@@ -272,7 +273,7 @@ public class JsonByteBufferWriter extends JsonWriter {
             if (!buffer.hasRemaining()) {
                 buffer = nextByteBuffer();
             }
-            buffer.put((byte) '"');
+            buffer.put(BYTE_DQUOTE);
         }
     }
 
@@ -329,11 +330,11 @@ public class JsonByteBufferWriter extends JsonWriter {
         if (expandsize == 0) { // 只需要一个buffer
             final ByteBuffer buffer = this.buffers[currBufIndex];
             if (quote) {
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
             }
             buffer.put(bs);
             if (quote) {
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
             }
         } else {
             ByteBuffer buffer = this.buffers[currBufIndex];
@@ -341,7 +342,7 @@ public class JsonByteBufferWriter extends JsonWriter {
                 if (!buffer.hasRemaining()) {
                     buffer = nextByteBuffer();
                 }
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
             }
             for (byte b : bs) {
                 if (!buffer.hasRemaining()) {
@@ -353,113 +354,117 @@ public class JsonByteBufferWriter extends JsonWriter {
                 if (!buffer.hasRemaining()) {
                     buffer = nextByteBuffer();
                 }
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
             }
         }
     }
 
     @Override
-    public void writeFieldShortValue(final byte[] fieldBytes, final char[] fieldChars, final short value) {
+    public boolean writeFieldBooleanValue(byte[] fieldBytes, char[] fieldChars, boolean comma, boolean value) {
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, false, String.valueOf(value));
+    }
+
+    @Override
+    public boolean writeFieldByteValue(byte[] fieldBytes, char[] fieldChars, boolean comma, byte value) {
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, false, String.valueOf(value));
+    }
+
+    @Override
+    public boolean writeFieldShortValue(byte[] fieldBytes, char[] fieldChars, boolean comma, short value) {
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, false, String.valueOf(value));
+    }
+
+    @Override
+    public boolean writeFieldIntValue(byte[] fieldBytes, char[] fieldChars, boolean comma, int value) {
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, false, String.valueOf(value));
+    }
+
+    @Override
+    public boolean writeFieldLongValue(byte[] fieldBytes, char[] fieldChars, boolean comma, long value) {
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, false, String.valueOf(value));
+    }
+
+    @Override
+    public boolean writeFieldStringValue(byte[] fieldBytes, char[] fieldChars, boolean comma, String value) {
+        if (value == null) {
+            return comma;
+        }
         byte[] bs1 = fieldBytes;
-        byte[] bs2 = Utility.latin1ByteArray(String.valueOf(value));
+        int expandsize = expand(1 + bs1.length);
-        int expandsize = expand(bs1.length + bs2.length);
         if (expandsize == 0) { // 只需要一个buffer
             final ByteBuffer buffer = this.buffers[currBufIndex];
+            if (comma) buffer.put(BYTE_COMMA);
             buffer.put(bs1);
-            buffer.put(bs2);
         } else {
             ByteBuffer buffer = this.buffers[currBufIndex];
+            if (comma) buffer.put(BYTE_COMMA);
             for (byte b : bs1) {
                 if (!buffer.hasRemaining()) {
                     buffer = nextByteBuffer();
                 }
                 buffer.put(b);
             }
-            for (byte b : bs2) {
-                if (!buffer.hasRemaining()) {
-                    buffer = nextByteBuffer();
-                }
-                buffer.put(b);
-            }
         }
+        writeString(value);
+        return true;
     }
 
     @Override
-    public void writeFieldIntValue(final byte[] fieldBytes, final char[] fieldChars, final int value) {
+    public boolean writeFieldObjectValue(
+            byte[] fieldBytes, char[] fieldChars, boolean comma, Encodeable encodeable, Object value) {
+        if (value == null) {
+            return comma;
+        }
         byte[] bs1 = fieldBytes;
-        byte[] bs2 = Utility.latin1ByteArray(String.valueOf(value));
+        int expandsize = expand(1 + bs1.length);
-        int expandsize = expand(bs1.length + bs2.length);
         if (expandsize == 0) { // 只需要一个buffer
             final ByteBuffer buffer = this.buffers[currBufIndex];
+            if (comma) buffer.put(BYTE_COMMA);
             buffer.put(bs1);
-            buffer.put(bs2);
         } else {
             ByteBuffer buffer = this.buffers[currBufIndex];
+            if (comma) buffer.put(BYTE_COMMA);
             for (byte b : bs1) {
                 if (!buffer.hasRemaining()) {
                     buffer = nextByteBuffer();
                 }
                 buffer.put(b);
             }
-            for (byte b : bs2) {
-                if (!buffer.hasRemaining()) {
-                    buffer = nextByteBuffer();
-                }
-                buffer.put(b);
-            }
         }
+        encodeable.convertTo(this, value);
+        return true;
     }
 
     @Override
-    public void writeFieldLongValue(final byte[] fieldBytes, final char[] fieldChars, final long value) {
+    protected boolean writeFieldLatin1Value(
-        byte[] bs1 = fieldBytes;
+            byte[] fieldBytes, char[] fieldChars, boolean comma, boolean quote, String value) {
-        byte[] bs2 = Utility.latin1ByteArray(String.valueOf(value));
+        if (value == null) {
-        int expandsize = expand(bs1.length + bs2.length);
+            return comma;
-        if (expandsize == 0) { // 只需要一个buffer
-            final ByteBuffer buffer = this.buffers[currBufIndex];
-            buffer.put(bs1);
-            buffer.put(bs2);
-        } else {
-            ByteBuffer buffer = this.buffers[currBufIndex];
-            for (byte b : bs1) {
-                if (!buffer.hasRemaining()) {
-                    buffer = nextByteBuffer();
-                }
-                buffer.put(b);
-            }
-            for (byte b : bs2) {
-                if (!buffer.hasRemaining()) {
-                    buffer = nextByteBuffer();
-                }
-                buffer.put(b);
-            }
         }
-    }
-
-    @Override
-    public void writeFieldLatin1Value(final byte[] fieldBytes, final char[] fieldChars, final String value) {
         byte[] bs1 = fieldBytes;
         byte[] bs2 = Utility.latin1ByteArray(value);
-        int expandsize = expand(bs1.length + bs2.length + 2);
+        int expandsize = expand(bs1.length + bs2.length + 3);
         if (expandsize == 0) { // 只需要一个buffer
             final ByteBuffer buffer = this.buffers[currBufIndex];
+            if (comma) buffer.put(BYTE_COMMA);
             buffer.put(bs1);
-            buffer.put((byte) '"');
+            if (quote) buffer.put(BYTE_DQUOTE);
             buffer.put(bs2);
-            buffer.put((byte) '"');
+            if (quote) buffer.put(BYTE_DQUOTE);
         } else {
             ByteBuffer buffer = this.buffers[currBufIndex];
+            if (comma) buffer.put(BYTE_COMMA);
             for (byte b : bs1) {
                 if (!buffer.hasRemaining()) {
                     buffer = nextByteBuffer();
                 }
                 buffer.put(b);
             }
-            {
+            if (quote) {
                 if (!buffer.hasRemaining()) {
                     buffer = nextByteBuffer();
                 }
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
             }
             for (byte b : bs2) {
                 if (!buffer.hasRemaining()) {
@@ -467,13 +472,14 @@ public class JsonByteBufferWriter extends JsonWriter {
                 }
                 buffer.put(b);
             }
-            {
+            if (quote) {
                 if (!buffer.hasRemaining()) {
                     buffer = nextByteBuffer();
                 }
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
             }
         }
+        return true;
     }
 
     @Override
@@ -531,7 +537,7 @@ public class JsonByteBufferWriter extends JsonWriter {
             expandsize = expand(byteLength);
             if (expandsize == 0) { // 只需要一个buffer
                 final ByteBuffer buffer = this.buffers[currBufIndex];
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
                 for (int i = 0; i < chs.length; i++) {
                     char c = chs[i];
                     switch (c) {
@@ -548,7 +554,7 @@ public class JsonByteBufferWriter extends JsonWriter {
                             buffer.put((byte) '\\').put((byte) '\\');
                             break;
                         case '"':
-                            buffer.put((byte) '\\').put((byte) '"');
+                            buffer.put((byte) '\\').put(BYTE_DQUOTE);
                             break;
                         default:
                             if (c < 0x80) {
@@ -571,7 +577,7 @@ public class JsonByteBufferWriter extends JsonWriter {
                             break;
                     }
                 }
-                buffer.put((byte) '"');
+                buffer.put(BYTE_DQUOTE);
                 return;
             }
         }

src/main/java/org/redkale/convert/json/JsonBytesWriter.java

@@ -28,7 +28,8 @@ public class JsonBytesWriter extends JsonWriter implements ByteTuple {
 
     private static final byte[] BYTES_NULL = new byte[] {'n', 'u', 'l', 'l'};
 
-    private static final int TENTHOUSAND_MAX = 10001;
+    // 所有byte、short值的序列化进行缓存
+    private static final int TENTHOUSAND_MAX = Short.MAX_VALUE + 2;
 
     private static final byte[][] TENTHOUSAND_BYTES = new byte[TENTHOUSAND_MAX][];
     private static final byte[][] TENTHOUSAND_BYTES2 = new byte[TENTHOUSAND_MAX][];
@@ -185,69 +186,133 @@ public class JsonBytesWriter extends JsonWriter implements ByteTuple {
     }
 
     @Override
-    public void writeFieldShortValue(final byte[] fieldBytes, final char[] fieldChars, final short value) {
+    public boolean writeFieldBooleanValue(byte[] fieldBytes, char[] fieldChars, boolean comma, boolean value) {
         byte[] bs1 = fieldBytes;
-        byte[] bs2 = (value >= 0 && value < TENTHOUSAND_MAX)
+        byte[] bs2 = value ? BYTES_TUREVALUE : BYTES_FALSEVALUE;
-                ? TENTHOUSAND_BYTES[value]
-                : ((value < 0 && value > -TENTHOUSAND_MAX)
-                        ? TENTHOUSAND_BYTES2[-value]
-                        : Utility.latin1ByteArray(String.valueOf(value)));
         int len1 = bs1.length;
         int len2 = bs2.length;
-        byte[] src = expand(len1 + len2);
+        byte[] src = expand(1 + len1 + len2);
+        if (comma) src[count++] = BYTE_COMMA;
         System.arraycopy(bs1, 0, src, count, len1);
         count += len1;
         System.arraycopy(bs2, 0, src, count, len2);
         count += len2;
+        return true;
     }
 
     @Override
-    public void writeFieldIntValue(final byte[] fieldBytes, final char[] fieldChars, final int value) {
+    public boolean writeFieldByteValue(byte[] fieldBytes, char[] fieldChars, boolean comma, byte value) {
         byte[] bs1 = fieldBytes;
-        byte[] bs2 = (value >= 0 && value < TENTHOUSAND_MAX)
+        byte[] bs2 = value >= 0 ? TENTHOUSAND_BYTES[value] : TENTHOUSAND_BYTES2[-value];
-                ? TENTHOUSAND_BYTES[value]
-                : ((value < 0 && value > -TENTHOUSAND_MAX)
-                        ? TENTHOUSAND_BYTES2[-value]
-                        : Utility.latin1ByteArray(String.valueOf(value)));
         int len1 = bs1.length;
         int len2 = bs2.length;
-        byte[] src = expand(len1 + len2);
+        byte[] src = expand(1 + len1 + len2);
+        if (comma) src[count++] = BYTE_COMMA;
         System.arraycopy(bs1, 0, src, count, len1);
         count += len1;
         System.arraycopy(bs2, 0, src, count, len2);
         count += len2;
+        return true;
     }
 
     @Override
-    public void writeFieldLongValue(final byte[] fieldBytes, final char[] fieldChars, final long value) {
+    public boolean writeFieldShortValue(byte[] fieldBytes, char[] fieldChars, boolean comma, short value) {
         byte[] bs1 = fieldBytes;
-        byte[] bs2 = (value >= 0 && value < TENTHOUSAND_MAX)
+        byte[] bs2 = value >= 0 ? TENTHOUSAND_BYTES[value] : TENTHOUSAND_BYTES2[-value];
-                ? TENTHOUSAND_BYTES[(int) value]
-                : ((value < 0 && value > -TENTHOUSAND_MAX)
-                        ? TENTHOUSAND_BYTES2[(int) -value]
-                        : Utility.latin1ByteArray(String.valueOf(value)));
         int len1 = bs1.length;
         int len2 = bs2.length;
-        byte[] src = expand(len1 + len2);
+        byte[] src = expand(1 + len1 + len2);
+        if (comma) src[count++] = BYTE_COMMA;
         System.arraycopy(bs1, 0, src, count, len1);
         count += len1;
         System.arraycopy(bs2, 0, src, count, len2);
         count += len2;
+        return true;
     }
 
     @Override
-    public void writeFieldLatin1Value(final byte[] fieldBytes, final char[] fieldChars, final String value) {
+    public boolean writeFieldIntValue(byte[] fieldBytes, char[] fieldChars, boolean comma, int value) {
+        byte[] bs1 = fieldBytes;
+        int len1 = bs1.length;
+        byte[] src = expand(len1 + 12);
+        if (comma) src[count++] = BYTE_COMMA;
+        System.arraycopy(bs1, 0, src, count, len1);
+        count += len1;
+        writeInt(value);
+        return true;
+    }
+
+    @Override
+    public boolean writeFieldLongValue(byte[] fieldBytes, char[] fieldChars, boolean comma, long value) {
+        byte[] bs1 = fieldBytes;
+        int len1 = bs1.length;
+        byte[] src = expand(len1 + 21);
+        if (comma) src[count++] = BYTE_COMMA;
+        System.arraycopy(bs1, 0, src, count, len1);
+        count += len1;
+        writeLong(value);
+        return true;
+    }
+
+    @Override
+    public boolean writeFieldStringValue(byte[] fieldBytes, char[] fieldChars, boolean comma, String value) {
+        if (value == null) {
+            return comma;
+        }
+        byte[] bs1 = fieldBytes;
+        int len1 = bs1.length;
+        byte[] src = expand(1 + len1);
+        if (comma) src[count++] = BYTE_COMMA;
+        System.arraycopy(bs1, 0, src, count, len1);
+        count += len1;
+        writeString(value);
+        return true;
+    }
+
+    @Override
+    public boolean writeFieldObjectValue(
+            byte[] fieldBytes, char[] fieldChars, boolean comma, Encodeable encodeable, Object value) {
+        if (value == null) {
+            return comma;
+        }
+        byte[] bs1 = fieldBytes;
+        int len1 = bs1.length;
+        byte[] src = expand(1 + len1);
+        if (comma) src[count++] = BYTE_COMMA;
+        System.arraycopy(bs1, 0, src, count, len1);
+        count += len1;
+        encodeable.convertTo(this, value);
+        return true;
+    }
+
+    @Override
+    protected boolean writeFieldLatin1Value(
+            byte[] fieldBytes, char[] fieldChars, boolean comma, boolean quote, String value) {
+        if (value == null) {
+            return comma;
+        }
         byte[] bs1 = fieldBytes;
         byte[] bs2 = Utility.latin1ByteArray(value);
         int len1 = bs1.length;
         int len2 = bs2.length;
-        byte[] src = expand(len1 + len2 + 2);
+        if (quote) {
-        System.arraycopy(bs1, 0, src, count, len1);
+            byte[] src = expand(len1 + len2 + 3);
-        count += len1;
+            if (comma) src[count++] = BYTE_COMMA;
-        src[count++] = BYTE_DQUOTE;
+            System.arraycopy(bs1, 0, src, count, len1);
-        System.arraycopy(bs2, 0, src, count, len2);
+            count += len1;
-        count += len2;
+            src[count++] = BYTE_DQUOTE;
-        src[count++] = BYTE_DQUOTE;
+            System.arraycopy(bs2, 0, src, count, len2);
+            count += len2;
+            src[count++] = BYTE_DQUOTE;
+        } else {
+            byte[] src = expand(1 + len1 + len2);
+            if (comma) src[count++] = BYTE_COMMA;
+            System.arraycopy(bs1, 0, src, count, len1);
+            count += len1;
+            System.arraycopy(bs2, 0, src, count, len2);
+            count += len2;
+        }
+        return true;
     }
 
     public JsonBytesWriter clear() {
@@ -536,7 +601,7 @@ public class JsonBytesWriter extends JsonWriter implements ByteTuple {
             count += bs.length;
             return;
         }
-        final char sign = value >= 0 ? 0 : '-';
+        final byte sign = value >= 0 ? 0 : BYTE_NEGATIVE;
         if (value < 0) {
             value = -value;
         }
@@ -577,7 +642,7 @@ public class JsonBytesWriter extends JsonWriter implements ByteTuple {
             }
         }
         if (sign != 0) {
-            bytes[--charPos] = (byte) sign;
+            bytes[--charPos] = BYTE_NEGATIVE;
         }
         count += size;
     }

src/main/java/org/redkale/convert/json/JsonCharsWriter.java

@@ -4,6 +4,8 @@
  */
 package org.redkale.convert.json;
 
+import org.redkale.convert.Encodeable;
+import static org.redkale.convert.json.JsonWriter.BYTE_COMMA;
 import static org.redkale.convert.json.JsonWriter.BYTE_DQUOTE;
 import static org.redkale.convert.json.JsonWriter.DEFAULT_SIZE;
 import static org.redkale.convert.json.JsonWriter.DigitOnes;
@@ -27,7 +29,8 @@ public class JsonCharsWriter extends JsonWriter {
 
     private static final char[] CHARS_FALSEVALUE = "false".toCharArray();
 
-    private static final int TENTHOUSAND_MAX = 10001;
+    // 所有byte、short值的序列化进行缓存
+    private static final int TENTHOUSAND_MAX = Short.MAX_VALUE + 2;
 
     private static final char[][] TENTHOUSAND_CHARS = new char[TENTHOUSAND_MAX][];
     private static final char[][] TENTHOUSAND_CHARS2 = new char[TENTHOUSAND_MAX][];
@@ -140,68 +143,133 @@ public class JsonCharsWriter extends JsonWriter {
     }
 
     @Override
-    public void writeFieldShortValue(final byte[] fieldBytes, final char[] fieldChars, final short value) {
+    public boolean writeFieldBooleanValue(byte[] fieldBytes, char[] fieldChars, boolean comma, boolean value) {
         char[] bs1 = fieldChars;
-        char[] bs2 = (value >= 0 && value < TENTHOUSAND_MAX)
+        char[] bs2 = value ? CHARS_TUREVALUE : CHARS_FALSEVALUE;
-                ? TENTHOUSAND_CHARS[value]
-                : ((value < 0 && value > -TENTHOUSAND_MAX)
-                        ? TENTHOUSAND_CHARS2[-value]
-                        : String.valueOf(value).toCharArray());
         int len1 = bs1.length;
         int len2 = bs2.length;
-        char[] src = expand(len1 + len2);
+        char[] src = expand(1 + len1 + len2);
+        if (comma) src[count++] = BYTE_COMMA;
         System.arraycopy(bs1, 0, src, count, len1);
         count += len1;
         System.arraycopy(bs2, 0, src, count, len2);
         count += len2;
+        return true;
     }
 
     @Override
-    public void writeFieldIntValue(final byte[] fieldBytes, final char[] fieldChars, final int value) {
+    public boolean writeFieldShortValue(byte[] fieldBytes, char[] fieldChars, boolean comma, short value) {
         char[] bs1 = fieldChars;
-        char[] bs2 = (value >= 0 && value < TENTHOUSAND_MAX)
+        char[] bs2 = value >= 0 ? TENTHOUSAND_CHARS[value] : TENTHOUSAND_CHARS2[-value];
-                ? TENTHOUSAND_CHARS[value]
-                : ((value < 0 && value > -TENTHOUSAND_MAX)
-                        ? TENTHOUSAND_CHARS2[-value]
-                        : String.valueOf(value).toCharArray());
         int len1 = bs1.length;
         int len2 = bs2.length;
-        char[] src = expand(len1 + len2);
+        char[] src = expand(1 + len1 + len2);
+        if (comma) src[count++] = BYTE_COMMA;
         System.arraycopy(bs1, 0, src, count, len1);
         count += len1;
         System.arraycopy(bs2, 0, src, count, len2);
         count += len2;
+        return true;
     }
 
     @Override
-    public void writeFieldLongValue(final byte[] fieldBytes, final char[] fieldChars, final long value) {
+    public boolean writeFieldByteValue(byte[] fieldBytes, char[] fieldChars, boolean comma, byte value) {
         char[] bs1 = fieldChars;
-        char[] bs2 = (value >= 0 && value < TENTHOUSAND_MAX)
+        char[] bs2 = value >= 0 ? TENTHOUSAND_CHARS[value] : TENTHOUSAND_CHARS2[-value];
-                ? TENTHOUSAND_CHARS[(int) value]
-                : ((value < 0 && value > -TENTHOUSAND_MAX)
-                        ? TENTHOUSAND_CHARS2[(int) -value]
-                        : String.valueOf(value).toCharArray());
         int len1 = bs1.length;
         int len2 = bs2.length;
-        char[] src = expand(len1 + len2);
+        char[] src = expand(1 + len1 + len2);
+        if (comma) src[count++] = BYTE_COMMA;
         System.arraycopy(bs1, 0, src, count, len1);
         count += len1;
         System.arraycopy(bs2, 0, src, count, len2);
         count += len2;
+        return true;
     }
 
     @Override
-    public void writeFieldLatin1Value(final byte[] fieldBytes, final char[] fieldChars, final String value) {
+    public boolean writeFieldIntValue(byte[] fieldBytes, char[] fieldChars, boolean comma, int value) {
+        char[] bs1 = fieldChars;
+        int len1 = bs1.length;
+        char[] src = expand(bs1.length + 12);
+        if (comma) src[count++] = BYTE_COMMA;
+        System.arraycopy(bs1, 0, src, count, len1);
+        count += bs1.length;
+        writeInt(value);
+        return true;
+    }
+
+    @Override
+    public boolean writeFieldLongValue(byte[] fieldBytes, char[] fieldChars, boolean comma, long value) {
+        char[] bs1 = fieldChars;
+        int len1 = bs1.length;
+        char[] src = expand(len1 + 21);
+        if (comma) src[count++] = BYTE_COMMA;
+        System.arraycopy(bs1, 0, src, count, len1);
+        count += len1;
+        writeLong(value);
+        return true;
+    }
+
+    @Override
+    public boolean writeFieldStringValue(byte[] fieldBytes, char[] fieldChars, boolean comma, String value) {
+        if (value == null) {
+            return comma;
+        }
+        char[] bs1 = fieldChars;
+        int len1 = bs1.length;
+        char[] src = expand(1 + len1);
+        if (comma) src[count++] = BYTE_COMMA;
+        System.arraycopy(bs1, 0, src, count, len1);
+        count += len1;
+        writeString(value);
+        return true;
+    }
+
+    @Override
+    public boolean writeFieldObjectValue(
+            byte[] fieldBytes, char[] fieldChars, boolean comma, Encodeable encodeable, Object value) {
+        if (value == null) {
+            return comma;
+        }
+        char[] bs1 = fieldChars;
+        int len1 = bs1.length;
+        char[] src = expand(1 + len1);
+        if (comma) src[count++] = BYTE_COMMA;
+        System.arraycopy(bs1, 0, src, count, len1);
+        count += len1;
+        encodeable.convertTo(this, value);
+        return true;
+    }
+
+    @Override
+    protected boolean writeFieldLatin1Value(
+            byte[] fieldBytes, char[] fieldChars, boolean comma, boolean quote, String value) {
+        if (value == null) {
+            return comma;
+        }
         char[] bs1 = fieldChars;
         int len1 = bs1.length;
         int len2 = value.length();
-        char[] src = expand(len1 + len2 + 2);
+
-        System.arraycopy(bs1, 0, src, count, len1);
+        if (quote) {
-        count += len1;
+            char[] src = expand(len1 + len2 + 3);
-        src[count++] = BYTE_DQUOTE;
+            if (comma) src[count++] = BYTE_COMMA;
-        value.getChars(0, len2, content, count);
+            System.arraycopy(bs1, 0, src, count, len1);
-        count += len2;
+            count += len1;
-        src[count++] = BYTE_DQUOTE;
+            src[count++] = BYTE_DQUOTE;
+            value.getChars(0, len2, content, count);
+            count += len2;
+            src[count++] = BYTE_DQUOTE;
+        } else {
+            char[] src = expand(1 + len1 + len2);
+            if (comma) src[count++] = BYTE_COMMA;
+            System.arraycopy(bs1, 0, src, count, len1);
+            count += len1;
+            value.getChars(0, len2, content, count);
+            count += len2;
+        }
+        return true;
     }
 
     public byte[] toBytes() {
@@ -389,8 +457,10 @@ public class JsonCharsWriter extends JsonWriter {
                 break;
             }
         }
-        if (sign != 0) size++; // 负数
+        if (sign != 0) {
-        expand(size);
+            size++; // 负数
+        }
+        char[] chars = expand(size);
 
         int q, r;
         int charPos = count + size;
@@ -401,8 +471,8 @@ public class JsonCharsWriter extends JsonWriter {
             // really: r = i - (q * 100);
             r = value - ((q << 6) + (q << 5) + (q << 2));
             value = q;
-            content[--charPos] = DigitOnes[r];
+            chars[--charPos] = DigitOnes[r];
-            content[--charPos] = DigitTens[r];
+            chars[--charPos] = DigitTens[r];
         }
 
         // Fall thru to fast mode for smaller numbers
@@ -410,11 +480,13 @@ public class JsonCharsWriter extends JsonWriter {
         for (; ; ) {
             q = (value * 52429) >>> (16 + 3);
             r = value - ((q << 3) + (q << 1)); // r = i-(q*10) ...
-            content[--charPos] = digits[r];
+            chars[--charPos] = digits[r];
             value = q;
             if (value == 0) break;
         }
-        if (sign != 0) content[--charPos] = sign;
+        if (sign != 0) {
+            chars[--charPos] = sign;
+        }
         count += size;
     }
 

src/main/java/org/redkale/convert/json/JsonWriter.java

@@ -24,6 +24,8 @@ public abstract class JsonWriter extends Writer {
 
     private static final char[] CHARS_NULL = new char[] {'n', 'u', 'l', 'l'};
 
+    protected static final byte BYTE_NEGATIVE = '-';
+
     protected static final byte BYTE_COMMA = ',';
 
     protected static final byte BYTE_COLON = ':';
@@ -83,13 +85,118 @@ public abstract class JsonWriter extends Writer {
         }
     }
 
-    public abstract void writeFieldShortValue(final byte[] fieldBytes, final char[] fieldChars, final short value);
+    // ---------------------------- writeFieldXXXValue 调用前不需要判断值是否为null ----------------------------
+    @ClassDepends
+    public abstract boolean writeFieldBooleanValue(byte[] fieldBytes, char[] fieldChars, boolean comma, boolean value);
 
-    public abstract void writeFieldIntValue(final byte[] fieldBytes, final char[] fieldChars, final int value);
+    @ClassDepends
+    public abstract boolean writeFieldByteValue(byte[] fieldBytes, char[] fieldChars, boolean comma, byte value);
 
-    public abstract void writeFieldLongValue(final byte[] fieldBytes, final char[] fieldChars, final long value);
+    @ClassDepends
+    public abstract boolean writeFieldShortValue(byte[] fieldBytes, char[] fieldChars, boolean comma, short value);
 
-    public abstract void writeFieldLatin1Value(final byte[] fieldBytes, final char[] fieldChars, final String value);
+    @ClassDepends
+    public final boolean writeFieldCharValue(byte[] fieldBytes, char[] fieldChars, boolean comma, char value) {
+        return writeFieldIntValue(fieldBytes, fieldChars, comma, value);
+    }
+
+    @ClassDepends
+    public abstract boolean writeFieldIntValue(byte[] fieldBytes, char[] fieldChars, boolean comma, int value);
+
+    @ClassDepends
+    public final boolean writeFieldFloatValue(byte[] fieldBytes, char[] fieldChars, boolean comma, float value) {
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, false, String.valueOf(value));
+    }
+
+    @ClassDepends
+    public abstract boolean writeFieldLongValue(byte[] fieldBytes, char[] fieldChars, boolean comma, long value);
+
+    @ClassDepends
+    public final boolean writeFieldDoubleValue(byte[] fieldBytes, char[] fieldChars, boolean comma, double value) {
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, false, String.valueOf(value));
+    }
+
+    @ClassDepends
+    public final boolean writeFieldBooleanValue(byte[] fieldBytes, char[] fieldChars, boolean comma, Boolean value) {
+        if (value == null) {
+            return comma;
+        }
+        return writeFieldBooleanValue(fieldBytes, fieldChars, comma, value.booleanValue());
+    }
+
+    @ClassDepends
+    public final boolean writeFieldByteValue(byte[] fieldBytes, char[] fieldChars, boolean comma, Byte value) {
+        if (value == null) {
+            return comma;
+        }
+        return writeFieldByteValue(fieldBytes, fieldChars, comma, value.byteValue());
+    }
+
+    @ClassDepends
+    public final boolean writeFieldShortValue(byte[] fieldBytes, char[] fieldChars, boolean comma, Short value) {
+        if (value == null) {
+            return comma;
+        }
+        return writeFieldShortValue(fieldBytes, fieldChars, comma, value.shortValue());
+    }
+
+    @ClassDepends
+    public final boolean writeFieldCharValue(byte[] fieldBytes, char[] fieldChars, boolean comma, Character value) {
+        if (value == null) {
+            return comma;
+        }
+        return writeFieldIntValue(fieldBytes, fieldChars, comma, value.charValue());
+    }
+
+    @ClassDepends
+    public final boolean writeFieldIntValue(byte[] fieldBytes, char[] fieldChars, boolean comma, Integer value) {
+        if (value == null) {
+            return comma;
+        }
+        return writeFieldIntValue(fieldBytes, fieldChars, comma, value.intValue());
+    }
+
+    @ClassDepends
+    public final boolean writeFieldFloatValue(byte[] fieldBytes, char[] fieldChars, boolean comma, Float value) {
+        if (value == null) {
+            return comma;
+        }
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, false, String.valueOf(value));
+    }
+
+    @ClassDepends
+    public final boolean writeFieldLongValue(byte[] fieldBytes, char[] fieldChars, boolean comma, Long value) {
+        if (value == null) {
+            return comma;
+        }
+        return writeFieldLongValue(fieldBytes, fieldChars, comma, value.longValue());
+    }
+
+    @ClassDepends
+    public final boolean writeFieldDoubleValue(byte[] fieldBytes, char[] fieldChars, boolean comma, Double value) {
+        if (value == null) {
+            return comma;
+        }
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, false, String.valueOf(value));
+    }
+
+    @ClassDepends
+    public final boolean writeFieldStandardStringValue(
+            byte[] fieldBytes, char[] fieldChars, boolean comma, String value) {
+        return writeFieldLatin1Value(fieldBytes, fieldChars, comma, true, value);
+    }
+
+    @ClassDepends
+    public abstract boolean writeFieldStringValue(byte[] fieldBytes, char[] fieldChars, boolean comma, String value);
+
+    @ClassDepends
+    public abstract boolean writeFieldObjectValue(
+            byte[] fieldBytes, char[] fieldChars, boolean comma, Encodeable encodeable, Object value);
+
+    protected abstract boolean writeFieldLatin1Value(
+            byte[] fieldBytes, char[] fieldChars, boolean comma, boolean quote, String value);
+
+    // ---------------------------- writeFieldXXXValue 主要供JsonDynEncoder使用 ----------------------------
 
     @Override
     @ClassDepends