专栏首页中间件兴趣圈源码分析Dubbo 泛化调用与泛化实现原理

源码分析Dubbo 泛化调用与泛化实现原理

微信公众号:[中间件兴趣圈] 作者简介:《RocketMQ技术内幕》作者

本文将重点分析Dubbo的两个重要特性:泛化调用与泛化实现。

泛化引用:

通常是服务调用方没有引入API包,也就不包含接口中的实体类,故服务调用方只能提供Map形式的数据,由服务提供者根据Map转化成对应的实体。

泛化实现

泛化实现,是指服务提供者未引入API包,也就不包含接口用于传输数据的实体类,故客户端发起调用前,需要将mode转化为Map。 从上面分析,其实所谓的泛化本质上就是Map与Bean的转换。

GenericImplFilter实现原理

  1public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
  2        String generic = invoker.getUrl().getParameter(Constants.GENERIC_KEY);
  3        if (ProtocolUtils.isGeneric(generic)                                                                                  // @1
  4                && !Constants.$INVOKE.equals(invocation.getMethodName())
  5                && invocation instanceof RpcInvocation) {
  6            RpcInvocation invocation2 = (RpcInvocation) invocation;
  7            String methodName = invocation2.getMethodName();
  8            Class<?>[] parameterTypes = invocation2.getParameterTypes();
  9            Object[] arguments = invocation2.getArguments();
 10
 11            String[] types = new String[parameterTypes.length];
 12            for (int i = 0; i < parameterTypes.length; i++) {
 13                types[i] = ReflectUtils.getName(parameterTypes[i]);
 14            }
 15
 16            Object[] args;
 17            if (ProtocolUtils.isBeanGenericSerialization(generic)) {
 18                args = new Object[arguments.length];
 19                for (int i = 0; i < arguments.length; i++) {
 20                    args[i] = JavaBeanSerializeUtil.serialize(arguments[i], JavaBeanAccessor.METHOD);
 21                }
 22            } else {
 23                args = PojoUtils.generalize(arguments);
 24            }
 25
 26            invocation2.setMethodName(Constants.$INVOKE);
 27            invocation2.setParameterTypes(GENERIC_PARAMETER_TYPES);
 28            invocation2.setArguments(new Object[]{methodName, types, args});
 29            Result result = invoker.invoke(invocation2);
 30
 31            if (!result.hasException()) {
 32                Object value = result.getValue();
 33                try {
 34                    Method method = invoker.getInterface().getMethod(methodName, parameterTypes);
 35                    if (ProtocolUtils.isBeanGenericSerialization(generic)) {
 36                        if (value == null) {
 37                            return new RpcResult(value);
 38                        } else if (value instanceof JavaBeanDescriptor) {
 39                            return new RpcResult(JavaBeanSerializeUtil.deserialize((JavaBeanDescriptor) value));
 40                        } else {
 41                            throw new RpcException(
 42                                    "The type of result value is " +
 43                                            value.getClass().getName() +
 44                                            " other than " +
 45                                            JavaBeanDescriptor.class.getName() +
 46                                            ", and the result is " +
 47                                            value);
 48                        }
 49                    } else {
 50                        return new RpcResult(PojoUtils.realize(value, method.getReturnType(), method.getGenericReturnType()));
 51                    }
 52                } catch (NoSuchMethodException e) {
 53                    throw new RpcException(e.getMessage(), e);
 54                }
 55            } else if (result.getException() instanceof GenericException) {
 56                GenericException exception = (GenericException) result.getException();
 57                try {
 58                    String className = exception.getExceptionClass();
 59                    Class<?> clazz = ReflectUtils.forName(className);
 60                    Throwable targetException = null;
 61                    Throwable lastException = null;
 62                    try {
 63                        targetException = (Throwable) clazz.newInstance();
 64                    } catch (Throwable e) {
 65                        lastException = e;
 66                        for (Constructor<?> constructor : clazz.getConstructors()) {
 67                            try {
 68                                targetException = (Throwable) constructor.newInstance(new Object[constructor.getParameterTypes().length]);
 69                                break;
 70                            } catch (Throwable e1) {
 71                                lastException = e1;
 72                            }
 73                        }
 74                    }
 75                    if (targetException != null) {
 76                        try {
 77                            Field field = Throwable.class.getDeclaredField("detailMessage");
 78                            if (!field.isAccessible()) {
 79                                field.setAccessible(true);
 80                            }
 81                            field.set(targetException, exception.getExceptionMessage());
 82                        } catch (Throwable e) {
 83                            logger.warn(e.getMessage(), e);
 84                        }
 85                        result = new RpcResult(targetException);
 86                    } else if (lastException != null) {
 87                        throw lastException;
 88                    }
 89                } catch (Throwable e) {
 90                    throw new RpcException("Can not deserialize exception " + exception.getExceptionClass() + ", message: " + exception.getExceptionMessage(), e);
 91                }
 92            }
 93            return result;
 94        }
 95
 96        if (invocation.getMethodName().equals(Constants.$INVOKE)                             // @2
 97                && invocation.getArguments() != null
 98                && invocation.getArguments().length == 3
 99                && ProtocolUtils.isGeneric(generic)) {
100
101            Object[] args = (Object[]) invocation.getArguments()[2];
102            if (ProtocolUtils.isJavaGenericSerialization(generic)) {
103
104                for (Object arg : args) {
105                    if (!(byte[].class == arg.getClass())) {
106                        error(byte[].class.getName(), arg.getClass().getName());
107                    }
108                }
109            } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {
110                for (Object arg : args) {
111                    if (!(arg instanceof JavaBeanDescriptor)) {
112                        error(JavaBeanDescriptor.class.getName(), arg.getClass().getName());
113                    }
114                }
115            }
116
117            ((RpcInvocation) invocation).setAttachment(
118                    Constants.GENERIC_KEY, invoker.getUrl().getParameter(Constants.GENERIC_KEY));
119        }
120        return invoker.invoke(invocation);
121    }

