Dubbo之泛化调用

dubbo版本
泛化调用
Dubbo2.6.x案例
Dubbo2.7.x新特性
源码解析

dubbo版本

dubbo版本2.6.7

泛化调用

泛化调用就是服务消费者端因为某种原因并没有该服务接口，此时通过GenericService来invoke需要调用的服务方法
- 比如其他语言调用java的接口
- consumer没有provider所定义的接口
泛接口调用方式主要用于客户端没有API接口及模型类元的情况，参数及返回值中的所有POJO均用Map表示，通常用于框架集成，比如：实现一个通用的服务测试框架或者Mock框架等，可通过GenericService调用所有服务实现。
```
public interface GenericService {
    //$invoke的三个参数分别为，方法名，方法参数类型数组，方法参数数组
    Object $invoke(String method, String[] parameterTypes, Object[] args) throws GenericException;
}
```
Dubbo泛化有三种不同的序列化方式
- generic = true：对参数使用 PojoUtils 进行序列化
- generic = bean ：对参数使用 JavaBean 方式进行序列化
- generic = nativejava：对参数使用 nativejava 方式进行序列化

Dubbo2.6.x案例

接口

public interface DemoService {

    String sayHello(String name);

    SayResponseDTO sayHello(SayRequestDTO sayRequestDTO);

}

consumer配置 generic="true"

<dubbo:reference id="demoService"
                 check="false"
                 interface="cn.jannal.dubbo.facade.DemoService"
                 group="group0"
                 generic="true"
                 version="1.0.0"/>

调用代码

GenericService genericService = (GenericService) context.getBean("demoService");
Object result = genericService.$invoke(
        "sayHello",
        new String[]{"java.lang.String"},
        new Object[]{"World"});
System.out.println(result);

Map<String, Object> paramsMap = new HashMap<String, Object>();
paramsMap.put("username", "jannal");
//如果参数时POJO，则使用map即可，如果返回的是POJO，如果返回POJO将自动转成Map
//{result=Hello jannal, response from provider: 10.0.75.1:20882, class=cn.jannal.dubbo.facade.dto.SayResponseDTO}
Object result2 = genericService.$invoke(
        "sayHello",
        new String[]{"cn.jannal.dubbo.facade.dto.SayRequestDTO"},
        new Object[]{paramsMap});
System.out.println("返回:" + result2);

Dubbo2.7.x新特性

2.7.12 之后，对于Dubbo泛化调用，提供一种新的方式：直接传递字符串来完成一次调用。即用户可以直接传递参数对象的json字符串来完成一次Dubbo泛化调用

//设置generic为gson (这个是必须的，否则会报java.lang.String cannot be cast to cn.jannal.dubbo.facade.dto.SayRequestDTO)
RpcContext.getContext().setAttachment("generic", "gson");
Object result3 = genericService.$invoke(
        "sayHello",
        new String[]{SayRequestDTO.class.getName()},
        new Object[]{"{'username':'jannal'}"});
//{result=Version:V1,Hello jannal, response from provider: 172.16.117.33:20882, class=cn.jannal.dubbo.facade.dto.SayResponseDTO}
log.info("返回结果:{}", result3);

对 Google Protobuf 对象进行泛化调用

<dubbo:reference id="demoService" check="true"
                 interface="cn.jannal.dubbo.facade.DemoService"
                 generic="protobuf-json"
                 protocol="dubbo"/>

GenericService genericService = (GenericService) context.getBean("demoService");
//protobuf的泛化调用只允许传递一个类型为String的json对象来代表请求参数
Map<String, Object> helloRequest = new HashMap<>();
helloRequest.put("name", "jannal");
genericService.$invoke("sayHello", new String[]{HelloRequest.class.getCanonicalName()}, new Object[]{JSONObject.toJSONString(helloRequest)});
context.stop();

源码解析

基于dubbo2.6.7版本
Dubbo的泛化调用和泛化实现依赖于两个过滤器来完成
- Consumer端：GenericImplFilter完成了消费者端的泛化功能
- Provider端：GenericFilter完成了提供者端的泛化功能

GenericImplFilter：当消费者进行调用的是泛化实现时，会将参数信息按照指定的序列化方式进行序列化后进行泛化调用。当消费者进行泛化调用时，会将参数信息进行序列化后进行泛化调用。

/**
 * GenericImplInvokerFilter
 * 1. 用于consumer实现泛化调用，实现序列化的检查和处理
 */
@Activate(group = Constants.CONSUMER, value = Constants.GENERIC_KEY, order = 20000)
public class GenericImplFilter implements Filter {

