一种基于直连式Dubbo的动态远程服务调用方法

已于 2023-11-30 21:53:59 修改
阅读量195 收藏
点赞数
文章标签： dubbo java spring spring boot
于 2023-11-30 21:38:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rgrhiea/article/details/134719861
版权

一、背景

我在一个项目中，使用直连式Dubbo作为各节点之间的通信方式。遇到这样一个问题——即当一个消费者面对多个生产者，要根据条件动态选择其中一个生产者去调用服务时，应该如何实现？还有这样一个问题，在面对同一个生产者时，我如何根据条件动态地去调用不同的api呢？

这个问题显而易见地解决方法是，把可能用到的服务提前注入，写一个switch语句判断究竟要调用哪一个服务。可是，如果现在我们的场景是在一个P2P网络中，随时都会有服务的加入也会有服务的退出，那么就不可能在开发阶段就把所有可能用到的服务都在代码里体现出来，需要一种动态远程服务调用的方式。

我正在做的一个项目，将多个应用连接起来，形成一个对等网络。每个应用各自维护一张本地路由表，各应用之间通过本地路由表+直连式Dubbo的方式实现通信。我希望某一个应用能够通过ip地址、接口名称调用网络中所有应用的所有功能，那么势必需要实现一种动态RPC。

接下来，我将展现一种基于直连式Dubbo的动态远程服务调用方法：

二、代码实现

2.1 创建项目

2.2.1 新建项目

环境版本：jdk1.8, springboot2.4.2, dubbo2.7.1

 首先新建一个springboot项目，删掉多余的东西。

然后，在dependencyManagement里指定一下dubbo版本，我使用的式2.7.1

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.7.1</version>
            </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.1</version>
        </dependency>
    </dependencies>
</dependencyManagement>

2.2.2 api模块

新建一个module

api模块用于定义远程服务调用所需要的接口，可以定义一个测试接口，HelloService

package com.example.api.service;

public interface HelloService {
    String sayHello(String name);
}

2.2.3 provider模块

provider模块需要实现api中的接口，为了体现出1对多的关系，这里我们定义两个服务：provider-cat和provider-dog

生产者需要在配置文件中配置dubbo信息，实现HelloService接口。

cat：

首先定义好启动类，测试能够成功运行

其次，pom.xml中添加dubbo相关依赖以及api模块的依赖

<dependencies>
    <!-- dubbo -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>api</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

配置文件application.yml里配置dubbo相关信息

server:
  port: 8001
dubbo:
  registry:
    address: N/A  # 不使用注册中心
  application:
    name: cat
  scan:
    base-packages: com.example.cat.impl  # 扫描包下的服务
  protocol:
    port: 20881  # dubbo端口号

实现HelloService接口，注意，这里的@Service注解由dubbo提供（新版本的注解已经换成了@DubboService，防止歧义）。

dog：

<dependencies>
    <!-- dubbo -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>api</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <scope>compile</scope>
    </dependency>
</dependencies>
server:
  port: 8002
dubbo:
  registry:
    address: N/A  # 不使用注册中心
  application:
    name: dog
  scan:
    base-packages: com.example.dog.impl  # 扫描包下的服务
  protocol:
    port: 20882  # dubbo端口号

2.2.4 consumer模块

<dependencies>
    <!-- dubbo -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>api</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <scope>compile</scope>
    </dependency>
</dependencies>
server:
  port: 8003
dubbo:
  application:
    name: consumer

写一个controller用于测试

package com.example.consumer.controller;

import com.example.api.service.HelloService;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/consumer")
public class ConsumerController {
    @Reference(url = "dubbo://localhost:20881")
    private HelloService helloService;

    @GetMapping("/hello")
    public String hello() {
        return helloService.sayHello("文明冲浪");
    }
}

成功调用了cat服务的sayHello()方法。

2.2 根据IP地址动态指定生产者

2.2.1 使用ReferenceConfig获取生产者服务引用

在consumer下创建一个RpcHelper

package com.example.consumer.rpc;

import org.apache.dubbo.config.ReferenceConfig;
import org.springframework.stereotype.Component;