代码@1:该分支是泛化实现,如果是泛化实现,则根据generic的值进行序列化,然后调用$invoke方法,因为服务端实现为泛化实现,所有的服务提供者实现GenericeServer#$invoker方法,其实现方式就是将Bean转换成Map。这些细节将在服务端GenericFilter序列中详细讲解。

代码@2:泛化引用,调用方是直接通过GenericService#$invoke方法进行调用,以此来区分是泛化调用还是泛化引用,那不经要问,为什么invoker.getUrl().getParameter(Constants.GENERIC_KEY)中获取的generic参数到底是< dubbo:service/>中配置的还是< dubbo:reference/>中配置的呢?其实不难理解:

  1. dubbo:servcie未配置而dubbo:reference配置了,则代表的是消费端的,必然是泛化引用。
  2. dubbo:servcie配置而dubbo:reference未配置了,则代表的是服务端的,必然是泛化实现。
  3. 如果两者都配置了,generic以消费端为主。消费端参数与服务端参数的合并在服务发现时,注册中心首先会将服务提供者的URL通知消费端,然后消费端会使用当前的配置与服务提供者URL中的配置进行合并,如遇到相同参数,则消费端覆盖服务端。

注:这里我就不深入去探讨其实现细节,因为这部分在下文源码分析GenericFilter时会详细介绍Map与Bean转换的细节,包含是否序列化,之所以这里没有细说,主要是因为我先看的是GenericFilter。

