精华内容
下载资源
问答
  • dubbo简介 1.1 dubbo是什么 Apache Dubbo (incubating)是一款高性能轻量级开源Java RPC框架它提供了三大核心能力面向接口的远程方法调用智能容错和负载均衡以及服务自动注册和发现 1.2 dubbo官网 / 1.3 dubbo的...
  • Apache Dubbo 是一款高性能、轻量级开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现。 Apache Dubbo Provider 存在反序列化漏洞,攻击者可以通过...

    0x01 漏洞背景

    2020年06月23日, 360CERT监测发现 Apache Dubbo 官方 发布了 Apache Dubbo 远程代码执行的风险通告,该漏洞编号为 CVE-2020-1948,漏洞等级:高危

    Apache Dubbo 是一款高性能、轻量级的开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现。

    Apache Dubbo Provider 存在反序列化漏洞,攻击者可以通过RPC请求发送无法识别的服务名称或方法名称以及一些恶意参数有效载荷,当恶意参数被反序列化时,可以造成远程代码执行。

    该漏洞的相关技术细节已公开。

    对此,360CERT建议广大用户及时安装最新补丁,做好资产自查以及预防工作,以免遭受黑客攻击。

    0x02 风险等级

    360CERT对该漏洞的评定结果如下

    0x03 漏洞详情

    Apache Dubbo Provider 存在反序列化漏洞,攻击者可以通过RPC请求发送无法识别的服务名称或方法名称以及一些恶意参数有效载荷,当恶意参数被反序列化时,可以造成远程代码执行。

    0x04 影响版本

    0x05 修复建议

    通用修补建议:

    建议广大用户及时升级到2.7.7或更高版本,下载地址为:

    https://github.com/apache/dubbo/releases/tag/dubbo-2.7.7

    0x06 相关空间测绘数据

    360安全大脑-Quake网络空间测绘系统通过对全网资产测绘,发现Dubbo在国内均有广泛使用,具体分布如下图所示。

    0x07 时间线

    2020-06-22 Apache Dubbo 官方发布通告

    2020-06-23 360CERT发布预警

    原文来自:安全客
    声明:本文经安全客授权发布,转载请联系安全客平台 链接:https://www.anquanke.com/post/id/209102

    关注公众号Java技术栈回复"面试"获取我整理的2020最全面试题及答案。

    推荐去我的博客阅读更多:

    1.Java JVM、集合、多线程、新特性系列教程

    2.Spring MVC、Spring Boot、Spring Cloud 系列教程

    3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程

    4.Java、后端、架构、阿里巴巴等大厂最新面试题

    觉得不错,别忘了点赞+转发哦!

    最后,关注下面的栈长的微信公众号:Java技术栈,回复:福利,可以免费获取一份我整理的 2020 最新 Java 面试题,真的非常全(含答案),无任何套路。

    展开全文
  • Apache Dubbo 是一款高性能、轻量级开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现。 Apache Dubbo Provider 存在 反序列化漏洞,攻击者可以通过...

    漏洞背景
    2020年06月23日, 360CERT监测发现 Apache Dubbo 官方 发布了 Apache Dubbo 远程代码执行 的风险通告,该漏洞编号为 CVE-2020-1948,漏洞等级:高危。

    Apache Dubbo 是一款高性能、轻量级的开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现。

    Apache Dubbo Provider 存在 反序列化漏洞,攻击者可以通过RPC请求发送无法识别的服务名称或方法名称以及一些恶意参数有效载荷,当恶意参数被反序列化时,可以造成远程代码执行。

    风险等级
    360CERT对该漏洞的评定结果如下
    在这里插入图片描述

    漏洞详情
    Apache Dubbo Provider 存在 反序列化漏洞,攻击者可以通过RPC请求发送无法识别的服务名称或方法名称以及一些恶意参数有效载荷,当恶意参数被反序列化时,可以造成远程代码执行。
    2.7.7版本的绕过 的漏洞复现情况如下。

    在这里插入图片描述

    影响版本
    Dubbo 2.7.0 - 2.7.6
    Dubbo 2.6.0 - 2.6.7
    Dubbo 2.5.x (官方不再维护)

    修复建议
    通用修补建议:
    建议广大用户及时升级到2.7.7或更高版本,下载地址为:
    https://github.com/apache/dubbo/releases/tag/

    相关空间测绘数据
    360安全大脑-Quake网络空间测绘系统通过对全网资产测绘,发现Dubbo在国内广泛使用,具体分布如下图所示。

    在这里插入图片描述

    产品侧解决方案
    360城市级网络安全监测服务
    360安全大脑的QUAKE资产测绘平台通过资产测绘技术手段,对该类漏洞进行监测,请用户联系相关产品区域负责人获取对应产品。

    时间线
    2020-06-22 Apache Dubbo 官方发布通告

    2020-06-29 360CERT更新预警

    该漏洞的相关技术细节已公开

    2020年06月29日, 360CERT监测发现 Apache Dubbo GitHub 发布了 2.7.7版本的绕过 被修复的Pull Request,经测试后发现能够有效绕过。
    对此,360CERT建议广大用户及时安装最新补丁,做好资产自查以及预防工作,以免遭受黑客攻击。

    展开全文
  • Dubbo进阶(十五):Dubbo总结

    千次阅读 2020-06-17 21:11:09
    Dubbo的定位是一款高性能、轻量级开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现。 Dubbo产生背景 随着互联网发展,网站应用规模不断扩大...

    最近针对Dubbo中核心的知识点做了一次系统的学习,现对本次学习Dubbo的过程做一次总结。在这里插入图片描述

    Dubbo的定位

    Dubbo的定位是一款高性能、轻量级的开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现。

    在这里插入图片描述

    Dubbo产生的背景

    随着互联网的发展,网站应用的规模不断扩大,常规的垂直应用架构已无法应对,分布式服务架构以及流动计算架构势在必行,亟需一个治理系统确保架构有条不紊的演进。

    • 分布式服务架构

      • 当垂直应用越来越多,应用之间交互不可避免,将核心业务抽取出来,作为独立的服务,逐渐形成稳定的服务中心,使前端应用能更快速的响应多变的市场需求。此时,用于提高业务复用及整合的分布式服务框架(RPC)是关键。
    • 流动计算架构

      • 当服务越来越多,容量的评估,小服务资源的浪费等问题逐渐显现,此时需增加一个调度中心基于访问压力实时管理集群容量,提高集群利用率。此时,用于提高机器利用率的资源调度和治理中心(SOA)是关键。
    Dubbo的架构

    在这里插入图片描述
    当服务提供者(provider)启动时会向注册中心注册,服务消费者(consumer)首先会向注册中心注册,然后订阅服务提供者的信息,当服务提供者的注册信息发生变化的时候,会通知服务消费者。在获取到服务方的元数据之后可以进行RPC调用,在RPC调用后会向监控中心上报统计信息(比如并发数和调用的接口),开发人员可以在监控中心看到服务的调用情况。

    Dubbo核心知识点的详细分析
    展开全文
  • Dubbo:一款java所属RPC框架。...Duboo三大核心能力:面向接口的远程方法调用、智能容错和负载均衡、服务自动注册和发现。 Dubbo内部架构图如下: 节点说明 Provider 暴露服务服务提供方 Consumer 调...

    一、概述

    Dubbo:一款java所属的RPC框架。
    RPC:remote procedure call(远程过程调用),即一个服务器的应用想调用另一个服务器的应用(由于不在同一个内存,无法直接调用)执行的方法的过程。
    rpc一般由三部分组成:网络传输框架(dubbo为netty),序列化协议,方法调用协议。

    一次 RPC 调用流程如下
    在这里插入图片描述

    服务消费者(Client 客户端)通过本地调用的方式调用服务。
    客户端存根(Client Stub)接收到调用请求后负责将方法、入参等信息序列化(组装)成能够进行网络传输的消息体。
    客户端存根(Client Stub)找到远程的服务地址,并且将消息通过网络发送给服务端。
    服务端存根(Server Stub)收到消息后进行解码(反序列化操作)。
    服务端存根(Server Stub)根据解码结果调用本地的服务进行相关处理
    服务端(Server)本地服务业务处理。
    处理结果返回给服务端存根(Server Stub)。
    服务端存根(Server Stub)序列化结果。
    服务端存根(Server Stub)将结果通过网络发送至消费方。
    客户端存根(Client Stub)接收到消息,并进行解码(反序列化)。
    服务消费方得到最终结果。

    Duboo的三大核心能力:面向接口的远程方法调用、智能容错和负载均衡、服务自动注册和发现。

    dubbo的十层构成

    1、接口服务层(service):根据业务逻辑内容设计consumer和provider对应的接口实现;

    2、配置层(config):初始化dubbo配置信息;

    3、服务代理层(proxy):用于生成服务端、客户端代理来调用远程接口;

    4、服务注册层(registry):封装服务地址的注册和发现;

    5、路由层(cluster):封装服务提供者的路由和负载均衡;

    6、监控层(monitor):监控服务调用次数和调用时间;

    7、远程调用层(protocol):封装远程调用具体过程;

    8、信息交换层(exchange):封装请求响应模式,同步转异步;

    9、网络传输层(transport):封装网络传输过程;

    10、数据序列层(serialize):负责网络传输的序列化和反序列化;

    Dubbo内部架构图如下:Dubbo内部架构图
    节点说明
    Provider 暴露服务的服务提供方
    Consumer 调用远程服务的服务消费方
    Registry 服务注册与发现的注册中心
    Monitor 统计服务的调用次数和调用时间的监控中心
    Container 服务运行容器

    调用关系说明
    服务容器负责启动,加载,运行服务提供者。
    服务提供者在启动时,向注册中心发布自己提供的服务。
    服务消费者在启动时,向注册中心订阅自己所需的服务。
    注册中心返回服务提供者地址列表给消费者(这里消费者已经缓存了提供者的信息),如果有变更,注册中心将基于长连接推送变更数据给消费者。
    服务消费者,从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一台调用。
    服务消费者和提供者,在内存中累计调用次数和调用时间,定时每分钟发送一次统计数据到监控中心。

    和springcloud区别
    1、dubbo为长连接,springcloud为短连接;

    2、dubbo默认dubbo协议基于tcp传输协议,二进制传输带宽占用小;springcloud基于http协议消耗大。

    3、dubbo为分布式部署,springcloud为微服务部署,微服务内自成体系。

    4、dubbo注册中心为zookeeper或redis;springcloud注册中心为eureka。

    5、dubbo是zookeeper推送服务;springcloud是各个微服务去eureka注册中心上拉取服务。

    Zookeeper用于服务治理,包括:
    服务的注册(对应发布)和发现(对应订阅),服务的监控,服务的安全处理,服务日志收集,服务的负载均衡调用策略。

    超时时间:服务提供者的超时时间即时超时也会执行完任务,只会在日志分析时提供警告。服务消费者的超时时间是只要接收不到服务提供者提供的服务,就会一直等待,直到超时时间耗尽。因此超时时间设置过长会处于阻塞状态,本设置为3秒。超时时间设置,以服务消费者为准。

    在Provider上尽量多配置Consumer端属性:作服务的提供者,比服务使用方更清楚服务性能参数,如调用的超时时间,合理的重试次数,等等;在Provider配置后,Consumer不配置则会使用Provider的配置值,即Provider配置可以作为Consumer的缺省值。否则,Consumer会使用Consumer端的全局设置,这对于Provider不可控的,并且往往是不合理的

    负载均衡策略
    1、RandomLoadBalance:随机负载均衡。随机的选择一个。是Dubbo的默认负载均衡策略。
    2、RoundRobinLoadBalance:轮询负载均衡。轮询选择一个。
    3、LeastActiveLoadBalance:最少活跃调用数,相同活跃数的随机。活跃数指调用前后计数差。使慢的 Provider 收到更少请求,因为越慢的 Provider 的调用前后计数差会越大。
    4、ConsistentHashLoadBalance:一致性哈希负载均衡。相同参数的请求总是落在同一台机器上。

    容错策略
    Failover Cluster:失败自动切换,当出现失败,重试其它服务器 。通常用于读操作,但重试会带来更长延迟。可通过 retries=“2” 来设置重试次数(不含第一次)。
    配置重试次数:

    <dubbo:service retries="2" />
    

    <dubbo:reference retries="2" />
    

    <dubbo:reference>
        <dubbo:method name="findFoo" retries="2" />
    </dubbo:reference>
    

    Failfast Cluster:快速失败,只发起一次调用,失败立即报错。通常用于非幂等性的写操作,比如新增记录。

    Failsafe Cluster:失败安全,出现异常时,直接忽略。通常用于写入审计日志等操作。

    Failback Cluster:失败自动恢复,后台记录失败请求,定时重发。通常用于消息通知操作。

    Forking Cluster:并行调用多个服务器,只要一个成功即返回。通常用于实时性要求较高的读操作,但需要浪费更多服务资源。可通过 forks=“2” 来设置最大并行数。

    Broadcast Cluster:广播调用所有提供者,逐个调用,任意一台报错则报错 。通常用于通知所有提供者更新缓存或日志等本地资源信息。

    dubbo的服务降级
    服务提供者宕机、出现异常、并发数过高或者服务超时时,服务消费者可以获取友好提示,而不是直接内部报错导致系统不可用。可以利用dubbo内的mock进行解决。
    对服务消费者配置如下:

    <dubbo:reference interface="com.fh.service.user.UserService" group="g1" id="us1" timeout="3000" version="1.0.0" mock="return goodjob"></dubbo:reference>
    
    

    如上配置,在降级时会给服务消费者返回字符串信息"goodjob"。
    或者对服务消费者配置如下:

    <dubbo:reference interface="com.fh.service.user.UserService" group="g1" id="us1" timeout="3000" version="1.0.0" mock="true"></dubbo:reference>
    
    

    如上配置,则需要在服务消费者中创建对应接口的包com.fh.service.user,在该包下创建UserServiceMock类,类名固定,且必须实现com.fh.service.user.UserService接口,实现后重写里面的方法,则服务降级时,会执行UserServiceMock下对应的同名方法。

    关于zookeeper宕机时,dubbo的使用
    平时zookeeper都是集群设置,宕机一个是完全没问题的,下面在不考虑zookeeper集群的情况下。
    如果zookeeper宕机了,此时dubbo的服务提供者和服务消费者之间还能正常调用么?答案是可以的。
    zookeeper可以用类似于文件节点树的方式存储数据,但是zookeeper的主要作用并不是存储数据,而是解决分布式集群中应用系统的一致性,用于维护和监控存储的数据状态的变化。所以数据发生变化,才会涉及到zookeeper的问题。
    在zookeeper宕机后,dubbo服务消费者由于已经缓存好了服务提供者的信息,因此应用完全可以正常调用。
    但参照上面zookeeper的作用,当服务提供者重启后,服务消费者的缓存随之失效,该服务提供者则不能使用。当服务消费者重启后,所有对之提供服务的服务提供者的缓存会全部失效。

    先要安装Zookeeper,只需解压到非中文路径即可,注意,zookeeper端口为2181,务必不要被占用。
    然后要创建服务提供者和服务消费者,即:提供service具体业务的service项目、和web层直接使用该业务的项目,两者均需要定为web工程。

    引入pom文件:

    <dependencies>
            <dependency>
                <groupId>com.fh</groupId>
                <artifactId>total-service-interface</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>dubbo</artifactId>
                <version>2.6.6</version>
            </dependency>
            <dependency>
                <groupId>io.netty</groupId>
                <artifactId>netty-all</artifactId>
                <version>4.1.32.Final</version>
            </dependency>
            <dependency>
                <groupId>org.apache.curator</groupId>
                <artifactId>curator-framework</artifactId>
                <version>4.0.0</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.apache.zookeeper</groupId>
                        <artifactId>zookeeper</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.apache.zookeeper</groupId>
                <artifactId>zookeeper</artifactId>
                <version>3.4.7</version>
            </dependency>
            <dependency>
                <groupId>com.github.sgroschupf</groupId>
                <artifactId>zkclient</artifactId>
                <version>0.1</version>
            </dependency>
        </dependencies>
    

    需要对dubbo中服务提供者和服务消费者互相确定服务身份的手段进行提前说明:传递的中转接口不能确定唯一服务身份,需要中转接口、服务分组和版本号三者,才可以确定唯一的服务提供者和服务消费者关联。也就是说,只有服务提供者和服务消费者在中转接口、服务分组、版本号三个值都一样(可默认不录入,视作一样)时,才可以进行信息交互。
    其中,服务分组和版本号,都是多个具体提供服务内容的类对同一个中转接口进行实现时,区分各自身份的手段。两者区别在于,服务分组不同的服务间可互相引用,而版本号不同的服务间不可互相引用。
    下面创建带有服务分组和版本号的dubbo案例:

    二、创建服务提供者

    1、xml配置文件方式:
    编写xml配置文件:

    <?xml version="1.0" encoding="utf-8"?>
    
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!--    将实现了准备暴露服务的接口的两个实现类都注册到spring中-->
        <bean class="com.fh.service.user.impl.UserServiceImpl" id="usi1"/>
        <bean class="com.fh.service.user.impl.UserServiceImpl2" id="usi2"/>
    
        <dubbo:application name="u1_provider"></dubbo:application>
    <!--    对UserService接口进行服务暴露,
            暴露内容关联具体实现内容usi1、usi2
            对两者各自进行服务分组g1、g2
            两者的负载均衡方式均为加权轮询
            两者权重分别为30、70
            版本号分别为1.0.0和2.0.0-->
        <dubbo:service interface="com.fh.service.user.UserService" ref="usi1" group="g1" loadbalance="roundrobin" weight="30" version="1.0.0"></dubbo:service>
        <dubbo:service interface="com.fh.service.user.UserService" ref="usi2" group="g2" loadbalance="roundrobin" weight="70" version="2.0.0"></dubbo:service>
    <!--    注册中心地址-->
        <dubbo:registry address="zookeeper://localhost" port="2181"></dubbo:registry>
    <!--    服务提供者的注册地址以及传输协议-->
        <dubbo:protocol port="21881" name="dubbo"></dubbo:protocol>
    </beans>
    

    编写暴露服务的具体接口实现类:

    public class UserServiceImpl implements UserService {
        @Autowired
        private UserMapper userMapper;
        
        @Override
        public User findUser(Integer id) {
            System.out.println("我是1号!!!!!!");
            return userMapper.findUser(id);
        }
    }
    
    

    2、注解方式
    编写xml配置文件:

    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
            
        <dubbo:application name="u1_provider"></dubbo:application>
    <!--    注册中心地址-->
        <dubbo:registry address="zookeeper://localhost" port="2181"></dubbo:registry>
    <!--    服务提供者的注册地址以及传输协议-->
        <dubbo:protocol port="21881" name="dubbo"></dubbo:protocol>
    <!--    定义dubbo去扫描的暴露具体服务内容实现类所在的包-->
        <dubbo:annotation package="com.fh.service"></dubbo:annotation>
    </beans>
    

    编写暴露服务的具体接口实现类:

    /**
     * 对UserService接口进行服务暴露,
     * 暴露内容关联具体实现内容不需指定,直接指向注解修饰的类的对象
     * 服务分组为g1
     * 负载均衡方式均为加权轮询
     * 权重分别为30
     * 版本号为1.0.0
     */
    @Service(interfaceClass = com.fh.service.user.UserService.class,group = "g1",loadbalance = "roundrobin",weight = 30,version = "1.0.0")
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserMapper userMapper;
        
        @Override
        public User findUser(Integer id) {
            System.out.println("我是1号!!!!!!");
            return userMapper.findUser(id);
        }
    }
    
    

    三、创建服务消费者

    1、xml配置文件方式:
    编写xml配置文件:

    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
        <dubbo:application name="u1_consumer"></dubbo:application>
    <!--    定义接收服务提供者数据的对象的具体信息:
            关联服务提供者暴露的接口UserService
            分别对相同服务分组g1、g2关联数据
            当前接收服务提供者数据的对象id分别为us1、us2
            超时时间
            版本号分别为1.0.0、2.0.0-->
        <dubbo:reference interface="com.fh.service.user.UserService" group="g1" id="us1" timeout="5000" version="1.0.0"></dubbo:reference>
        <dubbo:reference interface="com.fh.service.user.UserService" group="g2" id="us2" timeout="5000" version="2.0.0"></dubbo:reference>
        <!--    注册中心地址-->
        <dubbo:registry address="zookeeper://localhost" port="2181"></dubbo:registry>
        <!--指定是否使用合理化检查配置:服务的消费者启动时会检查服务的提供者的存在,在提供者不存在时,开启合理化检查,会直接报错,不开启则会在访问时获取不到数据才报错-->
        <dubbo:consumer check="true"></dubbo:consumer>
    </beans>
    

    编写接收服务数据的类:

    @RunWith(SpringJUnit4ClassRunner.class)
    @SpringJUnitConfig(locations = {"classpath*:/spring/applicationContext-*.xml"})
    public class ConsumerTest {
        @Autowired
        private UserService us1;
        @Autowired
        private UserService us2;
        @Test
        public void test1(){
            System.out.println(us1.findUser(1));
            System.out.println(us2.findUser(1));
        }
    }
    

    2、注解方式:
    编写配置文件:

    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
        <dubbo:application name="u1_consumer"></dubbo:application>
        <!--    注册中心地址-->
        <dubbo:registry address="zookeeper://localhost" port="2181"></dubbo:registry>
        <!--指定是否使用合理化检查配置:服务的消费者启动时会检查服务的提供者的存在,在提供者不存在时,开启合理化检查,会直接报错,不开启则会在访问时获取不到数据才报错-->
        <dubbo:consumer check="true"></dubbo:consumer>
        <!--    定义dubbo去扫描的消费服务的对象所在的包-->
        <dubbo:annotation package="com.fh.web.controller"></dubbo:annotation>
    </beans>
    

    编写接收服务数据的类:

    @RunWith(SpringJUnit4ClassRunner.class)
    @SpringJUnitConfig(locations = {"classpath*:/spring/applicationContext-*.xml"})
    public class ConsumerTest {
        /**
         * 定义接收服务提供者数据的对象的具体信息:
         * 关联服务提供者暴露的接口UserService
         * 分别对相同服务分组g1、g2关联数据
         * 当前接收服务提供者数据的对象id分别为us1、us2
         * 超时时间
         * 版本号分别为1.0.0、2.0.0
         */
        @Reference(interfaceClass = com.fh.service.user.UserService.class,group = "g1",timeout = 5000,version = "1.0.0")
        private UserService us1;
        @Reference(interfaceClass = com.fh.service.user.UserService.class,group = "g2",timeout = 5000,version = "2.0.0")
        private UserService us2;
        @Test
        public void test1(){
            System.out.println(us1.findUser(1));
            System.out.println(us2.findUser(1));
        }
    }
    

    创建步骤完成,准备启动!

    四、启动步骤

    分别对服务提供者和服务消费者创建tomcat,确保设置不同的端口。同时,可以再创建第三个tomcat,设置新端口,并引入dubbo-admin的war包,创建监控器用以查看。
    在启动服务提供者、服务消费者、监控器之前,需优先启动ZooKeeper。

    且一般上线阶段才会将服务提供者运行在tomcat上,开发阶段都是在服务提供者内创建测试类:

    package com.fh.test;
    
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import java.io.IOException;
    
    public class TestDemo {
        public static void main(String[] args) throws IOException {
            //读取配置文件,创建服务运行容器applicationContext-dubbo和applicationContext-tx
            ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath*:spring/applicationContext-*.xml");
            //开启applicationContext-dubbo和applicationContext-tx容器,applicationContext-dubbo的开启会启动服务提供者
            applicationContext.start();
            //设置在控制台按任意键退出,目的是为了pause卡主容器,让服务提供者一直保持开启状态
            System.in.read();
        }
    }
    

    在修改服务提供者的暴露端口(<dubbo:protocol name=“dubbo” port=“20881”></dubbo:protocol>)的情况下,服务提供者可以进行多次启动,达到多个服务提供者同时的共同运行。

    最终在dubbo admin上,不同服务分组、版本号的服务提供者和服务消费者信息展示如下:
    服务消费者:
    在这里插入图片描述

    服务提供者:

    在这里插入图片描述

    五、 zookeeper选举机制:

    zookeeper默认选举机制:FastLeaderElection->投票数大于半数则胜出。

    服务器ID(myid):服务器自身编号,越大则选举权重越大

    数据ID(zxid):服务器中存放的最新数据的版本号,越大则说明数据越新,在选举过程中权重越大

    逻辑时钟:投票次数,初始值为0,每投票一次+1,如果某台服务器出现宕机则不会投票,因此逻辑时钟会低于其他服务器。

    选举状态:竞选状态(looking)、随从状态(following,同步于leader,参与投票)、观察状态(observing,同步于leader,不参与投票)、领导状态(leading)

    假设有5台服务器,会按编号依次启动服务器

    1、全新集群选举(初始化选举):

    (1)服务器1启动,给自己投票,并对其他服务器发送自己的投票信息,由于其他服务器并未启动,因此无反馈信息,服务器1处于looking。

    (2)服务器2启动,给自己投票,并与zookeeper集群所有服务器汇总投票结果,由于服务器2的myid较大,所以服务器2胜出,服务器1投票给服务器2。但此时服务器2的投票数未能大于集群半数(2<5/2),所以服务器1、2均处于looking。

    (3)服务器3启动,给自己投票,并与zookeeper集群所有服务器汇总投票结果,由于服务器3的myid较大,所以服务器3胜出,服务器1、2投票给服务器3。此时服务器3的票数正好大于半数(3>5/2),所以服务器3被选举成功,处于leading,服务器1、2处于following。

    (4)服务器4启动,给自己投票,并与zookeeper集群所有服务器汇总投票结果,虽然服务器4的myid较大,但服务器3已经胜出,则服务器4只能处于following。

    (5)服务器5同服务器4,处于following。

    2、非全新集群选举(运行时选举):当leader宕机或leader失去过多following时,zookeeper集群进入恢复模式,该模式下不对外提供服务,直到leader被选举完成。

    (1)leader宕机后,剩余的非observing的服务器恢复到looking,进行重新选举。

    (2)选举时对比所有服务器的逻辑时钟,如果选举结果服务器的逻辑时钟小,则说明该服务器存在宕机问题,则放弃该选举结果重新投票。

    (3)统一逻辑时钟后选取zxid大的服务器,因为zxid越大表示该服务器上数据越新。

    (4)如果逻辑时钟和zxid一致,则比较myid,myid大的胜出。

    也就是要选出未宕机的数据最完整、最新的一台服务器作为zookeeper集群的leader。

    展开全文
  • Dubbo学习总结(一)介绍

    2019-01-14 11:40:45
    doubbo是一款高性能、轻量级开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现。 什么是分布式系统?  "分布式系统是若干独立计算机集合,...
  • 1. RPC是什么 RPC(Remote Procedure Call Protocol)——远程过程调用协议。 2. 为什么要用RPC 当我们系统访问量增大、业务增多时,我们会发现一台单机运行此系统已经无法...2)RMI(远程方法调用) 在Java...
  • RPC 让调用远程服务调用像调用本地方法那样简单。 Dubbo 是一款国产 RPC 框架,由阿里开源。相关阅读: Dubbo 常见问题总结 服务之间调用为啥不直接用 HTTP 而用 RPC? API 网关 网关主要用于请求转发、安全...
  • RPC 让调用远程服务调用像调用本地方法那样简单。 Dubbo 是一款国产 RPC 框架,由阿里开源。相关阅读: Dubbo 常见问题总结 服务之间调用为啥不直接用 HTTP 而用 RPC? API 网关 网关主要用于请求转发、安全...
  • Dubbo :Apache Dubbo 是一个基于 Java 高性能开源 RPC 框架。 Nacos :Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用特性集,帮助您快速实现动态服务发现、服务配置、服务元数据及流量...

空空如也

空空如也

1 2 3
收藏数 56
精华内容 22
关键字:

java的dubbo无法调用远程方法

java 订阅