RabbitMQ （五）实现类似Dubbo的RPC调用

最新推荐文章于 2023-06-30 11:27:53 发布
最新推荐文章于 2023-06-30 11:27:53 发布
阅读量480 收藏 1
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq rpc springboot aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fmi110/article/details/118459810
版权

springboot对rabbitMQ的接口做了封装，要实现 request/reponse 模式的调用，只需要调用 rabbitTemplate.convertSendAndReceive 方法即可，队列和交换器的设置使用topic模式即可。

  Object res = rabbitTemplate.convertSendAndReceive(exchangeName, routingKey, reqJson,message -> {
            MessageProperties messageProperties = message.getMessageProperties();
            messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);// 持久化消息
            // messageProperties.setContentType("application/json");
            String correlationId = UUID.randomUUID().toString().replaceAll("-", "");
            messageProperties.setCorrelationId(correlationId);
​
            return message;
        }, null);

下面通过spring aop、反射、rabbitmq实现一个类似dubbo的rpc调用系统：

  1. rabbitmq 使用topic工作模式

  2. springboot 创建client和server两个应用

  3. 通过注解 @Service 声明远程调用

  4. 客户端通过 RPCAspect 切面拦截本地服务调用，然后通过rabbitMQ发起远程调用，调用服务端的service并返回结果

这样就实现了一个简单的rpc过程，这里因为使用反射，并且序列化直接使用json，所以性能上可能弱鸡，后面有时间再跟dubbo的方式做个压测对比看看。

1 项目结构

项目结构图如下：

2 pom依赖

这里把项目用到的依赖全部直接贴出来

    
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
​
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>compile</scope>
        </dependency>

3 common模块

主要定义了接口和接口实现，以及自定义注解，很简单，直接贴代码

1 IService接口

package com.fmi110.rabbitmq.service;
​
public interface IService {
    public Object sayHello(String reqObjStr);
}

2 IService实现类

这里需要注意 @Service 是自定义的注解类 com.fmi110.rpc.Service ！！！

package com.fmi110.rabbitmq.service;
​
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.UUID;
import com.fmi110.rpc.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
​
/**
 * @author fmi110
 * @description 远程服务实现类
 * @date 2021/7/3 20:51
 */
@Slf4j
@Component
@Service // 这个是自定义的注解类 com.fmi110.rpc.Service！！！
public class ServiceImpl implements IService {
    @Override
    public Object sayHello(String reqObjStr) {
​
        // 模拟耗时 50 ms
        try { Thread.sleep(50);} catch (InterruptedException e) {}
​
        String now = DateUtil.now();
        String uuid   = UUID.fastUUID().toString();
        String result = now + ":" + uuid;
        log.info(">>>>> rpcService  >>>>>");
        log.info(result);
        return result;
    }
}
​

3 自定义注解

package com.fmi110.rpc;
​
import java.lang.annotation.*;
​
/**
 * @author fmi110
 * @description rpc服务注解
 * @date 2021/7/3 21:09
 */
​
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {
    String value() default "";
}

4 服务端

服务端主要执行如下内容：

  1. 监听消息队列内容

  2. 获取消息内容，反序列化请求数据，通过反射从spring上下文中获取service对象，并调用对应的方法，返回结果

1 application.properties

rabbitMQ配置：

  1. 每次只消费一条消息

  2. 使用自动ack机制，消息投递给消费者后自动从消息队列中移除

  3. 开启spring提供的消费失败自动重试机制，每条消息最多消费3次

# 应用名称
spring.application.name=rabbitmq
server.port=9089
server.servlet.context-path=/
​
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
# 指定连接的虚拟主机，可以在rabbitMQ控制台查看对应的虚拟主机的名字
spring.rabbitmq.virtual-host=my_vhost
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin
​
# 每次只消费一条消息
spring.rabbitmq.listener.simple.prefetch=1
# 开启消费者应答 ack 机制
#spring.rabbitmq.listener.simple.acknowledge-mode=manual
# 开启spring提供的retry
spring.rabbitmq.listener.simple.retry.enabled=true
spring.rabbitmq.listener.simple.retry.max-attempts=3
spring.rabbitmq.listener.simple.retry.initial-interval=3000

2 RabbitConfigRPC

配置消息队列和交换器，这里使用了 topic 模式

package com.fmi110.rabbitmq.config;
​
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
/**
 * @author fmi110
 * @description 配置交换器、队列
 * @date 2021/7/3 9:58
 */