GenericFilter实现原理

 1@Activate(group = Constants.PROVIDER, order = -20000)
 2public class GenericFilter implements Filter {
 3    @Override
 4    public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException {
 5        if (inv.getMethodName().equals(Constants.$INVOKE)
 6                && inv.getArguments() != null
 7                && inv.getArguments().length == 3
 8                && !ProtocolUtils.isGeneric(invoker.getUrl().getParameter(Constants.GENERIC_KEY))) {       // @1
 9            String name = ((String) inv.getArguments()[0]).trim();
10            String[] types = (String[]) inv.getArguments()[1];
11            Object[] args = (Object[]) inv.getArguments()[2];
12            try {
13                Method method = ReflectUtils.findMethodByMethodSignature(invoker.getInterface(), name, types);             // @2
14                Class<?>[] params = method.getParameterTypes();
15                if (args == null) {
16                    args = new Object[params.length];
17                }
18                String generic = inv.getAttachment(Constants.GENERIC_KEY);
19                if (StringUtils.isEmpty(generic)
20                        || ProtocolUtils.isDefaultGenericSerialization(generic)) {                                                             // @3
21                    args = PojoUtils.realize(args, params, method.getGenericParameterTypes());
22                } else if (ProtocolUtils.isJavaGenericSerialization(generic)) {                                                             // @4
23                    for (int i = 0; i < args.length; i++) {
24                        if (byte[].class == args[i].getClass()) {
25                            try {
26                                UnsafeByteArrayInputStream is = new UnsafeByteArrayInputStream((byte[]) args[i]);
27                                args[i] = ExtensionLoader.getExtensionLoader(Serialization.class)
28                                        .getExtension(Constants.GENERIC_SERIALIZATION_NATIVE_JAVA)
29                                        .deserialize(null, is).readObject();
30                            } catch (Exception e) {
31                                throw new RpcException("Deserialize argument [" + (i + 1) + "] failed.", e);
32                            }
33                        } else {
34                            throw new RpcException(
35                                    "Generic serialization [" +
36                                            Constants.GENERIC_SERIALIZATION_NATIVE_JAVA +
37                                            "] only support message type " +
38                                            byte[].class +
39                                            " and your message type is " +
40                                            args[i].getClass());
41                        }
42                    }
43                } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {                                                 // @5
44                    for (int i = 0; i < args.length; i++) {
45                        if (args[i] instanceof JavaBeanDescriptor) {
46                            args[i] = JavaBeanSerializeUtil.deserialize((JavaBeanDescriptor) args[i]);
47                        } else {
48                            throw new RpcException(
49                                    "Generic serialization [" +
50                                            Constants.GENERIC_SERIALIZATION_BEAN +
51                                            "] only support message type " +
52                                            JavaBeanDescriptor.class.getName() +
53                                            " and your message type is " +
54                                            args[i].getClass().getName());
55                        }
56                    }
57                }
58                Result result = invoker.invoke(new RpcInvocation(method, args, inv.getAttachments()));    // @6
59                if (result.hasException()
60                        && !(result.getException() instanceof GenericException)) {
61                    return new RpcResult(new GenericException(result.getException()));
62                }
63                if (ProtocolUtils.isJavaGenericSerialization(generic)) {                                                        // @7
64                    try {
65                        UnsafeByteArrayOutputStream os = new UnsafeByteArrayOutputStream(512);
66                        ExtensionLoader.getExtensionLoader(Serialization.class)
67                                .getExtension(Constants.GENERIC_SERIALIZATION_NATIVE_JAVA)
68                                .serialize(null, os).writeObject(result.getValue());
69                        return new RpcResult(os.toByteArray());
70                    } catch (IOException e) {
71                        throw new RpcException("Serialize result failed.", e);
72                    }
73                } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {
74                    return new RpcResult(JavaBeanSerializeUtil.serialize(result.getValue(), JavaBeanAccessor.METHOD));
75                } else {
76                    return new RpcResult(PojoUtils.generalize(result.getValue()));
77                }
78            } catch (NoSuchMethodException e) {
79                throw new RpcException(e.getMessage(), e);
80            } catch (ClassNotFoundException e) {
81                throw new RpcException(e.getMessage(), e);
82            }
83        }
84        return invoker.invoke(inv);  
85    }
86}

代码@1:如果方法名为$invoker,并且只有3个参数,并且服务端实现为非返回实现,则认为本次服务调用时客户端泛化引用服务端,客户端的泛化调用,需要将请求参数反序列化为该接口真实的pojo对象。

代码@2:根据接口名(API类)、方法名、方法参数类型列表,根据反射机制获取对应的方法。

代码@3:处理普通的泛化引用调用,即处理,只需要将参数列表Object[]反序列化为pojo即可,具体的反序列化为PojoUtils#realize,其实现原理如下:

