Dubbo笔记 ⑱ ：泛化调用 & 泛化实现

已于 2024-02-28 17:05:42 修改
阅读量4.5k 收藏 9
点赞数
分类专栏： # Dubbo笔记篇 文章标签： dubbo
于 2021-07-21 14:59:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36882793/article/details/118090702
版权

文章目录

一、前言

本系列为个人Dubbo学习笔记，内容基于《深度剖析Apache Dubbo 核心技术内幕》, 过程参考官方源码分析文章，仅用于个人笔记记录。本文分析基于Dubbo2.7.0版本，由于个人理解的局限性，若文中不免出现错误，感谢指正。

二、泛化调用与泛化实现

Dubbo泛化有三种不同的序列化方式：

  • generic = true：对参数使用 PojoUtils 进行序列化
  • generic = bean ： 对参数使用 JavaBean 方式进行序列化
  • generic = nativejava：对参数使用 nativejava 方式进行序列化

泛化接口调用方式主要在服务消费端没有API接口类及模型类元（比如入参和出参的POJO 类）的情况下使用，其参数及返回值中没有对应的POJO 类，所以所有POJO参数均转换为Map表示。使用泛化调用时，服务消费模块不再需要引入SDK二方包。

1. 泛化调用

泛化调用 ：要在服务消费端没有API接口类及模型类元（比如入参和出参的POJO 类）的情况下使用。在进行服务调用时相关参数通过 Map 形式将数据传递，由服务提供者将 Map 转换为 实体类，再进行调用。
 
简单来说 ： 泛化调用即服务消费者端启用了泛化调用，而服务提供者端则是正常服务。

其简单Demo 如下：

// 服务接口类
public interface SimpleDemoService {
    String sayHello(String msg);
    List<String> sayHello2(String msg);
}
// 常规的服务提供者
public class GenericProvider {
    public static void main(String[] args) throws IOException {
    	// applicationname 为 simple， 接口类型为 SimpleDemoService， 实现类为 MainSimpleDemoServiceImpl
        ServiceConfig<SimpleDemoService> serviceConfig = DubboUtil.serviceConfig("simple", SimpleDemoService.class, new MainSimpleDemoServiceImpl());

        serviceConfig.export();
        System.out.println("service is start");
        System.in.read();
    }
}

// 输出
// sayHello = MainSimpleDemoServiceImpl : generic
// sayHello2 = [MainSimpleDemoServiceImpl : generic2]
public class GenericConsumer {
    public static void main(String[] args) {
        ReferenceConfig<GenericService> referenceConfig = DubboUtil.referenceConfig("simple", GenericService.class);
        referenceConfig.setGeneric(true);
        referenceConfig.setInterface("com.kingfish.service.impl.SimpleDemoService");
        GenericService genericService = referenceConfig.get();
        // 通过 GenericService.$invoke 方法指定是泛化调用，方法名为 sayHello。参数类型为 String， 参数内容为 generic
        Object sayHello = genericService.$invoke("sayHello", new String[]{"java.lang.String"}, new Object[]{"generic"});
        System.out.println("sayHello = " + sayHello);

		// 调用 sayHello2 方法
        Object sayHello2 = genericService.$invoke("sayHello2", new String[]{"java.lang.String"}, new Object[]{"generic2"});
        System.out.println("sayHello2 = " + sayHello2);
    }
}

2. 泛化实现

泛化实现：泛化接口实现主要用于服务提供端没有API接口类及模型类元（比如入参和出参的POJO 类）的情况下使用。消费者发起接口请求时需要将相关信息转换为 Map 传递给 提供者，由提供者根据信息找到对应的泛型实现来进行处理。

简单来说 ： 泛化实现即服务提供者端启用了泛化实现，而服务消费者端则是正常调用。

其简单 Demo如下：


// 服务提供者 
public class GenericProvider {
    public static void main(String[] args) throws IOException {
    	// 获取 ServiceConfig
    	// 指定 applicationname 为 simple
    	// 指定 interface 为 com.kingfish.service.impl.SimpleDemoService,
    	// 指定 Ref 为 匿名 GenericService 接口实现类
        ServiceConfig<GenericService> serviceConfig = DubboUtil.serviceConfig("simple", "com.kingfish.service.impl.SimpleDemoService", new GenericService() {
            @Override
            public Object $invoke(String method, String[] parameterTypes, Object[] args) throws GenericException {
            	// 当消费者调用SimpleDemoService 服务时会进入到该方法中，根据如下判断逻辑来处理不同的方法。
                if ("sayHello".equals(method)) {
                    return "generic sayHello " + Arrays.toString(args);
                } else if ("sayHello2".equals(method)) {
                    return Lists.newArrayList("generic sayHello2 " + Arrays.toString(args));
                }
                return null;
            }
        });
		// 启用泛化
        serviceConfig.setGeneric("true");
        // 服务暴露
        serviceConfig.export();
        System.out.println("service is start");
        // 阻塞程序，防止main方法执行结束
        System.in.read();
    }
}