    private static final Logger logger = LoggerFactory.getLogger(GenericImplFilter.class);
    //泛化调用参数类型
    private static final Class<?>[] GENERIC_PARAMETER_TYPES = new Class<?>[]{String.class, String[].class, Object[].class};

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        String generic = invoker.getUrl().getParameter(Constants.GENERIC_KEY);
        if (ProtocolUtils.isGeneric(generic)
                && !Constants.$INVOKE.equals(invocation.getMethodName())
                && invocation instanceof RpcInvocation) {
            //获取泛化调用的参数 ：调用方法名、调用参数类型、调用参数值等
            RpcInvocation invocation2 = (RpcInvocation) invocation;
            String methodName = invocation2.getMethodName();
            Class<?>[] parameterTypes = invocation2.getParameterTypes();
            Object[] arguments = invocation2.getArguments();

            String[] types = new String[parameterTypes.length];
            for (int i = 0; i < parameterTypes.length; i++) {
                types[i] = ReflectUtils.getName(parameterTypes[i]);
            }

            Object[] args;
            // 判断序列化方式，进行序列化。如果是 Bean 序列化方式，则使用JavaBeanSerializeUtil 进行序列化
            if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                args = new Object[arguments.length];
                for (int i = 0; i < arguments.length; i++) {
                    args[i] = JavaBeanSerializeUtil.serialize(arguments[i], JavaBeanAccessor.METHOD);
                }
            } else {
                // 否则(generic = true || nativejava) 使用PojoUtils 进行序列化
                args = PojoUtils.generalize(arguments);
            }
            // 设置调用方法为 $invoke、参数类型为GENERIC_PARAMETER_TYPES，并设置参数具体值。
            // 目的是为了让 GenericFilter 能识别出这次调用是泛化调用。
            invocation2.setMethodName(Constants.$INVOKE);
            invocation2.setParameterTypes(GENERIC_PARAMETER_TYPES);
            invocation2.setArguments(new Object[]{methodName, types, args});
            // 进行泛化调用
            Result result = invoker.invoke(invocation2);
            // 如果泛化调用没有异常, 则将结果集反序列化后返回。
            if (!result.hasException()) {
                Object value = result.getValue();
                try {
                    Method method = invoker.getInterface().getMethod(methodName, parameterTypes);
                    // 对结果进行反序列化
                    if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                        if (value == null) {
                            return new RpcResult(value);
                        } else if (value instanceof JavaBeanDescriptor) {
                            return new RpcResult(JavaBeanSerializeUtil.deserialize((JavaBeanDescriptor) value));
                        } else {
                            throw new RpcException(
                                    "The type of result value is " +
                                            value.getClass().getName() +
                                            " other than " +
                                            JavaBeanDescriptor.class.getName() +
                                            ", and the result is " +
                                            value);
                        }
                    } else {
                        return new RpcResult(PojoUtils.realize(value, method.getReturnType(), method.getGenericReturnType()));
                    }
                } catch (NoSuchMethodException e) {
                    throw new RpcException(e.getMessage(), e);
                }
            } else if (result.getException() instanceof GenericException) {
                // 返回异常是 GenericException 类型，则说明是泛化异常而非调用过程中异常。进行处理
                GenericException exception = (GenericException) result.getException();
                try {
                    String className = exception.getExceptionClass();
                    Class<?> clazz = ReflectUtils.forName(className);
                    Throwable targetException = null;
                    Throwable lastException = null;
                    try {
                        targetException = (Throwable) clazz.newInstance();
                    } catch (Throwable e) {
                        lastException = e;
                        for (Constructor<?> constructor : clazz.getConstructors()) {
                            try {
                                targetException = (Throwable) constructor.newInstance(new Object[constructor.getParameterTypes().length]);
                                break;
                            } catch (Throwable e1) {
                                lastException = e1;
                            }
                        }
                    }
                    if (targetException != null) {
                        try {
                            Field field = Throwable.class.getDeclaredField("detailMessage");
                            if (!field.isAccessible()) {
                                field.setAccessible(true);
                            }
                            field.set(targetException, exception.getExceptionMessage());
                        } catch (Throwable e) {
                            logger.warn(e.getMessage(), e);
                        }
                        result = new RpcResult(targetException);
                    } else if (lastException != null) {
                        throw lastException;
                    }
                } catch (Throwable e) {
                    throw new RpcException("Can not deserialize exception " + exception.getExceptionClass() + ", message: " + exception.getExceptionMessage(), e);
                }
            }
            return result;
        }
        // 判断消费者是否开启了泛化调用,调用方法名为 $invoke && invocation参数有三个 && generic 参数满足三种泛化方式之一
        if (invocation.getMethodName().equals(Constants.$INVOKE)
                && invocation.getArguments() != null
                && invocation.getArguments().length == 3
                && ProtocolUtils.isGeneric(generic)) {

            Object[] args = (Object[]) invocation.getArguments()[2];
            if (ProtocolUtils.isJavaGenericSerialization(generic)) {

                for (Object arg : args) {
                    if (!(byte[].class == arg.getClass())) {
                        error(generic, byte[].class.getName(), arg.getClass().getName());
                    }
                }
            } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                for (Object arg : args) {
                    if (!(arg instanceof JavaBeanDescriptor)) {
                        error(generic, JavaBeanDescriptor.class.getName(), arg.getClass().getName());
                    }
                }
            }

            ((RpcInvocation) invocation).setAttachment(
                    Constants.GENERIC_KEY, invoker.getUrl().getParameter(Constants.GENERIC_KEY));
        }
        //普通调用并返回
        return invoker.invoke(invocation);
    }

    private void error(String generic, String expected, String actual) throws RpcException {
        throw new RpcException(
                "Generic serialization [" +
                        generic +
                        "] only support message type " +
                        expected +
                        " and your message type is " +
                        actual);
    }

}