@Slf4j
@Configuration
public class RabbitConfigRPC {
​
    String exchangeName = "rpc-exchange";
    String queueName    = "rpc-request-queue";
​
    @Bean
    public TopicExchange exchange() {
        boolean durable    = true; // 持久化
        boolean autoDelete = false; // 消费者全部解绑时不自动删除
        return new TopicExchange(exchangeName, durable, autoDelete);
    }
​
    /**
     * 持久化队列
     * @return
     */
    @Bean
    public Queue queue() {
        return new Queue(queueName, true, false, false);
    }
​
    @Bean
    public Binding binding(Queue queue,TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("rabbit.rpc");
    }
}
​

3 RabbitConsumer

消息消费者，主要执行：

  1. 从消息中提取反射调用需要的 class method arg 等信息

  2. 从 applicationContext 获取服务对象，确定调用的 method 对象，通过反射调用方法并返回结果

package com.fmi110.rabbitmq;
​
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONUtil;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;
​
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.IntFunction;
import java.util.stream.Collectors;
​
​
/**
 * @author fmi110
 * @description 消息消费者
 * @date 2021/7/1 16:08
 */
@Component
@Slf4j
public class RabbitConsumer {
​
    @Autowired
    private ApplicationContext applicationContext;
​
    @RabbitListener(queues = "rpc-request-queue")
    public Object consumeRPC(String data, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws Exception {
        return this.doInvoke(data);
    }
​
    /**
     * 反射调用
     *
     * @param data
     * @return
     * @throws ClassNotFoundException
     */
    private Object doInvoke(String data) throws ClassNotFoundException, NoSuchMethodException {
        Map       map            = JSONUtil.toBean(data, Map.class);
        String    className      = (String) map.get("class");
        String    methodName     = (String) map.get("method");
        JSONArray args           = (JSONArray) map.get("args");
        JSONArray parameterTypes = (JSONArray) map.get("parameterTypes");
        log.info(">>>>  RPC请求： {}", data);
        Class<?>   clazz   = Class.forName(className);
        Object     service = applicationContext.getBean(clazz);
        Class<?>[] clzArray   = new Class[parameterTypes.size()];
​
        for (int i = 0; i < parameterTypes.size(); i++) {
            String   clz    = (String) parameterTypes.get(i);
            Class<?> class_ = Class.forName(clz.replace("class ", ""));
            clzArray[i] = class_;
​
            // Object arg = args.get(i);
        }
        Method method = clazz.getMethod(methodName, clzArray);
        return ReflectionUtils.invokeMethod(method, service, args.stream().toArray());
    }
}
​

5 客户端

客户端需要做的事情：

  1. 定义aop切面，拦截远程服务的方法

  2. 获取服务调用的类、方法、参数等信息，封装成rpc调用的参数