// 输出 
// s = generic sayHello [111]
// strings = [generic sayHello2 [222]]
public class GenericConsumer {
    public static void main(String[] args) {
    	// 获取 SimpleDemoService 的 referenceConfig 
        ReferenceConfig<SimpleDemoService> referenceConfig = DubboUtil.referenceConfig("simple", SimpleDemoService.class);
        SimpleDemoService simpleDemoService = referenceConfig.get();
        // 调用 SimpleDemoService 的方法
        String s = simpleDemoService.sayHello("111");
        System.out.println("s = " + s);
        List<String> strings = simpleDemoService.sayHello2("222");
        System.out.println("strings = " + strings);
    }
}

三、源码实现

Dubbo 泛化调用和泛化实现依赖于下面两个过滤器 来完成。如下图：

  • GenericImplFilter：完成了消费者端的泛化功能。当请求发起时如果是泛化调用，则会将
  • GenericFilter：完成了提供者端的泛化功能
    在这里插入图片描述

1. GenericImplFilter

GenericImplFilter 作用于消费者端。

  • 当消费者进行调用的是泛化实现时，会将参数信息按照指定的序列化方式进行序列化后进行泛化调用。(这里会将调用方法指定为 $invoke，因为 GenericFilter 中判断是否是泛化调用的条件之一就是 方法名为 $invoke)
  • 当消费者进行泛化调用时，会将参数信息进行序列化后进行泛化调用。

其调用时机如下：
在这里插入图片描述

其实现如下：

/**
 * GenericImplInvokerFilter
 */
@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);
        // 1. 判断服务端是否是泛化实现
        // generic 满足三种泛化情况之一 && 调用方法名不为 $invoke && 参数类型为 RpcInvocation
        if (ProtocolUtils.isGeneric(generic)
                && !Constants.$INVOKE.equals(invocation.getMethodName())
                && invocation instanceof RpcInvocation) {
            // 1.1 获取泛化调用的参数 ：调用方法名、调用参数类型、调用参数值等
            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;
            // 1.2 判断序列化方式，进行序列化
            // 如果是 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});
            // 1.3 进行泛化调用
            Result result = invoker.invoke(invocation2);
            
			// 1.4 如果泛化调用没有异常, 则将结果集反序列化后返回。
            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;
        }
		// 2. 判断消费者是否开启了泛化调用
		// 调用方法名为 $invoke && invocation参数有三个 && generic 参数满足三种泛化方式之一
        if (invocation.getMethodName().equals(Constants.$INVOKE)
                && invocation.getArguments() != null
                && invocation.getArguments().length == 3
                && ProtocolUtils.isGeneric(generic)) {
			// 2.1 序列化参数
            Object[] args = (Object[]) invocation.getArguments()[2];
            if (ProtocolUtils.isJavaGenericSerialization(generic)) {

                for (Object arg : args) {
                    if (!(byte[].class == arg.getClass())) {
                    	// 抛出 RpcException 异常
                        error(generic, byte[].class.getName(), arg.getClass().getName());
                    }
                }
            } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                for (Object arg : args) {
                    if (!(arg instanceof JavaBeanDescriptor)) {
                    	// 抛出 RpcException 异常
                        error(generic, JavaBeanDescriptor.class.getName(), arg.getClass().getName());
                    }
                }
            }
			// 设置参数
            ((RpcInvocation) invocation).setAttachment(
                    Constants.GENERIC_KEY, invoker.getUrl().getParameter(Constants.GENERIC_KEY));
        }
        // 进行序列化调用并返回
        return invoker.invoke(invocation);
    }

}

2. GenericFilter

GenericFilter 作用于提供者。在 GenericImplFilter 中我们知道，一旦Dubbo确定了是泛化调用或提供者时泛化实现时就会将参数序列化，所以 GenericFilter 判断如果是泛化操作第一步则是按照序列化方式进行反序列化，并进行服务调用。

其调用时机如下：
在这里插入图片描述

@Activate(group = Constants.PROVIDER, order = -20000)
public class GenericFilter implements Filter {

    @Override
    public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException {
    	// 1. 消费者进行泛化调用
    	// 调用方法为 $invoke && 参数有三个 && 调用接口不是 GenericService
        if (inv.getMethodName().equals(Constants.$INVOKE)
                && inv.getArguments() != null
                && inv.getArguments().length == 3
                && !GenericService.class.isAssignableFrom(invoker.getInterface())) {
            // 1.1 参数解析
           	// 调用方法名
            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);
            }
        }
        // 2. 常规调用
        return invoker.invoke(inv);
    }

}

