精华内容
下载资源
问答
  • 聊一聊微服务之间的通讯方式

    万次阅读 多人点赞 2021-08-11 23:18:04
    服务调用与事件驱动属于微服务调间用的两种方式,常规上可以看做是同步与异步。其两种方式会应用于不同的场景。 同步,属于直接调用,适用于处理并发不高,且需要另一个服务调用结果场景。 异步,属于事件驱动方式,...

    介绍

    同步通讯与异步通讯属于微服务调间用的两种方式,其两种方式会应用于不同的场景,使用的合理可以是系统性能翻倍增长。

    同步

    同步调用是在某个服务调用后,会之间调用其他服务,在此之间会之间等待所以的服务完成调用,这几就是同步调用。

    缺点

    1. 耦合性
      在这里插入图片描述
      有一个很神奇的生物,叫做产品经理,经常脑洞大开。有时候开发人员觉得,已经开发完了没有问题了,但这个是产品经理总觉缺点什么,加个短信吧。这时,你就得加个发短信的业务,就得在支付服务里改动代码添加,发短信代码。假如说有一天添加了优惠价的功能,支付后是不是的扣除响应的优惠,你以为到这就结束了,加个积分系统,促使他下次还来买。等等这样需求该来该去谁受的了,所以呢这就是耦合性。

    2. 性能下降
      在这里插入图片描述
      当支付服务耗时 50 ms、订单服务耗时 150ms等,那么支付整个动作耗时就是加起来的总和。当大量的并发进来了,系统抗的住吗,这个就是性能下降吞吐量也下降。

    3. 资源浪费
      当进行支付服务完成后,调用订单服务、仓库服务、休息服务,此事支付服务就在干等着啥也不干,也会一直占用着系统资源。当请求少了还没什么,当请求多了十万、百万等。这就是资源的利用率,资源浪费。

    在这里插入图片描述

    1. 级联失败
      在这里插入图片描述
      当用支付同步调用时,如果我们的仓促服务抗不住这么大的并发,就会对后面的请求造成阻塞,一两等多了之后,就会对支付服务造成系统异常,影响正常业务,出现系统bug。这就是级联失败问题。

    总结

    所以综上所述,虽然同步调用有着很高的时效性,但也会带来各种各样的问题。任何技术都有自己的优点与缺点,在合适的场景下使用,即是最合理的。

    在这里插入图片描述

    异步

    上面讲解了同步调用,它存在着众多的不足。可以使用异步调用进行解决,但异步也不是完美的,它也有着对应的缺点。

    异步调用的实现方式,最常用的就是事件驱动。

    在这里插入图片描述记得上面将的同步调用吧,支付服务调用之后,会调用订单等,支付一直会等待着直到全部服务完成调用。而异步是支付服务支付成功后,发布一个事件,之后立马返回结果给用户。

    说到这可能有人会问,那其他服务不调用了吗?不,当然调用,记得支付成功后发布的事件吧

    其他的服务会订阅这个事件,从而触发一系列的服务调用。

    优点

    1. 服务解耦
      在这里插入图片描述
      如果有一天产品经理,想添加一个积分功能,之需要添加积分服务模块,订阅事件即可。
      如果有一天产品经理觉得短信成本有点高,想去掉,此时将短信服务取消订阅即可。

    这两种情况,不像同步时,去更改支付服务里面的代码对吧。这就是服务解耦。

    1. 性能提升,吞吐量提高
      在这里插入图片描述
      异步调用时,此时我们的总耗时已经不再是所有的服务总和,而是支付服务+发布事件耗时 60 ms。至于其他服务调用及每个服务抗并发的能力等会根据自身进行消费处理。这样就提升了吞吐量,系统的性能也得到的提升。

    2. 没有强依赖关系,没有级联问题
      在这里插入图片描述
      异步调用,当仓储服务异常时,只是这一个服务异常,没有影响支付服务。因为支付完成后,发布个事件,没有像同步一样调用仓储服务,会应为仓储服务异常,而导致支付服务失败。

    3. 流量削峰
      在这里插入图片描述

    当只有一个用户请求时,支付服务、订单服务、仓储服务、短信服务可以进行快速的请求。

    突然,有大量用户支付,一下子来个三个甚至更多,如果我们的擦仓储服务处理并发只能处理两个,那么borker就会给他两个,处理完成后会再向,borker进行拿取根据自身的消费能力进行处理。

    如果使用同步,三个甚至更多一下子给到仓储服务,此时仓储服务会因为并发而系统异常,从而导致支付服务失败。不能处理后边的并发请求。

    异步情况下,borker就像一个大坝一样拦着,起到一个缓冲左右,订单、仓储等根据自身能进行处理。所以这就是流量削峰。比如秒杀系统经常这样使用架构。

    缺点

    看完了优点,可能有的同学会发现,无论是解耦。流量削峰等都依赖了 borker。

    如果说在并发情况下扛不住那么高的并发 borker 挂了,此时系统是不是就瘫痪了,所以们对 borker 有着极高的可用性及并发性的要求。日常使用的有 kafka、rabbitMQ 。


    使用场景

    如果说在支付完成后,需要使用等待其他服务调用的结果,这必须得用同步,因为异步只是通知去做事件,支付成功后,其他服务接口支付服务不知道不清楚。

    如果对之后的结果,我不需要知道而且对并发要求高、吞吐量要求高、还需解除之间的耦合,这样就的使用异步。

    展开全文
  • 1.基本理解:https://www.cnblogs.com/stulzq/p/11581967.html 2.本人理解: /* 总体理解: 1.本文档等于定义(数据交换)接口规则 2.客户端和服务端必须一样 3.... 作为微服务通信可能带来的问题? 

    1.基本理解:https://www.cnblogs.com/stulzq/p/11581967.html

    2.本人理解:

    /*
    总体理解:
    1.本文档等于定义(数据交换)接口规则
    2.客户端和服务端必须一样
    3.点对点服务
    4.一般一个工具或者应用都搭载一个服务和客户端
    5.先有接口(本文档)然后需要的话各自实现
    */

    实现:

    1.服务端:

    2.客户端:

    源码:https://download.csdn.net/download/weixin_42401291/21889691

    ---------------------

    进阶:定义多个接口的使用

    1、修改.proto文件

    增加服务监听接口

    2、在GreeterService中添加实现监听的方法

    3.同理客户端也要修改.proto文件

    4.客户端调用

    ---------------

    多文件接口:

    但是需要修改项目文件:比较麻烦

     

     

    借鉴:下面的第五点

    https://www.cnblogs.com/stulzq/p/11581967.html

    -------------------

    思考:

    这样的grpc通信效率和原始的类之间的调用是否相等?

    作为微服务通信可能带来的问题? 

    展开全文
  • 微服务间通信

    2021-06-17 12:40:33
    1.什么是微服务 定义:基于单体应用围绕业务进行服务拆分,拆分出来每一个服务独立应用独立运行独立都署 运行在自己计算机进程中基于分布式服务管理 2.如何解决微服务的服务间通信问题? a.HTTP Rest 方式 使用http...

    1.什么是微服务

    定义:基于单体应用围绕业务进行服务拆分,拆分出来每一个服务独立应用独立运行独立都署
    运行在自己计算机进程中基于分布式服务管理

    2.如何解决微服务的服务间通信问题?

    a.HTTP Rest 方式 使用http协议进行数据传递JsoN springcloud 使用http协议传递参数
    b.RPC 方式 远程过程调用 二进制
    OSI: 物理层、数据链路层、网络层、传输层(RPC)、会话层、表示层、应用层(Http)

    3.如何在java代码中发起http方式请求?

    a.spring框架提供Httpclient对象RestTemplate发起—个http请求

    4 .实现服务间通信写一个案例

    1.开发两个测试服务用户服务users订单服务orders
    2.用户服务订单服务都是两个独立springboot应用
    3.两个服务都引入consul client依赖&健康检查依赖

           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-starter-consul-discovery</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-actuator</artifactId>
           </dependency>
    

    4 .配置两个服务application. properties

    		spring.cloud.consul.host=localhost
    		spring.cloud.consul.port=8500
    

    5.在入口类中加入服务注册client注解

    //User
    @SpringBootApplication
    @EnableDiscoveryClient
    public class UserApplication {
        public static void main(String[] args) {
            SpringApplication.run(UserApplication.class,args);
        }
    }
    //order
    @SpringBootApplication
    @EnableDiscoveryClient
    public class OrderApplication {
        public static void main(String[] args) {
            SpringApplication.run(OrderApplication.class,args);
        }
    }
    
    
    展开全文
  • 微服务之间是如何独立通讯的 同步 REST HTTP 协议 REST 请求在微服务中是最为常用的一种通讯方式,它依赖于 HTTP\HTTPS 协议。RESTFUL 的特点是: 每一个 URI 代表 1 种资源 客户端使用 GET、POS

    什么是微服务

    • 微服务架构是一个分布式系统,按照业务进行划分成为不同的服务单元,解决单体系统性能等不足。
    • 微服务是一种架构风格,一个大型软件应用由多个服务单元组成。系统中的服务单元可以单独部署,各个服务单元之间是松耦合的。

    微服务概念起源:Microservices

    微服务之间是如何独立通讯的

    同步

    REST HTTP 协议

    REST 请求在微服务中是最为常用的一种通讯方式,它依赖于 HTTP\HTTPS 协议。RESTFUL 的特点是:

    1. 每一个 URI 代表 1 种资源
    2. 客户端使用 GET、POST、PUT、DELETE 4 个表示操作方式的动词对服务端资源进行操作:GET 用来获取资源,POST 用来新建资源(也可以用于更新资源),PUT 用来更新资源,DELETE 用来删除资源
    3. 通过操作资源的表现形式来操作资源
    4. 资源的表现形式是 XML 或者 HTML
    5. 客户端与服务端之间的交互在请求之间是无状态的,从客户端到服务端的每个请求都必须包含理解请求所必需的信息

    举个例子,有一个服务方提供了如下接口:

    @RestController
    @RequestMapping("/communication")
    public class RestControllerDemo {
        @GetMapping("/hello")
        public String s() {
            return "hello";
        }
    }
    

    另外一个服务需要去调用该接口,调用方只需要根据 API 文档发送请求即可获取返回结果。

    @RestController
    @RequestMapping("/demo")
    public class RestDemo{
        @Autowired
        RestTemplate restTemplate;
    
        @GetMapping("/hello2")
        public String s2() {
            String forObject = restTemplate.getForObject("http://localhost:9013/communication/hello", String.class);
            return forObject;
        }
    }
    

    通过这样的方式可以实现服务之间的通讯。

    RPC TCP 协议

    RPC(Remote Procedure Call)远程过程调用,简单的理解是一个节点请求另一个节点提供的服务。它的工作流程是这样的:

    1. 执行客户端调用语句,传送参数
    2. 调用本地系统发送网络消息
    3. 消息传送到远程主机
    4. 服务器得到消息并取得参数
    5. 根据调用请求以及参数执行远程过程(服务)
    6. 执行过程完毕,将结果返回服务器句柄
    7. 服务器句柄返回结果,调用远程主机的系统网络服务发送结果
    8. 消息传回本地主机
    9. 客户端句柄由本地主机的网络服务接收消息
    10. 客户端接收到调用语句返回的结果数据

    举个例子。

    首先需要一个服务端:

    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.lang.reflect.Method;
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * RPC 服务端用来注册远程方法的接口和实现类
     */
    public class RPCServer {
        private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    
        private static final ConcurrentHashMap<String, Class> serviceRegister = new ConcurrentHashMap<>();
    
        /**
         * 注册方法
         * @param service
         * @param impl
         */
        public void register(Class service, Class impl) {
            serviceRegister.put(service.getSimpleName(), impl);
        }
    
        /**
         * 启动方法
         * @param port
         */
        public void start(int port) {
            ServerSocket socket = null;
            try {
                socket = new ServerSocket();
                socket.bind(new InetSocketAddress(port));
                System.out.println("服务启动");
                System.out.println(serviceRegister);
                while (true) {
                    executor.execute(new Task(socket.accept()));
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        private static class Task implements Runnable {
            Socket client = null;
    
            public Task(Socket client) {
                this.client = client;
            }
    
            @Override
            public void run() {
                ObjectInputStream input = null;
                ObjectOutputStream output = null;
                try {
                    input = new ObjectInputStream(client.getInputStream());
                    // 按照顺序读取对方写过来的内容
                    String serviceName = input.readUTF();
                    String methodName = input.readUTF();
                    Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
                    Object[] arguments = (Object[]) input.readObject();
                    Class serviceClass = serviceRegister.get(serviceName);
                    if (serviceClass == null) {
                        throw new ClassNotFoundException(serviceName + " 没有找到!");
                    }
                    Method method = serviceClass.getMethod(methodName, parameterTypes);
                    Object result = method.invoke(serviceClass.newInstance(), arguments);
    
                    output = new ObjectOutputStream(client.getOutputStream());
                    output.writeObject(result);
                } catch (Exception e) {
                    e.printStackTrace();
    
                } finally {
                    try {
                        // 这里就不写 output!=null才关闭这个逻辑了
                        output.close();
                        input.close();
                        client.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }
        }
    
    }
    
    

    其次需要一个客户端:

    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.net.InetSocketAddress;
    import java.net.Socket;
    
    /**
     * RPC 客户端
     */
    public class RPCclient<T> {
        /**
         * 通过动态代理将参数发送过去到 RPCServer ,RPCserver 返回结果这个方法处理成为正确的实体
         */
        public static <T> T getRemoteProxyObj(final Class<T> service, final InetSocketAddress addr) {
    
            return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service}, new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
                    Socket socket = null;
                    ObjectOutputStream out = null;
                    ObjectInputStream input = null;
                    try {
                        socket = new Socket();
                        socket.connect(addr);
    
                        // 将实体类,参数,发送给远程调用方
                        out = new ObjectOutputStream(socket.getOutputStream());
                        out.writeUTF(service.getSimpleName());
                        out.writeUTF(method.getName());
                        out.writeObject(method.getParameterTypes());
                        out.writeObject(args);
    
                        input = new ObjectInputStream(socket.getInputStream());
                        return input.readObject();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        out.close();
                        input.close();
                        socket.close();
                    }
                    return null;
                }
            });
    
        }
    
    }
    
    

    再来一个测试的远程方法。

    public interface Tinterface {
        String send(String msg);
    }
    
    public class TinterfaceImpl implements Tinterface {
        @Override
        public String send(String msg) {
            return "send message " + msg;
        }
    }
    
    

    测试代码如下:

    import com.huifer.admin.rpc.Tinterface;
    import com.huifer.admin.rpc.TinterfaceImpl;
    
    import java.net.InetSocketAddress;
    
    public class RunTest {
        public static void main(String[] args) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    RPCServer rpcServer = new RPCServer();
                    rpcServer.register(Tinterface.class, TinterfaceImpl.class);
                    rpcServer.start(10000);
                }
            }).start();
            Tinterface tinterface = RPCclient.getRemoteProxyObj(Tinterface.class, new InetSocketAddress("localhost", 10000));
            System.out.println(tinterface.send("rpc 测试用例"));
    
        }
    }
    
    

    输出 send message rpc 测试用例

    异步

    消息中间件

    常见的消息中间件有 Kafka、ActiveMQ、RabbitMQ、RocketMQ ,常见的协议有 AMQP、MQTTP、STOMP、XMPP。这里不对消息队列进行拓展了,具体如何使用还是请移步官网。

    展开全文
  • 1 首先在ruoyi-api中注册个service 2.指定服务关联的单体 3.ruoyi-web单体 就可以通过上面send 注册的服务,直接与send 通讯
  • 微服务架构中,不同的微服务有不同的请求地址,各个微服务之间通过互相调用完成用户请求。客户端要完成用户请求,需要调用很多微服务接口。 比如: 用户查看一个商品详情页,详情页包含了商品基本信息,商品价格...
  • 接下来在整个微服务架构中,我们比较关心的就是服务间的服务该如何调用,有哪些调用方式?总结:在springcloud中服务间调用方式主要是使用 http restful方式进行服务间调用1|0 1. 基于RestTemplate的服务调用在上面...
  • 微服务架构

    2021-01-22 19:43:47
    一、微服务架构: 一组小的服务;独立的进程;轻量级通信;基于业务能力;独立部署;无集中式管理; 二、微服务利弊: 利: 1、强模块化边界; 2、可独立部署; 3、技术多样性; 弊: 1、分布式复杂性...
  • 聊聊微服务的分布式通讯微服务目前比较热,但是微服务最难的还是可靠性问题,因为一个系统微服务可能几百个,网络调用频繁,网络的容错性就非常重要,因为对于分布式系统,需要默认网络环境是不可靠的,丢包或堵塞等...
  • 微服务网关zuul

    2021-02-18 22:32:00
    zuul 解决问题: 不同的微服务一般会有不同...如果让客户端直接与各个微服务通讯,可能会有很多问题: 客户端会请求多个不同的服务,需要维护不同的请求地址,增加开发难度 在某些场景下存在跨域请求的问题 加大身份认
  • 微服务网关Zuul

    2021-03-15 16:35:37
    如果让客户端直接与各个微服务通讯,可能会有很多问题: 客户端会请求多个不同的服务,需要维护不同的请求地址,增加开发难度 在某些场景下存在跨域请求的问题 加大身份认证的难度,每个微服务需要独立认证 因此,...
  • 如题,我目前有需要用 Laravel 设计微服务架构的需求,但能找到的相关资料不多目前已有的一个思考方向是使用 K8S 统合各个独立的 Laravel 小服务,再开放统一对外的 API Gateway但碰到一个问题是各个服务间要如何在...
  • 微服务之间是如何独立通讯的 1.远程过程调用(Remote Procedure Invocation):        也就是我们常说的服务的注册与发现        直接通过远程过程调用来访问别的service...
  • 一、首先声明gRPC接口 这里引入的是最新的gRpc-core 1.37版本, 采用的...要实现gRpc通讯, 先定义接口以及入参出参信息 syntax = "proto3"; option java_multiple_files = true; option java_package = "com.grpc.s
  • 微服务中,采用中心化的思想,将单体应用拆分为多个中心,中心之间分布部署,那么面临的问题之一就是,中心与中心之间怎么通信: 一、微服务的通信协议 IPC IPC 全称是 Inter Process Communication,中文大致...
  • 什么是微服务? 对于微服务业界并没有一个统一的、标准的定义(While there is no precise definition of this architectural style ) 。 但通在其常而言,微服务架构是一种架构模式或者说是一种架构风格,它提倡将...
  • 学习微服务你必须了解的设计模式
  • 微服务

    2021-05-27 11:11:57
    微服务的发展历史:https://blog.csdn.net/xxxlllbbb/article/details/105107628 单体应用于微服务的对比:https://blog.csdn.net/qinaye/article/details/82840625 serverless无服务的发展...
  • 微服务专题

    2021-11-24 17:48:27
    面试宝典之微服务专题
  • 微服务架构演变过程

    2021-02-08 23:28:33
    微服务架构演变过程微服务架构演变过程1、传统架构2、分布式架构3、SOA面向服务架构4、微服务架构微服务架构产生的原因微服务架构基本概念微服务架构与SOA架构的不同微服务架构会产生哪些问题为什么我们要使用...
  • 微服务之服务分层

    2020-12-29 01:09:12
    我觉得说微服务的服务分层前,有必要说一下微服务的演进历史和微服务架构的一些常用设计模式一、微服务演进历史MVC (Modle View Controller) 架构: 当业务规模很小时,将所有功能都部署在同一个进程中,通过双机...
  • 微服务和分布式的联系与区别什么?分布式只是一种手段把不同的机器分散在不同的地方,然后这些机器间相互协助完成业务,而微服务是一种特殊的分布式。分布式将一个大的系统划分为多个业务模块,业务模块分别部署到...
  • 简单的说,微服务是架构设计方式,分布式是系统部署方式,两者概念不同??微服务是啥?这里不引用书本上的复杂概论了,简单来说微服务就是很小的服务,小到一个服务只对应一个单一的功能,只做一件事。这个服务可以...
  • Spring Cloud及微服务简介

    千次阅读 2020-12-29 00:03:25
    最近在看微服务编排的东西,看到一篇入门博客,私以为不错,再次分享下:...微服务架构是一种架构模式,它提倡将单一应用程序划分成一组小的服务,服务之间互相协调、互相配合,为用户提供最...
  • 01、微服务和传统服务讲解 --一个对于学java比较经常碰到的,也是必须要了解的内容。即微服务 docker springboot springcloud的关系 --一个基本的应用业务场景图,帮助理解微服务 --部署前准备: --服务...
  • 服务调用和mq的区别和联系 1.联系:都是在分布式系统下,多个服务之间来支持一个业务 2.区别:服务调用是同步的,mq的生产者和消费者时异步支持一个业务的 如何选择用哪个 1.如果业务必须是同步的,... 2.... 3.... 4....
  • 微服务网关Gateway 1.微服务网关概述 不同的微服务一般会有不同的网络地址,而外部客户端可能需要调用多个服务的接口才能完成一个业务需求,如果让客户端直接与各个微服务通信,会有以下的问题: 客户端会多次...
  • 一般的情况之下java微服务面试都会问些什么问题呢?面试题又是怎样的?下面要给大家分享的是java微服务面试题以及答案,一起来看一看吧。一、面试题及答案1、微服务是什么?答案:微服务架构是一种架构模式,但是,又...
  • 微服务的七大原则

    2020-12-19 09:03:55
    SOA架构(Service Oriented Architecture) SOA架构 SOA是一种粗粒度、松耦合服务架构,服务之间通过简单、精确定义接口进行通讯,不涉及底层编程接口和通讯模型。SOA可以看作是B/S模型、XML(标准通用标记语言的...
  • 1、微服务简介 简而言之,微服务架构风格是一种将单个应用程序开发为“一套小型服务”的方法,每个服务“运行在自己的进程中”,并通过轻量级机制(通常是HTTP资源API)进行通信。这些服务“围绕业务功能构建”,并...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,963
精华内容 9,585
关键字:

微服务通讯