GenericFilter：判断如果是泛化操作第一步则是按照序列化方式进行反序列化，并进行服务调用

/**
 * GenericInvokerFilter.
 * 1. 用于provider，实现泛化调用，实现序列化的检查和处理
 */
@Activate(group = Constants.PROVIDER, order = -20000)
public class GenericFilter implements Filter {

    @Override
    public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException {
        if (inv.getMethodName().equals(Constants.$INVOKE)
                && inv.getArguments() != null
                && inv.getArguments().length == 3
                && !invoker.getInterface().equals(GenericService.class)) {
            //调用方法名
            String name = ((String) inv.getArguments()[0]).trim();
            //调用方法参数
            String[] types = (String[]) inv.getArguments()[1];
            //参数值
            Object[] args = (Object[]) inv.getArguments()[2];
            try {
                //反射获取方法实例
                Method method = ReflectUtils.findMethodByMethodSignature(invoker.getInterface(), name, types);
                Class<?>[] params = method.getParameterTypes();
                if (args == null) {
                    args = new Object[params.length];
                }
                // 获取泛化调用的泛化类型
                String generic = inv.getAttachment(Constants.GENERIC_KEY);
                // 泛化类型为空，则从上下文获取
                if (StringUtils.isBlank(generic)) {
                    generic = RpcContext.getContext().getAttachment(Constants.GENERIC_KEY);
                }
                // generic 为空 || 默认情况，则使用 generic=true 的方式
                if (StringUtils.isEmpty(generic)
                        || ProtocolUtils.isDefaultGenericSerialization(generic)) {
                    args = PojoUtils.realize(args, params, method.getGenericParameterTypes());
                } else if (ProtocolUtils.isJavaGenericSerialization(generic)) {
                    // generic = nativjava 的方式
                    for (int i = 0; i < args.length; i++) {
                        if (byte[].class == args[i].getClass()) {
                            try {
                                UnsafeByteArrayInputStream is = new UnsafeByteArrayInputStream((byte[]) args[i]);
                                args[i] = ExtensionLoader.getExtensionLoader(Serialization.class)
                                        .getExtension(Constants.GENERIC_SERIALIZATION_NATIVE_JAVA)
                                        .deserialize(null, is).readObject();
                            } catch (Exception e) {
                                throw new RpcException("Deserialize argument [" + (i + 1) + "] failed.", e);
                            }
                        } else {
                            throw new RpcException(
                                    "Generic serialization [" +
                                            Constants.GENERIC_SERIALIZATION_NATIVE_JAVA +
                                            "] only support message type " +
                                            byte[].class +
                                            " and your message type is " +
                                            args[i].getClass());
                        }
                    }
                } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                    // generic = bean的方式
                    for (int i = 0; i < args.length; i++) {
                        if (args[i] instanceof JavaBeanDescriptor) {
                            args[i] = JavaBeanSerializeUtil.deserialize((JavaBeanDescriptor) args[i]);
                        } else {
                            throw new RpcException(
                                    "Generic serialization [" +
                                            Constants.GENERIC_SERIALIZATION_BEAN +
                                            "] only support message type " +
                                            JavaBeanDescriptor.class.getName() +
                                            " and your message type is " +
                                            args[i].getClass().getName());
                        }
                    }
                }
                // 进行服务调用。传递给下一个 filter,最后进行服务调用
                Result result = invoker.invoke(new RpcInvocation(method, args, inv.getAttachments()));
                // 对结果集进行反序列化并返回
                if (result.hasException()
                        && !(result.getException() instanceof GenericException)) {
                    return new RpcResult(new GenericException(result.getException()));
                }
                if (ProtocolUtils.isJavaGenericSerialization(generic)) {
                    try {
                        UnsafeByteArrayOutputStream os = new UnsafeByteArrayOutputStream(512);
                        ExtensionLoader.getExtensionLoader(Serialization.class)
                                .getExtension(Constants.GENERIC_SERIALIZATION_NATIVE_JAVA)
                                .serialize(null, os).writeObject(result.getValue());
                        return new RpcResult(os.toByteArray());
                    } catch (IOException e) {
                        throw new RpcException("Serialize result failed.", e);
                    }
                } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                    return new RpcResult(JavaBeanSerializeUtil.serialize(result.getValue(), JavaBeanAccessor.METHOD));
                } else {
                    return new RpcResult(PojoUtils.generalize(result.getValue()));
                }
            } catch (NoSuchMethodException e) {
                throw new RpcException(e.getMessage(), e);
            } catch (ClassNotFoundException e) {
                throw new RpcException(e.getMessage(), e);
            }
        }
        return invoker.invoke(inv);
    }

}