四、总结

Dubbo的泛化调用和泛化实现逻辑还是比较简单：

消费者进行服务调用：

  1. 如果消费者调用的提供者是泛化实现并且消费者不是泛化调用，则 GenericImplFilter 需要将调用修改为泛化调用形式，以便让GenericFilter 识别出是泛化调用。
  2. 如果消费者进行泛化调用，则 GenericImplFilter 对参数进行序列化后进行服务调用

服务端接收到服务调用：

  1. GenericFilter 会首先判断是否是泛化调用。判断条件如下：

    1. 调用方法名为 $invoke
2. 调用参数有三个
3. 调用的接口不能为 GenericService

  2. 如果满足上述条件，则 GenericFilter 对参数进行反序列化，并根据方法名、接口名等参数进行调用。否则按照常规逻辑调用。

这里我们需要清楚，对于GenericImplFilter 来说，存在泛化调用和泛化实现两种逻辑，泛化调用则需要将参数序列化， 调用泛化实现则需要将调用方法、参数等做相应的处理。而对于 GenericFilter 只需要关注是否是泛化调用。如果是泛化调用，则根据参数确定调用的接口、方法以及参数信息进行调用。

注：

  1. 如果提供者暴露服务接口为 GenericService， 则默认其开启了泛化调用，generic 默认为 true。
    这一点在 服务暴露时 ServiceConfig#checkAndUpdateSubConfigs 方法在填充默认配置时判断，如下：
    在这里插入图片描述
  2. 当提供者服务为泛化实现时，消费者引用的url会和提供者的url 在RegistryDirectory#toInvokers 方法中进行属性合并，消费者在合并时将 genric 属性进行了合并，激活了消费者端的 GenericImplFilter 过滤器。

以上：内容部分参考
《深度剖析Apache Dubbo 核心技术内幕》
https://dubbo.apache.org/zh/docs/v2.7/dev/source/
https://blog.csdn.net/prestigeding/article/details/80727275
https://blog.csdn.net/prestigeding/article/details/82947183
如有侵扰，联系删除。 内容仅用于自我记录学习使用。如有错误，欢迎指正

猫吻鱼
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Dubbo接口的泛化调用
mianhuabushitang的博客
08-23 5953
Dubbo接口的泛化调用
dubbo-boot:封装dubbo实现微框架
05-26
主控层 : 接口服务主控层是有各原子服务串织成的, 接口服务主控层通过Dubbo方式调用接入接出模块，负责整个产品的业务逻辑，在业务层中没有具体的操作，只有业务调用. zookeepr： dubbo服务注册中心，通过zookeeper ...
代码技巧——dubbo泛化调用
娜娜米的博客
08-28 1793
「泛化调用」方式调用dubbo接口，即Dubbo的调用方，在不引入服务接口类的情况下，远程调用其他Dubbo服务；下面给出代码示例；
接口测试平台（一）——dubbo的泛化调用
baixiaozheng的博客
06-29 581
  最近想有没有一个可以兼容各种分布式接口测试的工具，github上搜到很多开源的，但实际运行起来，和自己想的并不一致，于是自己研究一下试着写一下。   先对当前主流的dubbo，springcloud的feign接口，普通http接口做适配   dubbo消费端，一般必须依赖服务端提供的api包，没有api接口包，就无法直接引用，此时可以使用泛型调用，调用方可不用知道被调用方的具体细节...
