From bb92e4541a7f95890859b21140d30b73cbef0a1e Mon Sep 17 00:00:00 2001
From: redkale <redkale@qq.com>
Date: Mon, 30 Sep 2024 19:40:16 +0800
Subject: [PATCH] pb

---
 .../org/redkale/convert/ConvertFactory.java   |   2 +-
 .../convert/ext/BigDecimalSimpledCoder.java   |   2 +-
 .../convert/ext/BigIntegerSimpledCoder.java   |   2 +-
 .../convert/ext/InetAddressSimpledCoder.java  |   4 +-
 .../convert/ext/LongAdderSimpledCoder.java    |   2 +-
 .../convert/ext/Uint128SimpledCoder.java      |   2 +-
 .../convert/pb/ProtobufArrayEncoder.java      |   8 +-
 .../redkale/convert/pb/ProtobufCoders.java    | 137 +++++++++++++++++-
 .../convert/pb/ProtobufCollectionEncoder.java |  13 +-
 .../convert/pb/ProtobufEnumSimpledCoder.java  |  12 +-
 .../redkale/convert/pb/ProtobufFactory.java   |  11 ++
 .../convert/pb/ProtobufMapEncoder.java        |  16 +-
 .../convert/pb/ProtobufObjectEncoder.java     |  21 ++-
 13 files changed, 208 insertions(+), 24 deletions(-)

