fix: preserve generic parameter types during deserialization to fix List<Byte> → List<Integer> [3.3]

dubbo-common/src/main/java/org/apache/dubbo/rpc/model/MethodDescriptor.java

@@ -48,6 +48,18 @@ public interface MethodDescriptor {
 
     Class<?>[] getParameterClasses();
 
+    /**
+     * Retrieves the generic parameter types of the method.
+     * <p>
+     * For parameterized parameters like {@code List<Byte>}, this returns the
+     * {@link java.lang.reflect.ParameterizedType} instead of just the raw {@code Class}.
+     *
+     * @return the generic parameter types
+     */
+    default Type[] getGenericParameterTypes() {
+        return getParameterClasses();
+    }
+
     Class<?> getReturnClass();
 
     Type[] getReturnTypes();

dubbo-common/src/main/java/org/apache/dubbo/rpc/model/ReflectionMethodDescriptor.java

@@ -44,6 +44,7 @@ public class ReflectionMethodDescriptor implements MethodDescriptor {
     public final String methodName;
     private final String[] compatibleParamSignatures;
     private final Class<?>[] parameterClasses;
+    private final Type[] genericParameterTypes;
     private final Class<?> returnClass;
     private final Type[] returnTypes;
     private final String paramDesc;
@@ -57,6 +58,7 @@ public ReflectionMethodDescriptor(Method method) {
         this.method = method;
         this.methodName = method.getName();
         this.parameterClasses = method.getParameterTypes();
+        this.genericParameterTypes = method.getGenericParameterTypes();
         this.returnClass = method.getReturnType();
         Type[] returnTypesResult;
         try {
@@ -149,6 +151,11 @@ public Class<?>[] getParameterClasses() {
         return parameterClasses;
     }
 
+    @Override
+    public Type[] getGenericParameterTypes() {
+        return genericParameterTypes;
+    }
+
     @Override
     public String getParamDesc() {
         return paramDesc;

dubbo-common/src/test/java/org/apache/dubbo/rpc/model/ReflectionMethodDescriptorTest.java

@@ -20,7 +20,10 @@
 import org.apache.dubbo.rpc.model.MethodDescriptor.RpcType;
 import org.apache.dubbo.rpc.support.DemoService;
 
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Map;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -89,6 +92,47 @@ void addAttribute() {
         Assertions.assertEquals(attr, method.getAttribute(attr));
     }
 
+    @Test
+    void getGenericParameterTypes_nonGeneric() {
+        Type[] types = method.getGenericParameterTypes();
+        Assertions.assertEquals(1, types.length);
+        Assertions.assertEquals(String.class, types[0]);
+    }
+
+    @Test
+    void getGenericParameterTypes_withGenericParam() throws NoSuchMethodException {
+        ReflectionMethodDescriptor md =
+                new ReflectionMethodDescriptor(DemoService.class.getDeclaredMethod("processBytes", List.class));
+        Type[] genericTypes = md.getGenericParameterTypes();
+        Class<?>[] rawTypes = md.getParameterClasses();
+
+        Assertions.assertEquals(1, genericTypes.length);
+        Assertions.assertEquals(List.class, rawTypes[0]);
+        Assertions.assertInstanceOf(ParameterizedType.class, genericTypes[0]);
+
+        ParameterizedType pt = (ParameterizedType) genericTypes[0];
+        Assertions.assertEquals(List.class, pt.getRawType());
+        Assertions.assertEquals(Byte.class, pt.getActualTypeArguments()[0]);
+    }
+
+    @Test
+    void getGenericParameterTypes_mixedParams() throws NoSuchMethodException {
+        ReflectionMethodDescriptor md = new ReflectionMethodDescriptor(
+                DemoService.class.getDeclaredMethod("processMultiple", String.class, List.class, Map.class));
+        Type[] genericTypes = md.getGenericParameterTypes();
+        Class<?>[] rawTypes = md.getParameterClasses();
+
+        Assertions.assertEquals(3, genericTypes.length);
+        // String param: generic type == raw type
+        Assertions.assertSame(rawTypes[0], genericTypes[0]);
+        // List<Short>: generic type is ParameterizedType
+        Assertions.assertInstanceOf(ParameterizedType.class, genericTypes[1]);
+        Assertions.assertEquals(Short.class, ((ParameterizedType) genericTypes[1]).getActualTypeArguments()[0]);
+        // Map<String, Byte>: generic type is ParameterizedType
+        Assertions.assertInstanceOf(ParameterizedType.class, genericTypes[2]);
+        Assertions.assertEquals(Byte.class, ((ParameterizedType) genericTypes[2]).getActualTypeArguments()[1]);
+    }
+
     @Test
     void testEquals() {
         try {

dubbo-common/src/test/java/org/apache/dubbo/rpc/support/DemoService.java

@@ -16,6 +16,13 @@
  */
 package org.apache.dubbo.rpc.support;
 
+import java.util.List;
+import java.util.Map;
+
 public interface DemoService {
     String sayHello(String name);
+
+    void processBytes(List<Byte> data);
+
+    void processMultiple(String name, List<Short> values, Map<String, Byte> mapping);
 }

dubbo-common/src/test/java/org/apache/dubbo/rpc/support/DemoServiceImpl.java

@@ -16,9 +16,18 @@
  */
 package org.apache.dubbo.rpc.support;
 
+import java.util.List;
+import java.util.Map;
+
 public class DemoServiceImpl implements DemoService {
     @Override
     public String sayHello(String name) {
         return "hello " + name;
     }
+
+    @Override
+    public void processBytes(List<Byte> data) {}
+
+    @Override
+    public void processMultiple(String name, List<Short> values, Map<String, Byte> mapping) {}
 }

dubbo-rpc/dubbo-rpc-dubbo/src/main/java/org/apache/dubbo/rpc/protocol/dubbo/DecodeableRpcInvocation.java

@@ -47,6 +47,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.lang.reflect.Type;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Supplier;
@@ -80,6 +81,8 @@ public class DecodeableRpcInvocation extends RpcInvocation implements Codec, Dec
 
     protected final FrameworkModel frameworkModel;
 
+    private Type[] genericParameterTypes;
+
     protected final transient Supplier<CallbackServiceCodec> callbackServiceCodecFactory;
 
     private static final boolean CHECK_SERIALIZATION =
@@ -237,6 +240,7 @@ protected Class<?>[] drawPts(String path, String version, String desc, Class<?>[
             MethodDescriptor methodDescriptor = serviceDescriptor.getMethod(getMethodName(), desc);
             if (methodDescriptor != null) {
                 pts = methodDescriptor.getParameterClasses();
+                this.genericParameterTypes = methodDescriptor.getGenericParameterTypes();
                 this.setReturnTypes(methodDescriptor.getReturnTypes());
 
                 // switch TCCL
@@ -271,10 +275,15 @@ protected Class<?>[] drawPts(String path, String version, String desc, Class<?>[
     }
 
     protected Object[] drawArgs(ObjectInput in, Class<?>[] pts) throws IOException, ClassNotFoundException {
-        Object[] args;
-        args = new Object[pts.length];
+        Object[] args = new Object[pts.length];
         for (int i = 0; i < args.length; i++) {
-            args[i] = in.readObject(pts[i]);
+            if (genericParameterTypes != null
+                    && i < genericParameterTypes.length
+                    && genericParameterTypes[i] != pts[i]) {
+                args[i] = in.readObject(pts[i], genericParameterTypes[i]);
+            } else {
+                args[i] = in.readObject(pts[i]);
+            }
         }
         return args;
     }

dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/ReflectionPackableMethod.java

@@ -106,7 +106,8 @@ public ReflectionPackableMethod(
 
             // server
             this.responsePack = new WrapResponsePack(serialization, url, serializeName, actualResponseType);
-            this.requestUnpack = new WrapRequestUnpack(serialization, url, allSerialize, actualRequestTypes);
+            this.requestUnpack = new WrapRequestUnpack(
+                    serialization, url, allSerialize, actualRequestTypes, method.getGenericParameterTypes());
         }
         this.allSerialize = allSerialize;
     }
@@ -473,16 +474,20 @@ private class WrapRequestUnpack implements WrapperUnPack {
 
         private final Class<?>[] actualRequestTypes;
 
+        private final Type[] genericParameterTypes;
+
         private final Collection<String> allSerialize;
 
         private WrapRequestUnpack(
                 MultipleSerialization serialization,
                 URL url,
                 Collection<String> allSerialize,
-                Class<?>[] actualRequestTypes) {
+                Class<?>[] actualRequestTypes,
+                Type[] genericParameterTypes) {
             this.serialization = serialization;
             this.url = url;
             this.actualRequestTypes = actualRequestTypes;
+            this.genericParameterTypes = genericParameterTypes;
             this.allSerialize = allSerialize;
         }
 
@@ -510,7 +515,14 @@ private Object[] deserializeFromWrapper(TripleCustomerProtocolWrapper.TripleRequ
             for (int i = 0; i < wrapper.getArgs().size(); i++) {
                 ByteArrayInputStream bais =
                         new ByteArrayInputStream(wrapper.getArgs().get(i));
-                ret[i] = serialization.deserialize(url, wrapper.getSerializeType(), actualRequestTypes[i], bais);
+                if (genericParameterTypes != null
+                        && i < genericParameterTypes.length
+                        && genericParameterTypes[i] != actualRequestTypes[i]) {
+                    ret[i] = serialization.deserialize(
+                            url, wrapper.getSerializeType(), actualRequestTypes[i], genericParameterTypes[i], bais);
+                } else {
+                    ret[i] = serialization.deserialize(url, wrapper.getSerializeType(), actualRequestTypes[i], bais);
+                }
             }
             return ret;
         }

dubbo-serialization/dubbo-serialization-api/src/main/java/org/apache/dubbo/common/serialize/DefaultMultipleSerialization.java

@@ -21,6 +21,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.lang.reflect.Type;
 
 public class DefaultMultipleSerialization implements MultipleSerialization {
 
@@ -46,6 +47,17 @@ public Object deserialize(URL url, String serializeType, Class<?> clz, InputStre
         return in.readObject(clz);
     }
 
+    @Override
+    public Object deserialize(URL url, String serializeType, Class<?> clz, Type type, InputStream os)
+            throws IOException, ClassNotFoundException {
+        serializeType = convertHessian(serializeType);
+        final Serialization serialization = url.getOrDefaultFrameworkModel()
+                .getExtensionLoader(Serialization.class)
+                .getExtension(serializeType);
+        final ObjectInput in = serialization.deserialize(null, os);
+        return in.readObject(clz, type);
+    }
+
     private String convertHessian(String ser) {
         if (ser.equals("hessian4")) {
             return "hessian2";

dubbo-serialization/dubbo-serialization-api/src/main/java/org/apache/dubbo/common/serialize/MultipleSerialization.java

@@ -23,6 +23,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.lang.reflect.Type;
 
 @SPI(scope = ExtensionScope.FRAMEWORK)
 public interface MultipleSerialization {
@@ -31,4 +32,9 @@ public interface MultipleSerialization {
 
     Object deserialize(URL url, String serializeType, Class<?> clz, InputStream os)
             throws IOException, ClassNotFoundException;
+
+    default Object deserialize(URL url, String serializeType, Class<?> clz, Type type, InputStream os)
+            throws IOException, ClassNotFoundException {
+        return deserialize(url, serializeType, clz, os);
+    }
 }

dubbo-serialization/dubbo-serialization-hessian2/src/main/java/org/apache/dubbo/common/serialize/hessian2/Hessian2ObjectInput.java

@@ -22,8 +22,17 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
+import java.util.TreeSet;
 
 import com.alibaba.com.caucho.hessian.io.Hessian2Input;
 
@@ -119,14 +128,96 @@ public <T> T readObject(Class<T> cls) throws IOException, ClassNotFoundException
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public <T> T readObject(Class<T> cls, Type type) throws IOException, ClassNotFoundException {
         if (!Objects.equals(
                 mH2i.getSerializerFactory().getClassLoader(),
                 Thread.currentThread().getContextClassLoader())) {
             mH2i.setSerializerFactory(hessian2FactoryManager.getSerializerFactory(
                     Thread.currentThread().getContextClassLoader()));
         }
-        return readObject(cls);
+        T result = readObject(cls);
+        if (type instanceof ParameterizedType && result != null) {
+            result = (T) convertCollectionElementsIfNeeded(result, (ParameterizedType) type);
+        }
+        return result;
+    }
+
+    private Object convertCollectionElementsIfNeeded(Object obj, ParameterizedType type) {
+        Type[] typeArgs = type.getActualTypeArguments();
+
+        if (obj instanceof Collection && typeArgs.length >= 1 && typeArgs[0] instanceof Class) {
+            Class<?> elementType = (Class<?>) typeArgs[0];
+            if (isNarrowNumberType(elementType)) {
+                Collection<?> src = (Collection<?>) obj;
+                Collection<Object> converted = createCompatibleCollection(src, src.size());
+                for (Object e : src) {
+                    converted.add(convertNumber(e, elementType));
+                }
+                return converted;
+            }
+        }
+
+        if (obj instanceof Map && typeArgs.length >= 2) {
+            Class<?> keyType = typeArgs[0] instanceof Class ? (Class<?>) typeArgs[0] : null;
+            Class<?> valType = typeArgs[1] instanceof Class ? (Class<?>) typeArgs[1] : null;
+            boolean convertKey = keyType != null && isNarrowNumberType(keyType);
+            boolean convertVal = valType != null && isNarrowNumberType(valType);
+            if (convertKey || convertVal) {
+                Map<Object, Object> src = (Map<Object, Object>) obj;
+                Map<Object, Object> converted = new java.util.LinkedHashMap<>(src.size());
+                for (Map.Entry<Object, Object> entry : src.entrySet()) {
+                    Object k = convertKey ? convertNumber(entry.getKey(), keyType) : entry.getKey();
+                    Object v = convertVal ? convertNumber(entry.getValue(), valType) : entry.getValue();
+                    converted.put(k, v);
+                }
+                return converted;
+            }
+        }
+        return obj;
+    }
+
+    private static boolean isNarrowNumberType(Class<?> type) {
+        return type == Byte.class
+                || type == byte.class
+                || type == Short.class
+                || type == short.class
+                || type == Float.class
+                || type == float.class;
+    }
+
+    private static Object convertNumber(Object value, Class<?> targetType) {
+        if (!(value instanceof Number)) {
+            return value;
+        }
+        Number num = (Number) value;
+        if (targetType == Byte.class || targetType == byte.class) {
+            return num.byteValue();
+        }
+        if (targetType == Short.class || targetType == short.class) {
+            return num.shortValue();
+        }
+        if (targetType == Float.class || targetType == float.class) {
+            return num.floatValue();
+        }
+        return value;
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private static Collection<Object> createCompatibleCollection(Collection<?> source, int size) {
+        if (source instanceof LinkedList) {
+            return new LinkedList<>();
+        }
+        if (source instanceof LinkedHashSet) {
+            return new LinkedHashSet<>(size);
+        }
+        if (source instanceof TreeSet) {
+            return new TreeSet(((TreeSet) source).comparator());
+        }
+        if (source instanceof Set) {
+            return new HashSet<>(size);
+        }
+        return new ArrayList<>(size);
     }
 
     public InputStream readInputStream() throws IOException {