@Component
public class RpcHelper {
    /**
     * 根据地址，获取生产者服务
     * @param address IP地址
     * @param clazz 类型信息
     * @return 生产者服务
     * @param <T> 服务类型
     */
    public <T> T getServiceByAddress(String address, Class<T> clazz) {
        // 构造直连URL
        String url = "dubbo://" + address;
        // 创建引用配置
        ReferenceConfig<T> referenceConfig = new ReferenceConfig<>();
        referenceConfig.setInterface(clazz);
        referenceConfig.setUrl(url); // 设置直连URL
        // 获取服务引用
        return referenceConfig.get();
    }
}

在controller中，使用此方法，动态指定生产者

package com.example.consumer.controller;

import com.example.api.service.HelloService;
import com.example.consumer.rpc.RpcHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/consumer")
public class ConsumerController {

    @Autowired
    private RpcHelper rpcHelper;

    @GetMapping("/hello")
    public String hello(@RequestParam("id") Integer id) {
        String address1 = "localhost:20881";
        String address2 = "localhost:20882";
        if (1 == id) {
            return rpcHelper.getServiceByAddress(address1, HelloService.class).sayHello("文明冲浪");
        }
        if (2 == id) {
            return rpcHelper.getServiceByAddress(address2, HelloService.class).sayHello("文明冲浪");
        }
        return "";
    }
}

测试：当id为1时，调用了cat的方法，当id为2时，调用了dog的方法。

2.3 根据beanName与methodName动态调用功能

2.2节展示了如何条件选择不同的生产者调用功能，但是假如存在这样一种情况：消费者的代码写好了不想改了，而此时生产者又增加了新接口。这时想要调用生产者的新功能是不是就必须修改代码再重新打包部署呢？Spring提供了根据名称从上下文中获取Bean，并通过反射调用方法的功能。

在生产者侧，写一个HandlerHelper，这里以cat为例

package com.example.cat.handler;

import com.sun.istack.internal.NotNull;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Component
public class HandlerHelper implements ApplicationContextAware {
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(@NotNull ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public Object invokeMethod(String beanName, String methodName, Object... args) throws Exception {
        Object bean = applicationContext.getBean(beanName);
        Class<?> beanClass = bean.getClass();
        Class<?>[] parameterTypes = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
            parameterTypes[i] = args[i].getClass();
        }
        Method method = beanClass.getMethod(methodName, parameterTypes);
        return method.invoke(bean, args);
    }
}

在cat里定义多个service

package com.example.cat.service;

import org.springframework.stereotype.Service;

@Service("catService")
public class CatService {
    public String catName(String name) {
        return "the cat's name is " + name;
    }
}
package com.example.cat.service;

import org.springframework.stereotype.Service;

@Service("infoService")
public class InfoService {
    public String getInfo(Integer id) {
        return "get information by id: " + id;
    }
}

api模块定义HandlerService接口以及入参

package com.example.api.service;

import com.example.api.model.HandlerParam;

public interface HandlerService {
    Object handle(HandlerParam param);
}
package com.example.api.model;

import lombok.Data;

@Data
public class HandlerParam implements Serializable {
    private String serviceName;
    private String methodName;
    private Object[] params;
}

生产者cat要实现HandlerService接口

package com.example.cat.impl;

import com.example.api.model.HandlerParam;
import com.example.api.service.HandlerService;
import com.example.cat.handler.HandlerHelper;
import org.apache.dubbo.config.annotation.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Service
@Component
public class HandlerServiceImpl implements HandlerService {

    @Autowired
    private HandlerHelper handlerHelper;