在JAVA的世界中,pojo通常用map来表示,也就是一个Map可以用来表示一个对象的值,那从一个Map如果序列化一个对象呢?其关键的要素是要在Map中保留该对象的类路径名。例如现在有这样一个对象:

 1public class Student {
 2    private int id;
 3    private String name;
 4    private Team team;
 5    //省略get set方法
 6}
 7public class Team {
 8    private int id;
 9    private String name;
10    // 省略其他属性与set get方法
11}
12用Map表示Student为:
13{
14    “class”:"somepackeage.Student",
15    "id":1,
16    "name":"dingw",
17    "team":
18    {
19        "class" : "somepackage.Team",
20        "id":2,
21        "name":"t"
22    }
23}

也就是通过class来标识该Map需要反序列化的pojo类型。

代码@4:处理< dubbo:reference generic="nativejava" /> 启用泛化引用,并使用nativejava序列化参数,在服务端这边通过nativejava反序列化参数成pojo对象。

代码@5:处理< dubbo:reference generic="bean" /> 启用泛化引用,并使用javabean序列化参数,在服务端这边通过javabean反序列化参数成pojo对象。

代码@6:序列化API方法中声明的类型,构建new RpcInvocation(method, args, inv.getAttachments())调用环境,继续调用后续过滤器。

代码@7:处理执行结果,如果是nativejava或bean,则需要对返回结果序列化,如果是generic=true,则使用PojoUtils.generalize序列化,也即将pojo序列化为Map。

泛化调用与泛化引用,就介绍到这里了。

本文分享自微信公众号 - 中间件兴趣圈(dingwpmz_zjj),作者:丁威

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-04-10

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • RocketMQ ACL使用指南

    RocketMQ在4.4.0版本开始支持ACL。ACL是access control list的简称,俗称访问控制列表。访问控制,基本上会涉及到用户、资源、权限...

    丁威
  • Elasticsearch Mapping parameters(主要参数一览)

    指定分词器。elasticsearch是一款支持全文检索的分布式存储系统,对于text类型的字段,首先会使用分词器进行分词,然后将分词后的词根一个一个存储在倒排...

    丁威
  • 源码分析Dubbo服务调用日志(accesslog参数)实现原理

    谈到服务调用日志,大家恐怕第一想到就是如果开启了这个参数,会影响性能。那真实的情况是怎么样了?性能损耗到底有多大呢?在实践中我们如何使用该功能呢?本文将详细分析...

    丁威
  • 对2019政府工作报告通信部分的深入解读

    众所周知,全国人大政府工作报告,是国家宏观政策的风向标。所以,每个行业,都会关注报告中和本行业相关的内容,并认真进行分析和研究。

    鲜枣课堂
  • ApiBoot 新官网发布 - 丰富使用文档

    ApiBoot为接口服务而生,基于SpringBoot完成扩展、自动化配置,通过封装一系列Starter来让调用者快速集成组件,降低学习、使用门槛,提高开发效率...

    恒宇少年
  • ApiBoot发布2.1.4-RC1版本,修复无法拉取jar到本地问题

    ApiBoot为接口服务而生,基于SpringBoot完成扩展、自动化配置,通过封装一系列Starter来让调用者快速集成组件,降低学习、使用门槛,提高开发效率...

    恒宇少年
  • 科学计算拓展排序 sort_index sort_values值计数value_countsgroupby分组apply聚合

    前言:这里开始涉及到数据处理,例如给你几千行几千列的数据,对这些数据进行分类聚合 排序 sort_index sort_values 参数:asc...

    DC童生
  • ApiBoot 2.0.9.RELEASE 版本发布,支持自定义Oauth2授权方式

    ApiBoot是一款基于SpringBoot1.x,SpringBoot2.x的接口服务集成基础框架,内部提供了框架的封装集成、使用扩展、自动化配置等,让接口开...

    恒宇少年
  • 微信小程序|顶部导航标签栏

    当我们在一个小程序中想要查看某些信息,总是以页面顶部的一个导航栏展示出来,点击该导航栏上的各个标签则会出现对应页面内容。而如何实现顶部的标签导航,则需要我们引入...

    算法与编程之美
  • 投资人关注新零售哪些运营数据

    你是否也想获得1V1面见金牌投资人的机会?你是否也想现场签订投资意向?心动不如行动,点击参与云+创业 X 智见传媒 投资百人战活动,将有机会得到顶级投资人的深度...

    云加创业小助手

扫码关注云+社区

领取腾讯云代金券