  3. 通过rabbitMQ发起rpc调用，并获取返回结果

1 application.properties

主要配置rabbitMQ的链接信息

# 应用名称
spring.application.name=rabbitmq
server.port=8080
server.servlet.context-path=/
​
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
# 指定连接的虚拟主机，可以在rabbitMQ控制台查看对应的虚拟主机的名字
spring.rabbitmq.virtual-host=my_vhost
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin
​
spring.rabbitmq.listener.simple.prefetch=1
​
# 开启 publish-comfirm 机制和消息路由匹配失败退回机制
spring.rabbitmq.publisher-returns=true
spring.rabbitmq.publisher-confirm-type=correlated
# 开启消费者应答 ack 机制
#spring.rabbitmq.listener.simple.acknowledge-mode=manual

2 RabbitConfigRPC

package com.fmi110.rabbitmq.config;
​
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
/**
 * @author fmi110
 * @description 配置交换器、队列
 * @date 2021/7/3 9:58
 */
@Slf4j
@Configuration
public class RabbitConfigRPC {
​
    String exchangeName = "rpc-exchange";
    String queueName    = "rpc-request-queue";
​
    @Bean
    public TopicExchange exchange() {
        boolean durable    = true; // 持久化
        boolean autoDelete = false; // 消费者全部解绑时不自动删除
        return new TopicExchange(exchangeName, durable, autoDelete);
    }
​
    /**
     * 持久化、队列
     * @return
     */
    @Bean
    public Queue queue() {
        return new Queue(queueName, true, false, false);
    }
​
    @Bean
    public Binding binding(Queue queue,TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("rabbit.rpc");
    }
}
​

3 RPCAspect切面

这是实现远程调用的核心，拦截请求，使用 rabbitmq 实现远程调用

package com.fmi110.rabbitmq.aspect;
​
import cn.hutool.json.JSONUtil;
import com.fmi110.rabbitmq.RabbitProducer;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
​
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.HashMap;
​
/**
 * @author fmi110
 * @description RPC服务 aop切面
 * @date 2021/7/3 20:54
 */
@Component
@Slf4j
@Aspect
public class RPCAspect {
​
    @Autowired
    RabbitProducer rabbitProducer;
​
    @Pointcut("execution(public * com.fmi110.rabbitmq.service.ServiceImpl.*(..))")
    public void rpcPointCut() {
    }
​
​
    @Around("rpcPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
​
        Method          method    = signature.getMethod();
​
        // 类名
        Class target    =  point.getTarget().getClass();
​
        String className = target.getName();
        // 方法名
        String methodName = method.getName();
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        Class<?>[] parameterTypes = method.getParameterTypes();
        //请求的参数
        Object[] args = point.getArgs();
        String   argsStr    = JSONUtil.toJsonStr(args);
        log.info("class:{}",className);
        log.info("method:{}",methodName);
        log.info("args:{}",argsStr);
        HashMap<String, Object> map = new HashMap<>();
        map.put("class", className);
        map.put("method", methodName);
        map.put("parameterTypes", parameterTypes);
        map.put("args", args);
        String reqJson = JSONUtil.toJsonStr(map);
        // Object proceed = point.proceed();
        Object proceed = rabbitProducer.sendRPC(reqJson); // rabbitMQ rpc调用
        return proceed;
    }
}
​

4 RabbitProducer

rabbitMQ发送消息的逻辑

package com.fmi110.rabbitmq;
​
import cn.hutool.json.JSONUtil;
import com.rabbitmq.client.AMQP;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
​
import javax.annotation.PostConstruct;
import java.nio.charset.StandardCharsets;
import java.security.AlgorithmConstraints;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
​
/**
 * @author fmi110
 * @description 消息生产者
 * @date 2021/7/1 15:08
 */
@Component
@Slf4j
public class RabbitProducer {
    @Autowired
    RabbitTemplate rabbitTemplate;
​
    /**
     * 1 设置 confirm 回调，消息发送到 exchange 时回调
     * 2 设置 return callback ,当路由规则无法匹配到消息队列时，回调
     * <p>
     * correlationData：消息发送时，传递的参数，里边只有一个id属性，标识消息用
     */
    @PostConstruct
    public void enableConfirmCallback() {
        // #1
        /**
         * 连接不上 exchange或exchange不存在时回调
         */
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            if (!ack) {
                log.error("消息发送失败");
                // TODO 记录日志，发送通知等逻辑
            }
        });
​
        // #2
        /**
         * 消息投递到队列失败时，才会回调该方法
         * message:发送的消息
         * exchange:消息发往的交换器的名称
         * routingKey:消息携带的路由关键字信息
         */
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
            log.error("{}，exchange={},routingKey={}",replyText,exchange,routingKey);
            // TODO 路由失败后续处理逻辑
        });
    }
​
    public Object sendRPC(String reqJson) {
​
        String exchangeName = "rpc-exchange";
        String routingKey = "rabbit.rpc";
        Object res = rabbitTemplate.convertSendAndReceive(exchangeName, routingKey, reqJson,message -> {
            MessageProperties messageProperties = message.getMessageProperties();
            messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);// 持久化消息
            messageProperties.setContentType("application/json");
            String correlationId = UUID.randomUUID().toString().replaceAll("-", "");
            messageProperties.setCorrelationId(correlationId);
​
            return message;
        }, null);
        log.info(">>>>>服务端返回的响应:");
        log.info(JSONUtil.toJsonStr(res));
        return res;
    }
}
​

5 Controller

触发远程调用使用的

package com.fmi110.rabbitmq.controller;
@Slf4j
@RestController
public class TestController {
   
    @Resource(name = "serviceImpl")
    IService service;
​
    @GetMapping("/rpcCall")
    public Object rpcCall(String rpc) {
        Object result =service.sayHello("aaa");
        return result;
    }
}

6 运行效果

客户端截图：

服务端截图：

7 使用场景

在网络可以进行双向通信的场景下，实现远程调用的方式有很多，比如dubbo、EJB等，但是在某些特殊的场景下，比如某些政务系统网络，对网络通信的方向有严格的限制，有些限制外网区不能主动向内网区发起通信，只能内网通外网，这个时候如果要实现外网调用内网的服务，使用dubbo，EJB就无法实现了，这个时候就可以借助消息队列来绕过这个问题，消息服务部署在外网区，消息消费者在内网，消费者就可以连接上外网的服务，进而实现双向通信。