    @Override
    public Object handle(HandlerParam param) {
        try {
            return handlerHelper.invokeMethod(param.getServiceName(),
                    param.getMethodName(),
                    param.getParams());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return null;
    }
}

消费者里调用：

测试：根据不同的beanName和methodName调用了不同的方法

三、总结

其实上述功能可以通过restTemplate，直接构造各种http请求来实现，还非常简单。但是rpc有其自身优势。

部分代码由AI生成。

文明冲浪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Dubbo直连调试
u011439259的博客
10-08 305
场景： 在开发及测试环境下，经常需要绕过注册中心，只测试指定服务提供者，这时候可能需要点对点直连。 步骤： 1、服务消费者pom.xml配置 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <dependency>
SpringBoot+Dubbo+Nacos实现远程服务调用
06-14
SpringBoot+Dubbo+Nacos实现远程服务调用
Dubbo 直连方式
h259077的博客
12-16 1167
Dubbo是一个分布式服务框架，致力于提高性能和透明化的RPC远程服务调用方案， 服务治理方案。
Dubbo泛化调用原理及使用
最新发布
qq_29388687的博客
07-09 904
Dubbo 泛化调用是一种在分布式服务框架 Dubbo 中实现的服务调用机制，它允许服务消费者在没有服务提供者接口定义的情况下进行服务调用。透传式调用，发起方只是想调用提供者拿到结果，没有过多的业务逻辑诉求，即使有，也是拿到结果后再继续做分发处理。代理服务，所有的请求都会经过代理服务器，而代理服务器不会感知任何业务逻辑，只是一个通道，接收数据 -> 发起调用 -> 返回结果，调用流程非常简单纯粹。前端网关。
SpringBoot+dubbo调用的直连方式（含代码样例）
adru的博客
11-01 1438
Dubbo直连是一种在Dubbo框架中的通信方式，它可以不通过注册中心，直接建立服务消费者和提供者之间的连接。这种方式的实现主要有两种：点对点直连和单边直连。主要应用场景：我们在微服务项目中写完某个模块的代码想要测试的时候，就可以采用直连的方式，如果使用注册中心得方式就可能调用到别人提供的服务。
Dubbo直连方式
qq_41172638的博客
10-29 1191
springboot dubbo 的直连方式
第二章、dubbo 框架（直连方式 dubbo）
weixin_59334478的博客
08-10 257
服务接口中的方法要给消费者使用，消费者项目需要知道接口名称和接口中的方法名称、参。消费者直接访问服务提供者，没有注册中心。消费者必须指定服务提供者的访问地址（这些信息服务提供者才知道。创建archety-webapp的model。地址访问固定的服务提供者。本机打包到maven仓库的地址。服务接口项目的类文件打包为。仓库，仓库中的提供者。...
Dubbo——初识Dubbo框架、使用直连方式实现Dubbo
m0_61083409的博客
04-01 538
文章目录： 1.Dubbo概述 1.1基本架构 1.2 dubbo支持的协议 2.直连方式实现dubbo 2.1 服务提供者的创建 2.2 服务消费者的创建 2.3 启动测试！！！ 1.Dubbo概述 Apache Dubbo (incubating) |db| 是一款高性能、轻量级的开源 Java RPC 框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。 Dubbo 是一个分布式服务框架，致力于提供高性能和透明化的 RPC 远程服务调用方案、 服务治理方
SpringBoot2.0 整合 Dubbo框架实现RPC服务远程调用方法
08-25
在服务消费方，我们可以使用 Dubbo framework 来调用远程服务： ```java @RestController @RequestMapping("/api") public class DubboController { @Autowired private DubboService dubboService; @GetMapping...
Dubbo服务只订阅与直连提供者（开发调试）.docx
11-05
直连提供者是一种特殊的调用方式，主要用于开发和调试，它允许服务消费者直接连接到指定的服务提供者，绕过注册中心。这种模式适用于快速验证服务接口的正确性，尤其是在单个服务实例或少数实例的情况下。 配置直连...
zookeeper 分布式集群管理应用， Dubbo 实现远程调用 服务降级
03-14
zooKeeper 是一个开放源码的分布式协调服务，主要为了解决分布式架构下数据一致性问题， 它是集群的管理者， 监视着集群中各个节点的状态，根据节点提交的反馈进行下一步合理操作。 最终， 将简单易用的接口和性能...
Dubbo 架构-直连
vengu733的博客
10-17 800
Apache Dubbo是一款高性能的Java RPC框架。其前身是阿里巴巴公司开源的一个高性能、轻量级的开源Java RPC框架，可以和Spring框架无缝集成。Dubbo官网地址：http://dubbo.apache.orgDubbo提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。Dubbo官方文档：https://dubbo.apache.org/zh/RPC全称为remote procedure call，即远程过程调用。
dubbo直连模式
web18484626332的博客
04-01 1383
1:Spring mvc配置直连 （1）启动参数中添加 在JVM启动参数中加入-D参数映射服务地址， -Ddubbo.properties.file=/home/aaa/conf/dubbo.properties 配置文件：dubbo.properties 这个文件放到自己相应的目录盘下，启动参数中就配置读那个目录下的这个文件，配置如下： #=====是否注册到注册中心 dubbo.registry.register=false #不注册到注册中心 dubbo.reference.demoservice=d
dubbo 直连解决方案
weixin_43935720的博客
09-29 524
要做什么 看dubbo官网后发现有dubbo直连这种方式，简化了我们开发环境的流程，不再需要启动注册中心。于是想要应用到自己项目中去。 但是各类网站看了很多dubbo直连的案例，基本都和官网一致，一个一个service 指定 url，这样的方式不太符合我们自己项目，我想要的是所有的service 使用 dubbo://127.0.0.1:20880 url dubbo版本：2.7.8 源码过程分析 这里先创建的一个又Spring 管理的Controller， 其中只有一个属性且被Reference 注解标识
Dubbo详解
freellf的专栏
04-26 1126
写操作：通过NioSocketChannel的write方法向连接里面写入数据时候是非阻塞的，马上会返回即使调用写入的线程是我们的业务线程。Netty通过在ChannelPipeline中判断调用NioSocketChannel的write的调用线程是不是其对应的NioEventLoop中的线程，如果发现不是则会把写入请求封装为WriteTask投递到其对应的NioEventLoop中的队列里面，然后等其对应的NioEventLoop中的线程轮询读写事件时候，将其从队列里面取出来执行。处理等待的“结果”。
Dubbo笔记 ⑧ : 消费者启动流程 - ReferenceConfig#get
猫吻鱼的博客
05-15 3493
一、前言 首先看一下消费者启动时序图 我们可以通过 如下代码获取到服务提供方的引用，从而进行服务调用，那么毋庸置疑，消费者的处理流程在 ReferenceConfig#get 方法中 DemoService demoService = referenceConfig.get(); 二、ReferenceConfig#get public synchronized T get() { // 检查并更新缺省配置 checkAndUpdateSubConfigs();
2.3.Dubbo的基本应用- 异步调用 、泛化调用 、动态配置
08-26 436
如果某个服务想要支持泛化调用，泛化调用可以用来做服务测试。就可以不用依赖该服务的接口。那么这个时候我们就可以。形式调用我们的服务了。接口来进行服务调用。
dubboreference注解_dubbo使用注解配置，客户端(消费端)ReferenceConfig源码简析
weixin_39568926的博客
12-20 3444
本来是要看个开源项目的，结果看着看着就看到dubbo源码里面去了，吸引力太大了，哈哈~1、如果是配置文件，在com.alibaba.dubbo.config.spring.schema.DubboNamespaceHandler完成类解析注册，当spring扫描到标签，会createbean,完成bean设置属性com.alibaba.dubbo.config.spring.ReferenceBe...
dubbo远程服务调用
09-11
Dubbo远程服务调用是一种通过网络连接调用远程服务的方式。相比本地调用，远程调用需要处理集群容错和网络通信相关的功能，因为服务提供者和服务消费者可能位于不同的机器上。Dubbo提供了一种简单的远程调用实现。 具体实现步骤如下： 1. 首先，需要配置Dubbo的远程调用方式，可以使用Dubbo内置的zookeeper作为消息服务，也可以使用其他的消息服务。 2. 然后，将Dubbo服务提供者(dubbo-server)导入到Tomcat运行，以提供服务。 3. 最后，调用Dubbo服务消费者(dubbo-client)的测试类(Consumer.java)来进行远程服务调用。 在Dubbo的远程调用中，为了解决网络通信中的粘包和拆包问题，Dubbo采用了一种特殊的分隔符号0xdabb作为魔法数，用于分割传输的数据。这样可以确保数据的准确传输。 总结起来，Dubbo远程服务调用是通过网络连接调用远程服务的一种方法，需要配置Dubbo的远程调用方式和消息服务，并使用特殊的分隔符号来解决网络通信中的粘包和拆包问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值