diff --git a/src/main/java/org/redkale/convert/ConvertFactory.java b/src/main/java/org/redkale/convert/ConvertFactory.java
index 712fc0ac5..f36ad97b8 100644
--- a/src/main/java/org/redkale/convert/ConvertFactory.java
+++ b/src/main/java/org/redkale/convert/ConvertFactory.java
@@ -128,10 +128,10 @@ public abstract class ConvertFactory<R extends Reader, W extends Writer> {
             this.register(BigInteger.class, BigIntegerSimpledCoder.instance);
             this.register(BigDecimal.class, BigDecimalSimpledCoder.instance);
             this.register(InetAddress.class, InetAddressSimpledCoder.instance);
+            this.register(InetSocketAddress.class, InetAddressSimpledCoder.InetSocketAddressSimpledCoder.instance);
             this.register(LongAdder.class, LongAdderSimpledCoder.instance);
             this.register(Uint128.class, Uint128SimpledCoder.instance);
             this.register(Class.class, TypeSimpledCoder.instance);
-            this.register(InetSocketAddress.class, InetAddressSimpledCoder.InetSocketAddressSimpledCoder.instance);
             this.register(Pattern.class, PatternSimpledCoder.instance);
             this.register(File.class, FileSimpledCoder.instance);
             this.register(Throwable.class, ThrowableSimpledCoder.instance);
diff --git a/src/main/java/org/redkale/convert/ext/BigDecimalSimpledCoder.java b/src/main/java/org/redkale/convert/ext/BigDecimalSimpledCoder.java
index 8b1dad424..401424586 100644
--- a/src/main/java/org/redkale/convert/ext/BigDecimalSimpledCoder.java
+++ b/src/main/java/org/redkale/convert/ext/BigDecimalSimpledCoder.java
@@ -19,7 +19,7 @@ import org.redkale.util.Utility;
  * @param <R> Reader输入的子类型
  * @param <W> Writer输出的子类型
  */
-public final class BigDecimalSimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, BigDecimal> {
+public class BigDecimalSimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, BigDecimal> {
 
     public static final BigDecimalSimpledCoder instance = new BigDecimalSimpledCoder();
 
diff --git a/src/main/java/org/redkale/convert/ext/BigIntegerSimpledCoder.java b/src/main/java/org/redkale/convert/ext/BigIntegerSimpledCoder.java
index 826ef5b4c..c25c3797c 100644
--- a/src/main/java/org/redkale/convert/ext/BigIntegerSimpledCoder.java
+++ b/src/main/java/org/redkale/convert/ext/BigIntegerSimpledCoder.java
@@ -18,7 +18,7 @@ import org.redkale.convert.json.*;
  * @param <R> Reader输入的子类型
  * @param <W> Writer输出的子类型
  */
-public final class BigIntegerSimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, BigInteger> {
+public class BigIntegerSimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, BigInteger> {
 
     public static final BigIntegerSimpledCoder instance = new BigIntegerSimpledCoder();
 
diff --git a/src/main/java/org/redkale/convert/ext/InetAddressSimpledCoder.java b/src/main/java/org/redkale/convert/ext/InetAddressSimpledCoder.java
index d175b867e..89799f007 100644
--- a/src/main/java/org/redkale/convert/ext/InetAddressSimpledCoder.java
+++ b/src/main/java/org/redkale/convert/ext/InetAddressSimpledCoder.java
@@ -20,7 +20,7 @@ import org.redkale.util.StringWrapper;
  * @param <W> Writer输出的子类型
  */
 @SuppressWarnings("unchecked")
-public final class InetAddressSimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, InetAddress> {
+public class InetAddressSimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, InetAddress> {
 
     public static final InetAddressSimpledCoder instance = new InetAddressSimpledCoder();
 
@@ -53,7 +53,7 @@ public final class InetAddressSimpledCoder<R extends Reader, W extends Writer> e
      * @param <W> Writer输出的子类型
      */
     @SuppressWarnings("unchecked")
-    public static final class InetSocketAddressSimpledCoder<R extends Reader, W extends Writer>
+    public static class InetSocketAddressSimpledCoder<R extends Reader, W extends Writer>
             extends SimpledCoder<R, W, InetSocketAddress> {
 
         public static final InetSocketAddressSimpledCoder instance = new InetSocketAddressSimpledCoder();
diff --git a/src/main/java/org/redkale/convert/ext/LongAdderSimpledCoder.java b/src/main/java/org/redkale/convert/ext/LongAdderSimpledCoder.java
index 6fd9421a6..15ade82e3 100644
--- a/src/main/java/org/redkale/convert/ext/LongAdderSimpledCoder.java
+++ b/src/main/java/org/redkale/convert/ext/LongAdderSimpledCoder.java
@@ -17,7 +17,7 @@ import org.redkale.convert.*;
  * @param <R> Reader输入的子类型
  * @param <W> Writer输出的子类型
  */
-public final class LongAdderSimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, LongAdder> {
+public class LongAdderSimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, LongAdder> {
 
     public static final LongAdderSimpledCoder instance = new LongAdderSimpledCoder();
 
diff --git a/src/main/java/org/redkale/convert/ext/Uint128SimpledCoder.java b/src/main/java/org/redkale/convert/ext/Uint128SimpledCoder.java
index 00ae93226..eeb95e9ff 100644
--- a/src/main/java/org/redkale/convert/ext/Uint128SimpledCoder.java
+++ b/src/main/java/org/redkale/convert/ext/Uint128SimpledCoder.java
@@ -18,7 +18,7 @@ import org.redkale.util.*;
  * @param <R> Reader输入的子类型
  * @param <W> Writer输出的子类型
  */
-public final class Uint128SimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, Uint128> {
+public class Uint128SimpledCoder<R extends Reader, W extends Writer> extends SimpledCoder<R, W, Uint128> {
 
     private static final ByteArraySimpledCoder bsSimpledCoder = ByteArraySimpledCoder.instance;
 
diff --git a/src/main/java/org/redkale/convert/pb/ProtobufArrayEncoder.java b/src/main/java/org/redkale/convert/pb/ProtobufArrayEncoder.java
index 3dec113db..51173a9a0 100644
--- a/src/main/java/org/redkale/convert/pb/ProtobufArrayEncoder.java
+++ b/src/main/java/org/redkale/convert/pb/ProtobufArrayEncoder.java
@@ -55,16 +55,16 @@ public class ProtobufArrayEncoder<T> extends ArrayEncoder<ProtobufWriter, T>
         if (value == null || value.length < 1) {
             return 0;
         }
-        int len = 0;
+        int size = 0;
         ProtobufEncodeable itemEncoder = (ProtobufEncodeable) this.componentEncoder;
         for (T item : value) {
-            len += itemEncoder.computeSize(item);
+            size += itemEncoder.computeSize(item);
         }
-        return len;
+        return size;
     }
 
     @Override
     public boolean requireSize() {
-        return requireSizeFlag;
+        return !componentSimpled;
     }
 }
diff --git a/src/main/java/org/redkale/convert/pb/ProtobufCoders.java b/src/main/java/org/redkale/convert/pb/ProtobufCoders.java
index 7a9cfcbb1..c12af709c 100644
--- a/src/main/java/org/redkale/convert/pb/ProtobufCoders.java
+++ b/src/main/java/org/redkale/convert/pb/ProtobufCoders.java
@@ -5,6 +5,10 @@
 package org.redkale.convert.pb;
 
 import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
 import java.util.*;
 import java.util.concurrent.atomic.*;
 import java.util.stream.Stream;
@@ -12,6 +16,8 @@ import org.redkale.convert.SimpledCoder;
 import org.redkale.convert.ext.AtomicBooleanSimpledCoder;
 import org.redkale.convert.ext.AtomicIntegerSimpledCoder;
 import org.redkale.convert.ext.AtomicLongSimpledCoder;
+import org.redkale.convert.ext.BigDecimalSimpledCoder;
+import org.redkale.convert.ext.BigIntegerSimpledCoder;
 import org.redkale.convert.ext.BoolSimpledCoder;
 import org.redkale.convert.ext.ByteSimpledCoder;
 import org.redkale.convert.ext.CharSequenceSimpledCoder;
@@ -21,16 +27,20 @@ import org.redkale.convert.ext.DateSimpledCoder;
 import org.redkale.convert.ext.DoubleSimpledCoder;
 import org.redkale.convert.ext.DurationSimpledCoder;
 import org.redkale.convert.ext.FloatSimpledCoder;
+import org.redkale.convert.ext.InetAddressSimpledCoder;
+import org.redkale.convert.ext.InetAddressSimpledCoder.InetSocketAddressSimpledCoder;
 import org.redkale.convert.ext.InstantSimpledCoder;
 import org.redkale.convert.ext.IntSimpledCoder;
 import org.redkale.convert.ext.LocalDateSimpledCoder;
 import org.redkale.convert.ext.LocalDateTimeSimpledCoder;
 import org.redkale.convert.ext.LocalTimeSimpledCoder;
+import org.redkale.convert.ext.LongAdderSimpledCoder;
 import org.redkale.convert.ext.LongSimpledCoder;
 import org.redkale.convert.ext.NumberSimpledCoder;
 import org.redkale.convert.ext.ShortSimpledCoder;
 import org.redkale.convert.ext.StringSimpledCoder;
 import org.redkale.convert.ext.StringWrapperSimpledCoder;
+import org.redkale.convert.ext.Uint128SimpledCoder;
 import org.redkale.util.*;
 
 /**
@@ -175,7 +185,7 @@ public abstract class ProtobufCoders {
     }
 
     public static class ProtobufStringSimpledCoder extends StringSimpledCoder<ProtobufReader, ProtobufWriter>
-            implements ProtobufPrimitivable, ProtobufEncodeable<ProtobufWriter, String> {
+            implements ProtobufEncodeable<ProtobufWriter, String> {
 
         public static final ProtobufStringSimpledCoder instance = new ProtobufStringSimpledCoder();
 
@@ -213,7 +223,7 @@ public abstract class ProtobufCoders {
 
     public static class ProtobufStringWrapperSimpledCoder
             extends StringWrapperSimpledCoder<ProtobufReader, ProtobufWriter>
-            implements ProtobufPrimitivable, ProtobufEncodeable<ProtobufWriter, StringWrapper> {
+            implements ProtobufEncodeable<ProtobufWriter, StringWrapper> {
 
         public static final ProtobufStringWrapperSimpledCoder instance = new ProtobufStringWrapperSimpledCoder();
 
@@ -230,7 +240,7 @@ public abstract class ProtobufCoders {
 
     public static class ProtobufCharSequenceSimpledCoder
             extends CharSequenceSimpledCoder<ProtobufReader, ProtobufWriter>
-            implements ProtobufPrimitivable, ProtobufEncodeable<ProtobufWriter, CharSequence> {
+            implements ProtobufEncodeable<ProtobufWriter, CharSequence> {
 
         public static final ProtobufCharSequenceSimpledCoder instance = new ProtobufCharSequenceSimpledCoder();
 
@@ -247,7 +257,7 @@ public abstract class ProtobufCoders {
 
     public static class ProtobufStringBuilderSimpledCoder
             extends StringBuilderSimpledCoder<ProtobufReader, ProtobufWriter>
-            implements ProtobufPrimitivable, ProtobufEncodeable<ProtobufWriter, StringBuilder> {
+            implements ProtobufEncodeable<ProtobufWriter, StringBuilder> {
 
         public static final ProtobufStringBuilderSimpledCoder instance = new ProtobufStringBuilderSimpledCoder();
 
@@ -331,7 +341,7 @@ public abstract class ProtobufCoders {
 
     public static class ProtobufLocalDateTimeSimpledCoder
             extends LocalDateTimeSimpledCoder<ProtobufReader, ProtobufWriter>
-            implements ProtobufPrimitivable, ProtobufEncodeable<ProtobufWriter, java.time.LocalDateTime> {
+            implements ProtobufEncodeable<ProtobufWriter, java.time.LocalDateTime> {
 
         public static final ProtobufLocalDateTimeSimpledCoder instance = new ProtobufLocalDateTimeSimpledCoder();
 
@@ -412,6 +422,123 @@ public abstract class ProtobufCoders {
         }
     }
 
+    public static class ProtobufBigIntegerSimpledCoder extends BigIntegerSimpledCoder<ProtobufReader, ProtobufWriter>
+            implements ProtobufEncodeable<ProtobufWriter, BigInteger> {
+
+        public static final ProtobufBigIntegerSimpledCoder instance = new ProtobufBigIntegerSimpledCoder();
+
+        @Override
+        public int computeSize(BigInteger value) {
+            if (value == null) {
+                return 0;
+            }
+            byte[] bs = value.toByteArray();
+            return ProtobufFactory.computeSInt32SizeNoTag(bs.length) + bs.length;
+        }
+
+        @Override
+        public Type getType() {
+            return BigInteger.class;
+        }
+    }
+
+    public static class ProtobufBigDecimalSimpledCoder extends BigDecimalSimpledCoder<ProtobufReader, ProtobufWriter>
+            implements ProtobufEncodeable<ProtobufWriter, BigDecimal> {
+
+        public static final ProtobufBigDecimalSimpledCoder instance = new ProtobufBigDecimalSimpledCoder();
+
+        @Override
+        public int computeSize(BigDecimal value) {
+            if (value == null) {
+                return 0;
+            }
+            return ProtobufStringSimpledCoder.instance.computeSize(value.toString());
+        }
+
+        @Override
+        public Type getType() {
+            return BigDecimal.class;
+        }
+    }
+
+    public static class ProtobufInetAddressSimpledCoder extends InetAddressSimpledCoder<ProtobufReader, ProtobufWriter>
+            implements ProtobufEncodeable<ProtobufWriter, InetAddress> {
+
+        public static final ProtobufInetAddressSimpledCoder instance = new ProtobufInetAddressSimpledCoder();
+
+        @Override
+        public int computeSize(InetAddress value) {
+            if (value == null) {
+                return 0;
+            }
+            byte[] bs = value.getAddress();
+            return ProtobufFactory.computeSInt32SizeNoTag(bs.length) + bs.length;
+        }
+
+        @Override
+        public Type getType() {
+            return InetAddress.class;
+        }
+    }
+
+    public static class ProtobufInetSocketAddressSimpledCoder
+            extends InetSocketAddressSimpledCoder<ProtobufReader, ProtobufWriter>
+            implements ProtobufEncodeable<ProtobufWriter, InetSocketAddress> {
+
+        public static final ProtobufInetSocketAddressSimpledCoder instance =
+                new ProtobufInetSocketAddressSimpledCoder();
+
+        @Override
+        public int computeSize(InetSocketAddress value) {
+            if (value == null) {
+                return 0;
+            }
+            byte[] bs = value.getAddress().getAddress();
+            return ProtobufFactory.computeSInt32SizeNoTag(bs.length) + bs.length;
+        }
+
+        @Override
+        public Type getType() {
+            return InetSocketAddress.class;
+        }
+    }
+
+    public static class ProtobufLongAdderSimpledCoder extends LongAdderSimpledCoder<ProtobufReader, ProtobufWriter>
+            implements ProtobufPrimitivable, ProtobufEncodeable<ProtobufWriter, LongAdder> {
+
+        public static final ProtobufLongAdderSimpledCoder instance = new ProtobufLongAdderSimpledCoder();
+
+        @Override
+        public int computeSize(LongAdder value) {
+            return ProtobufLongSimpledCoder.instance.computeSize(value == null ? null : value.longValue());
+        }
+
+        @Override
+        public Type getType() {
+            return LongAdder.class;
+        }
+    }
+
+    public static class ProtobufUint128SimpledCoder extends Uint128SimpledCoder<ProtobufReader, ProtobufWriter>
+            implements ProtobufEncodeable<ProtobufWriter, Uint128> {
+
+        public static final ProtobufUint128SimpledCoder instance = new ProtobufUint128SimpledCoder();
+
+        @Override
+        public int computeSize(Uint128 value) {
+            if (value == null) {
+                return 0;
+            }
+            byte[] bs = value.getBytes();
+            return ProtobufFactory.computeSInt32SizeNoTag(bs.length) + bs.length;
+        }
+
+        @Override
+        public Type getType() {
+            return Uint128.class;
+        }
+    }
+
     // ------------------------------------- boolean[] -------------------------------------
     public static class ProtobufBoolArraySimpledCoder extends SimpledCoder<ProtobufReader, ProtobufWriter, boolean[]>
             implements ProtobufPrimitivable, ProtobufEncodeable<ProtobufWriter, boolean[]> {
diff --git a/src/main/java/org/redkale/convert/pb/ProtobufCollectionEncoder.java b/src/main/java/org/redkale/convert/pb/ProtobufCollectionEncoder.java
index 2e3385dd5..a8accb488 100644
--- a/src/main/java/org/redkale/convert/pb/ProtobufCollectionEncoder.java
+++ b/src/main/java/org/redkale/convert/pb/ProtobufCollectionEncoder.java
@@ -13,7 +13,8 @@ import org.redkale.convert.*;
  * @author zhangjx
  * @param <T> T
  */
-public class ProtobufCollectionEncoder<T> extends CollectionEncoder<ProtobufWriter, T> {
+public class ProtobufCollectionEncoder<T> extends CollectionEncoder<ProtobufWriter, T>
+        implements ProtobufEncodeable<ProtobufWriter, Collection<T>> {
 
     protected final boolean componentSimpled;
 
@@ -45,4 +46,14 @@ public class ProtobufCollectionEncoder<T> extends CollectionEncoder<ProtobufWrit
         }
         out.writeArrayE();
     }
+
+    @Override
+    public int computeSize(Collection<T> value) {
+        return 0;
+    }
+
+    @Override
+    public boolean requireSize() {
+        return !componentSimpled;
+    }
 }
diff --git a/src/main/java/org/redkale/convert/pb/ProtobufEnumSimpledCoder.java b/src/main/java/org/redkale/convert/pb/ProtobufEnumSimpledCoder.java
index 4e9ecdbd9..7cefd6865 100644
--- a/src/main/java/org/redkale/convert/pb/ProtobufEnumSimpledCoder.java
+++ b/src/main/java/org/redkale/convert/pb/ProtobufEnumSimpledCoder.java
@@ -21,7 +21,7 @@ import org.redkale.util.RedkaleClassLoader;
  * @param <E> Enum的子类
  */
 public class ProtobufEnumSimpledCoder<R extends ProtobufReader, W extends ProtobufWriter, E extends Enum>
-        extends SimpledCoder<R, W, E> {
+        extends SimpledCoder<R, W, E> implements ProtobufEncodeable<W, E> {
 
     private final Map<Integer, E> values = new HashMap<>();
 
@@ -68,4 +68,14 @@ public class ProtobufEnumSimpledCoder<R extends ProtobufReader, W extends Protob
     public Class<E> getType() {
         return (Class) type;
     }
+
+    @Override
+    public int computeSize(E value) {
+        return 0;
+    }
+
+    @Override
+    public boolean requireSize() {
+        return false;
+    }
 }
diff --git a/src/main/java/org/redkale/convert/pb/ProtobufFactory.java b/src/main/java/org/redkale/convert/pb/ProtobufFactory.java
index 94e81e89f..eaa5f88f3 100644
--- a/src/main/java/org/redkale/convert/pb/ProtobufFactory.java
+++ b/src/main/java/org/redkale/convert/pb/ProtobufFactory.java
@@ -6,6 +6,10 @@
 package org.redkale.convert.pb;
 
 import java.lang.reflect.*;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
 import java.util.*;
 import java.util.concurrent.atomic.*;
 import java.util.stream.Stream;
@@ -74,6 +78,12 @@ public class ProtobufFactory extends ConvertFactory<ProtobufReader, ProtobufWrit
             this.register(AtomicBoolean.class, ProtobufCoders.ProtobufAtomicBooleanSimpledCoder.instance);
             this.register(AtomicInteger.class, ProtobufCoders.ProtobufAtomicIntegerSimpledCoder.instance);
             this.register(AtomicLong.class, ProtobufCoders.ProtobufAtomicLongSimpledCoder.instance);
+            this.register(BigInteger.class, ProtobufCoders.ProtobufBigIntegerSimpledCoder.instance);
+            this.register(BigDecimal.class, ProtobufCoders.ProtobufBigDecimalSimpledCoder.instance);
+            this.register(InetAddress.class, ProtobufCoders.ProtobufInetAddressSimpledCoder.instance);
+            this.register(InetSocketAddress.class, ProtobufCoders.ProtobufInetSocketAddressSimpledCoder.instance);
+            this.register(LongAdder.class, ProtobufCoders.ProtobufLongAdderSimpledCoder.instance);
+            this.register(Uint128.class, ProtobufCoders.ProtobufUint128SimpledCoder.instance);
 
             this.register(boolean[].class, ProtobufCoders.ProtobufBoolArraySimpledCoder.instance);
             this.register(byte[].class, ProtobufCoders.ProtobufByteArraySimpledCoder.instance);
@@ -96,6 +106,7 @@ public class ProtobufFactory extends ConvertFactory<ProtobufReader, ProtobufWrit
 
             this.register(String[].class, this.createArrayDecoder(String[].class));
             this.register(String[].class, this.createArrayEncoder(String[].class));
+            
         }
     }
 
diff --git a/src/main/java/org/redkale/convert/pb/ProtobufMapEncoder.java b/src/main/java/org/redkale/convert/pb/ProtobufMapEncoder.java
index 0f52b94e4..66df7656a 100644
--- a/src/main/java/org/redkale/convert/pb/ProtobufMapEncoder.java
+++ b/src/main/java/org/redkale/convert/pb/ProtobufMapEncoder.java
@@ -15,7 +15,8 @@ import org.redkale.convert.*;
  * @param <K> K
  * @param <V> V
  */
-public class ProtobufMapEncoder<K, V> extends MapEncoder<ProtobufWriter, K, V> {
+public class ProtobufMapEncoder<K, V> extends MapEncoder<ProtobufWriter, K, V>
+        implements ProtobufEncodeable<ProtobufWriter, Map<K, V>> {
 
     private final boolean enumtostring;
     private final int keyTag;
@@ -60,4 +61,17 @@ public class ProtobufMapEncoder<K, V> extends MapEncoder<ProtobufWriter, K, V> {
         });
         out.writeMapE();
     }
+
+    @Override
+    public int computeSize(Map<K, V> value) {
+        if (value == null || value.isEmpty()) {
+            return 0;
+        }
+        return 0;
+    }
+
+    @Override
+    public final boolean requireSize() {
+        return true;
+    }
 }
diff --git a/src/main/java/org/redkale/convert/pb/ProtobufObjectEncoder.java b/src/main/java/org/redkale/convert/pb/ProtobufObjectEncoder.java
index 8e4bc183b..282875795 100644
--- a/src/main/java/org/redkale/convert/pb/ProtobufObjectEncoder.java
+++ b/src/main/java/org/redkale/convert/pb/ProtobufObjectEncoder.java
@@ -17,6 +17,8 @@ import org.redkale.util.Utility;
 public class ProtobufObjectEncoder<T> extends ObjectEncoder<ProtobufWriter, T>
         implements ProtobufEncodeable<ProtobufWriter, T> {
 
+    protected boolean memberSizeRequired;
+
     protected ProtobufObjectEncoder(Type type) {
         super(type);
     }
@@ -29,15 +31,20 @@ public class ProtobufObjectEncoder<T> extends ObjectEncoder<ProtobufWriter, T>
         }
         Attribute attr = member.getAttribute();
         boolean enumtostring = ((ProtobufFactory) factory).enumtostring;
+        this.memberSizeRequired |= ((ProtobufEncodeable) member.getEncoder()).requireSize();
         setTag(member, ProtobufFactory.getTag(attr.field(), attr.genericType(), member.getPosition(), enumtostring));
     }
 
     @Override
     protected ProtobufWriter objectWriter(ProtobufWriter out, T value) {
-        if (out.length() > out.initOffset) {
-            return out.pollChild().configParentFunc(out);
-        }
-        return out;
+//        if (memberSizeRequired) {
+//            out.writeLength(computeSize(value));
+//        }
+//        return out;
+                if (out.length() > out.initOffset) {
+                    return out.pollChild().configParentFunc(out);
+                }
+                return out;
     }
 
     @Override
@@ -49,7 +56,11 @@ public class ProtobufObjectEncoder<T> extends ObjectEncoder<ProtobufWriter, T>
 
     @Override
     public int computeSize(T value) {
-        return 0;
+        int size = 0;
+        for (EnMember member : members) {
+            size += ((ProtobufEncodeable) member.getEncoder()).computeSize(member.getFieldValue(value));
+        }
+        return size;
     }
 
     @Override