fmi110
关注
专栏目录
springboot | Rabbitmq 实现RPC方式 远程同步调用
洛阳泰山的博客
01-06 1885
RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP），用于在应用程序之间进行异步通信和消息传递。RabbitMQ提供了可靠的消息传递机制，具有高吞吐量、低延迟和可扩展性等特点，被广泛应用于分布式系统、微服务架构和消息驱动的应用程序中。
JVM+Tomcat+Dubbo+Rabbit MQ线程关系，阿里P7需要掌握！
a3961401的博客
10-29 6852
目录： 一、基础概念 二、进程和线程关系（进程和线程都是CPU工作时间段的描述） 1、进程概念 2、线程概念 3、进程和线程区别（资源管理方式不同） 4、进程和线程的优缺点 5、进程和线程的关系 三、它们的线程数关系（java应用） 1、存在形式和之间的关系（ jvm ←→ tomcat < dubbo , mq client > ←→ mq server ） 2、JVM线程大小分配原则 1）、线程数量的影响因素 2）、如何确定线程池大小 3）、如何解决线程数分配不合理的问题 最新2020整理收
消息中间件RabbitMQ（五）——实现RPC调用
scorpio的博客
02-06 3830
消息中间件RabbitMQ（五）——实现RPC调用
dubbo和rabbitmq对比
weixin_30306905的博客
06-04 2293
随着项目越来越大，局势就是项目拆分，大项目拆分成很多项目，各种技术也应允而生。从应用交互层面，按我的理解dubbo和rabbitmq就对比分析进行学习。dubbo和zookeeper结合 1.zookeeper基于服务发布和治理 2.dubbo注册服务和发布应用接口 配置说明： <!-- 提供方 --> <dubbo:application name="prod...
RabbitMQ学习（五）—— 实现RPC
蜗牛敲代码的博客
09-21 420
文章目录RPC RPC   先说下什么是rpc，rpc（remote procedure call）即远程过程调用，相对的是本地过程调用，本地调用就像你在一个单体系统中的用户模块去调用订单的接口。而rpc就是把系统之间调用用户系统与订单系统互不影响，而订单系统开放了接口，用户系统通过某种通信协议去调用该接口 当然，rpc的框架也有很多，比如spring cloud、阿里的dubbo、Facebo...
RabbitMQ 实现类似Dubbo的RPC调用.rar
最新发布
03-20
本篇文章将深入探讨如何利用RabbitMQ实现类似Dubbo的RPC调用。 首先，我们要理解RabbitMQ是一个开源的消息队列系统，基于AMQP（Advanced Message Queuing Protocol）协议，它主要用于在分布式系统中传递消息。与...
RabbitMQ （四）实现类似Dubbo的RPC调用
07-04
**RabbitMQ 实现类似 Dubbo 的 RPC 调用** 在分布式系统中，远程过程调用（RPC）是一种常见的通信方式，它允许一个服务直接调用另一个服务的方法，仿佛两个服务是在同一个进程中运行一样。在微服务架构中，Dubbo 是...
RabbitMQ （四）实现类似Dubbo的RPC调用.pdf
07-04
RabbitMQ （四）实现类似Dubbo的RPC调用.pdf
Springboot+rabbitmq如何实现高并发的rpc调用
热门推荐
CSDNOFZHC的博客
03-02 1万+
2019年5月最新更新：注意！并不推荐RPC式的mq调用，这么做完全没有发挥mq异步削峰的作用。之所以会有这篇文章完全是因为架构无法更改。 RPC式的mq调用，会使调用端的线程一直阻塞，中间还过了一层mq。虽然仍旧是rpc式的通信，但是效果还不如dubbo，建议需要同步的业务直接使用dubbo。 2018年8月： 一.背景 公司项目的收单前置服务A与收单服务B之间是通过ra...
RabbitMQ+Zookeeper+Dubbo+Nginx+Mysql+Redis搭建.txt
01-02
**Dubbo** 是一个高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用、智能容错和负载均衡、服务自动注册与发现。 1. **搭建Dubbo环境** - 安装Java环境。 - 下载Dubbo的示例项目...
rabbitmq对外http api调用demo
03-01
包含通过http方式调用rabbitmq对外接口,如查看队列的有效性、获取交换机等信息 包含通过http方式调用rabbitmq对外接口,如查看队列的有效性、获取交换机等信息 包含通过http方式调用rabbitmq对外接口,如查看队列的有效性、获取交换机等信息 包含通过http方式调用rabbitmq对外接口,如查看队列的有效性、获取交换机等信息
4.和rabbitMQ类似的软件有什么？RabbitMQ的协议是？效率怎么样？Rabbit有多少种模型图？Linux如何安装RabbitMQ？嘻哈的简写笔记——RabbitMQ
嘻哈怪才的博客
12-19 645
1.和rabbitMQ类似的软件有什么？RabbitMQ的协议是？效率怎么样？ ·还有类似软件有：JMS ：(含义：符合java规范的消息队列)，ActiveMQ，RocketMQ(阿里研发) ·消息队列的协议：AMQP ·RabbitMQ的开发语言是Erlang ；Erlang是一门面向高并发的编程语言(爱立信公司；1991年推出)；所以rabbitMQ的效率非常高； 2.Rabbit有多少种模型图？Linux如何安装RabbitMQ？ 7种模型图； 安装RabbitMQ步骤： (1)新建文件夹； (2)
RabbitMQ学习之基于spring-rabbitmq的RPC远程调用
任何技能都是从模仿开始，逐步升华。
11-08 5683
spring-rabbitmq中实现远程接口调用，主要在com.rabbitmq.spring.remoting下几个类： 发布服务端(Server)：RabbitInvokerServiceExporter.java 接口调用客户端(Client)：RabbitInvokerProxyFactoryBean.java，RabbitInvokerClientInterceptor.java，
2020年Java基础高频面试题汇总（1.4W字详细解析）附答案
a3961401的博客
10-27 4226
1、 Java语言有哪些特点 （1）简单易学、有丰富的类库 （2）面向对象（Java最重要的特性，让程序耦合度更低，内聚性更高） （3）与平台无关性（JVM是Java跨平台使用的根本） （4）可靠安全 （5）支持多线程 2、面向对象和面向过程的区别面向过程： 是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是为了描述某个事物在解
springboot+dubbo+redis+RabbitMQ 项目整合实例【附完整源码】
公众号-老炮说Java
07-10 5186
往期精选  ●  卸磨杀驴！程序员心中的悲愤与无奈  ●  2018.06.27阿里云宕机50分钟  ●  程序员/架构师/技术经理/技术总监是干什么的  ●  记一次内存溢的出分析经历——带给我的痛苦  ●  10步代码详解springboot集成数据库  ●  程序员加薪的技巧  ●  史上最全的java进阶书籍  ●  性能优化的一般性原则与方法  ●  记录服务上线一年来的点点滴滴  ● ...
（六）「消息队列」之 RabbitMQ 实现 RPC 远程过程调用（使用 .NET 客户端）
YMGogre的博客
06-30 1069
请求/应答 模式示例
dubbo+rabbitmq+hystrix实现服务的高可用
congge
10-29 1万+
实际业务中，我们总希望我们的系统能够尽可能做到高可用，容错性强，系统内部在服务的调用链路上，可控制性更好，这样一旦系统一旦出现问题，容易追踪问题的来源，尤其是在分布式开发，微服务化越来越流行的今天，如何达到上述的几项标准，是考量我们的系统的有效试金石，下面，我们使用dubbo模拟分布式系统环境下的调用，使用rabbitmq模拟分布式下消息的确认，以及在分布式环境下，服务调用失败的时候，采用hyst...
基于消息中间件RabbitMQ实现简单的RPC服务，jdk下载教程
m0_64867802的博客
12-07 124
即：当 Client 发送 RPC 请求时，Client 端是消息生产者，Server 端是消息消费者；当 Server 返回结果时，Server 端是消息生产者，Client 是消息消费者；发送和返回使用不同的队列。 接下来我们通过代码，详细展示一个计算斐波那契数列的 RPC 服务。 2. RPCServer 实现 2.1 Server 初始化 /** * 队列名、交换机名、路由键 */ private static final String EXCHANGE_NAME = "rpc_ex
RPC实现MQ通信的一个小例子
studyvcmfc的专栏
12-24 95
https://www.cnblogs.com/linhaifeng/p/6509571.html
使用RabbitMQ模拟Dubbo RPC调用实践
"该文档是关于使用RabbitMQ实现类似Dubbo的RPC调用的教程，主要通过SpringBoot和RabbitMQ的API进行接口封装，采用topic工作模式，结合SpringAOP、反射技术来实现远程过程调用。文档中提到了项目的结构、核心代码以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值