Dubbo 面试题（十一）
闲依农圃邻，偶似山林客。
04-29 721
1. Dubbo3 如何实现泛化调用 ？ 2. 简述什么是 Dubbo3 回声测试 ? 3. 简述Dubbo 超时设置有哪些方式 ？ 4. 简述Dubbo 配置文件是如何加载到 Spring 中的 ？ 5. 简述Dubbo 动态代理策略有哪些 ？ 6. 老版本的Dubbo如何升级到Dubbo3 ？ 7. Dubbo3 如何配置对于 Netty4 支持 ?
Dubbo泛化调用入门到精通
m0_67401153的博客
09-02 1175
consumer 端 | | provider 端 || | | || | | || | | || | | || | | | || | | || | | || | | || | | |基于PojoUtils 简化复杂对象，不用引入二方包。
dubbo泛化调用
qq_36042938的博客
09-03 3705
dubbo泛化调用
RPC泛化调用普及&应用（看完还不懂的可以用钱砸死我）
风雨一更
03-23 1万+
一、概念镇场子，场景知其然 1.什么是泛化调用？ 泛化调用是指在调用方没有服务方提供的API（SDK）的情况下，对服务方进行调用，并且可以拿到调用结果。 2.什么时候会用到泛化调用？ 测试集成平台 我们要搭建一个统一的测试平台，可以让各个业务方在测试平台中通过输入接口、分组名、方法名以及参数值，在线测试自己发布的RPC服务。这时我们就有一个问题要解决，我们搭建统一的测试平台实际上是作为各个RPC服务的调用端，而在RPC框架的使用中，调用端是需要依赖服务提供方提供的接口API的，而统一测试平台不可能依赖所有服
手写RPC框架之泛化调用
BASK2311的博客
06-27 1298
什么是泛化调用泛化调用就是在不依赖服务方接口jar包的情况下进行调用，包括对调用方法的泛化、参数的泛化和返回值的泛化。泛化调用的使用场景常规的PRC调用都是客户端依赖服务端提供的接口jar包，然后利用动态代理技术，像调用本地方法一样调用远程方法，但是有些场景下客户端无法依赖jar包，也要调用远程方法，这时就需要用到泛化调用了。
一看就会！Dubbo 泛化调用简明教程——含不同类型入参处理
wzz2333的博客
01-10 2265
Dubbo 泛化调用入门教程，案例详细，简洁易懂！
Apache Dubbo：Dubbo高级特性：服务版本与分组
07-12
Apache Dubbo：Dubbo高级特性：服务版本与分组 Dubbo是著名的RCP框架，文档内有干货，提供代码和可复现的命令，值得借鉴。
Apache Dubbo：Dubbo高级特性：服务降级与熔断实战
最新发布
07-12
Apache Dubbo：Dubbo高级特性：服务降级与熔断实战 Dubbo是著名的RCP框架，文档内有干货，提供代码和可复现的命令，值得借鉴。
Apache Dubbo：Dubbo服务治理：限流与降级策略
07-12
Apache Dubbo：Dubbo服务治理：限流与降级策略 Dubbo是著名的RCP框架，文档内有干货，提供代码和可复现的命令，值得借鉴。
Apache Dubbo：Dubbo服务治理：负载均衡与容错机制
07-12
Apache Dubbo：Dubbo服务治理：负载均衡与容错机制 Dubbo是著名的RCP框架，文档内有干货，提供代码和可复现的命令，值得借鉴。
Dubbo泛化调用
li12412414的博客
01-13 1360
场景一：我们要搭建一个统一的测试平台，可以让各个业务方在测试平台中通过输入接口、分组名、方法名以及参数值，在线测试自己发布的 RPC 服务。这时我们就有一个问题要解决，我们搭建统一的测试平台实际上是作为各个 RPC 服务的调用端，而在 RPC 框架的使用中，调用端是需要依赖服务提供方提供的接口 API 的，而统一测试平台不可能依赖所有服务提供方的接口 API。我们不能因为每有一个新的服务发布，就去修改平台的代码以及重新上线。这时我们就需要让调用端在没有服务提供方提供接口的情况下，仍然可以正常地发起 RPC
超越接口：探索Dubbo的泛化调用机制
热门推荐
todoitbo的博客
04-09 7万+
本文将深入探讨 Dubbo 中的泛化调用（Generic Invocation）功能，这是 Dubbo 框架中一个强大且灵活的特性。我们将介绍泛化调用的基本概念和工作原理，并提供实际示例，演示如何在 Dubbo 微服务架构中灵活地使用泛化调用实现动态 RPC 调用。无论您是 Dubbo 的新手还是经验丰富的用户，本文都将为您揭示如何利用泛化调用提高微服务架构的灵活性和可扩展性。
Dubbo的泛化调用demo
吃西瓜不吐葡萄皮
01-18 968
application.propertise dubbo.address=zookeeper://127.0.0.1:2181 # application.name 自定义 应用名称 application.name=api-test apigateway.dubbo.protocol.name=dubbo apigateway.dubbo.protocol.port=20880 初始化 A...
【工作小札】apache-dubob泛化调用小例
洋YANG的博客
03-31 1688
小七最近在开发网关应用，因为下层业务系统之间都是dubbo协议通信，不再提供http接口，所以考虑在网关层需要做一下协议转换，即http转dubbo。参考dubbo官网，发现dubbo提供了泛化调用来解决这个场景的问题。因为小七公司已经从对接规范上，杜绝了多参数调用的情况，所有这里小七就只列举几种常见的单参数调用例子。{“data”:{“name”:“第七人格”,“id”:“1”,“class”:“xxxx”}}因为泛型存在类型擦除的情况，所以我们在进行泛化调用的时候，需要申明泛型类型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猫吻鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值