Dubbo

最新推荐文章于 2021-02-06 17:45:36 发布

铝合金直男

最新推荐文章于 2021-02-06 17:45:36 发布

阅读量238

点赞数

文章标签： Dubbo分布式

本文链接：https://blog.csdn.net/yrj520bd/article/details/103116773

版权

Dubbo

课程介绍

传统系统架构模式（了解）
Dubbo/Dubbox简介（掌握）
Dubbo本地服务化实现（掌握）
项目分布式服务调用实现（掌握）
Dubbo管理控制台（了解）
Dubbo监控中心（了解）

传统系统架构模式

什么是传统系统的架构模式

传统应用系统中（如：P2P网贷系统），我们主要使用了三层架构：

即表示层、业务层和数据访问层

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L5j9ugJd-1574038537486)(D:\TinkingCat\dubbo\assets\1573461546712.png)]

传统Web应用程序客户端（浏览器）发起请求，由业务层执行业务逻辑，执行业务的过程中又通过数据库查询/处理业务相关的数据，最后在完成业务后将数据结合视图展示给用户

传统应用架构的不足

但是，在这种体系架构下的系统有几个问题。所有代码（表示层，业务层和数据访问层）在同一个项目中维护。虽然逻辑上我们也使用了一些外部扩展服务，如消息服务和数据访问的服务，但最终还是部署在一个应用中。

单系统的架构模式，在系统业务庞大的情况下，有很多的不足之处：

1.所有项目都会使用相同的一个代码库，每一个团队成员（UI\前端\程序猿）都会提交维护代码库的内容，当内容逐渐增多，效率就变得低下。

2.如果采取多模块开发模式，模块间相互依赖，极小的改动都会引起其它开发环境同步更新，如果有已上线运行的产品，那么发布也是个很大的工作量。

3.单系统的架构模式，虽然采用了三层架构来区分不同层的责任与任务，但是从实际的操作中来看，难免存在责任交叉，因此某些地方的改动可能会带来其它层的同步变动，失去了分层的独立性。

4.有很多团队分为开发团队和运营支持团队，开发团队只负责开发，在完成后交于运营团队管理，虽然运营团队能很好地处理一些日常问题，但遇到系统危机问题时，也不得不求助于开发团队。

5.当业务逐渐增长，单系统可能被拆解为多个独立的子系统，但系统间是存在一定业务关联的，这时解决基础服务公用的问题就势在必行，需要开发者将通用服务独立发布以便于其它系统调用

微服务架构

基于以上问题，微服务的概念就被提出来了。

微服务的理念就是，将产品或项目分解为众多独立的服务，这些服务独立地部署，并且不依赖于其它服务。

可能有些开发者会想，三层架构的模式本身不就已经分解了么？这可能是大家对微服务的一个认识误区，微服务不是去垂直分解实现过程，如实现某个服务需要用到的JMS、UI和数据库访问，而是按照功能进行分解。一个完整的功能本身就包含了UI、业务、日志、数据访问等一系列内容。

例如：我们的即将升级课程中的B2C商城平台，包含商品及库存模块、订单模块、支付模块、物流模块、购物车模块、商城站点模块等，那么，我们可以将不同模块分别部署，每个团队可以独立负责各自模块的开发运维与升级。

因此，微服务没有集中的数据库，每个模块都具有自己的存储系统，可能是MySQL，也可能是Redis，技术选型可以根据模块的特点来选择

微服务的优势

① 单系统只用一种开发语言，但微服务每个服务独立，每个服务可以看成一个项目，因此每个服务可以选择最合适服务特色的技术开发。独立技术选型

② 开发集中在一个服务，业务和代码量都不大，开发人员能很好地把控代码。可读性增强

③ 服务间进行调用时，可以通过API来进行通讯，如REST，也可以使用分布式服务管理框架如Dubbo、SpringCloud等

微服务的问题

因为每个功能都是独立的服务，因此在一个较大的项目中，监测管理这些服务变得复杂，如果某个服务出现故障，那么调试跟踪比单系统更复杂，因为日志分布在不同的系统中，所以调试起来需要花费更多精力，因此，建立统一的日志管理系统可能是目前解决这一问题的最好方案。

系统应用架构演变

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BoQ2a3IT-1574038537488)(D:\TinkingCat\dubbo\assets\1573461732591.png)]

单一应用架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。

此时，用于简化增删改查工作量的 数据访问框架(ORM) 是关键。

垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。

此时，用于加速前端页面开发的 Web框架(MVC) 是关键。

分布式服务架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。

此时，用于提高业务复用及整合的 分布式服务框架(RPC) 是关键。

流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。

此时，用于提高机器利用率的 资源调度和治理中心(SOA) 是关键

在这里插播一条关于RPC的简介：
RPC(Remote Procedure Call Protocol)：远程过程调用：
两台服务器A、B，分别部署不同的应用a,b。当A服务器想要调用B服务器上应用b提供的函数或方法的时候，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义传达调用的数据。
说白了，就是你在你的机器上写了一个程序，我这边是无法直接调用的，这个时候就出现了一个远程服务调用的概念。

RPC是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。
RPC采用客户机/服务器模式。请求程序就是一个客户机，而服务提供程序就是一个服务器。首先，客户机调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。在服务器端，进程保持睡眠状态直到调用信息到达为止。当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，最后，客户端调用进程接收答复信息，获得进程结果，然后调用执行继续进行。

RPC需要解决的问题：

通讯问题 : 主要是通过在客户端和服务器之间建立TCP连接，远程过程调用的所有交换的数据都在这个连接里传输。连接可以是按需连接，调用结束后就断掉，也可以是长连接，多个远程过程调用共享同一个连接。
寻址问题 ： A服务器上的应用怎么告诉底层的RPC框架，如何连接到B服务器（如主机或IP地址）以及特定的端口，方法的名称名称是什么，这样才能完成调用。比如基于Web服务协议栈的RPC，就要提供一个endpoint URI，或者是从UDDI服务上查找。如果是RMI调用的话，还需要一个RMI Registry来注册服务的地址。
序列化 与 反序列化 ： 当A服务器上的应用发起远程过程调用时，方法的参数需要通过底层的网络协议如TCP传递到B服务器，由于网络协议是基于二进制的，内存中的参数的值要序列化成二进制的形式，也就是序列化（Serialize）或编组（marshal），通过寻址和传输将序列化的二进制发送给B服务器。
同理，B服务器接收参数要将参数反序列化。B服务器应用调用自己的方法处理后返回的结果也要序列化给A服务器，A服务器接收也要经过反序列化的过程。

小结

随着系统应用架构的演变与微服务的发展，传统架构模式虽然能解决大部分应用场景，但在高并发、高扩展性与精细力度的性能控制上已经不能满足应用开发的需求，因此，基于微服务的理念开发的系统将越来越多。

Dubbo/Dubbox简介

什么是Dubbo/Dubbox

Dubbo是：

一款分布式服务框架
高性能和透明化的RPC远程服务调用方案
SOA服务治理方案

每天为2千多个服务提供大于30亿次访问量支持，并被广泛应用于阿里巴巴集团的各成员站点以及别的公司的业务中。并被广泛应用于阿里巴巴集团的各成员站点，同时，国内有大量的大型平台都是基于Dubbo的分布式服务治理架构完成服务的分布式访问。

Dubbo采用的是一种非常简单的模型，要么是提供方提供服务，要么是消费方消费服务，所以基于这一点可以抽象出服务提供方（Provider）和服务消费方（Consumer）两个角色。

Dubbo主要解决了以下问题：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KcEE61YA-1574038537488)(D:\TinkingCat\dubbo\assets\1573461934146.png)]

在大规模服务化之前，应用可能只是通过RMI或Hessian等工具，简单的暴露和引用远程服务，通过配置服务的URL地址进行调用，通过F5等硬件进行负载均衡。

1) 当服务越来越多时，服务URL配置管理变得非常困难，F5硬件负载均衡器的单点压力也越来越大。

此时需要一个服务注册中心，动态的注册和发现服务，使服务的位置透明。

并通过在消费方获取服务提供方地址列表，实现软负载均衡和Failover，降低对F5硬件负载均衡器的依赖，也能减少部分成本。

当进一步发展，服务间依赖关系变得错踪复杂，甚至分不清哪个应用要在哪个应用之前启动，架构师都不能完整的描述应用的架构关系。

这时，需要自动画出应用间的依赖关系图，以帮助架构师理清理关系。

3) 接着，服务的调用量越来越大，服务的容量问题就暴露出来，这个服务需要多少机器支撑？什么时候该加机器？

为了解决这些问题，第一步，要将服务现在每天的调用量，响应时间，都统计出来，作为容量规划的参考指标。

其次，要可以动态调整权重，在线上，将某台机器的权重一直加大，并在加大的过程中记录响应时间的变化，直到响应时间到达阀值，记录此时的访问量，再以此访问量乘以机器数反推总容量。

Dubbox

Dubbo开源过后，当当网根据自身的需求，为Dubbo实现了一些新的功能，并将其命名为Dubbox（即Dubbo eXtensions）。

主要的新功能包括：

支持REST风格远程调用（HTTP + JSON/XML)

支持基于Kryo和FST的Java高效序列化实现

支持基于嵌入式Tomcat的HTTP remoting体系

升级Spring：将dubbo中Spring由2.x升级到目前最常用的3.x版本，减少项目中版本冲突带来的麻烦。

升级ZooKeeper客户端：将dubbo中的zookeeper客户端升级到最新的版本，以修正老版本中包含的bug。

dubbox和dubbo 2.x是兼容的，没有改变dubbo的任何已有的功能和配置方式（除了升级了Spring之类的版本）。

Dubbo核心架构

总体架构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IVCR2zDn-1574038537489)(D:\TinkingCat\dubbo\assets\1573462036381.png)]

Dubbo框架设计一共划分了10个层：

服务接口层（Service）、配置层（Config）、服务代理层（Proxy）、服务注册层（Registry）、集群层（Cluster）、监控层（Monitor）、远程调用层（Protocol）、信息交换层（Exchange）、网络传输层（Transport）和数据序列化层（Serialize）。

而最上面的Service层是留给实际想要使用Dubbo开发分布式服务的开发者实现业务逻辑的接口层。图中左边淡蓝背景的为服务消费方使用的接口，右边淡绿色背景的为服务提供方使用的接口，位于中轴线上的为双方都用到的接口。

Dubbo核心要点

① 服务定义

服务是围绕服务提供方和服务消费方的，服务提供方实现服务，而服务消费方调用服务。

② 服务注册

对于服务提供方，它需要发布服务，而且由于应用系统的复杂性，服务的数量、类型也不断膨胀；对于服务消费方，它最关心如何获取到它所需要的服务，而面对复杂的应用系统，需要管理大量的服务调用。而且，对于服务提供方和服务消费方来说，他们还有可能兼具这两种角色，即既需要提供服务，有需要消费服务。

通过将服务统一管理起来，可以有效地优化内部应用对服务发布/使用的流程和管理。服务注册中心可以通过特定协议来完成服务对外的统一。Dubbo提供的注册中心有如下几种类型可供选择：

Multicast注册中心（测试）、Zookeeper注册中心**（官方推荐）**、Redis注册中心、Simple注册中心

③ 服务监控

无论是服务提供方，还是服务消费方，他们都需要对服务调用的实际状态进行有效的监控，从而改进服务质量。

④ 远程通信与信息交换

远程通信需要指定通信双方所约定的协议，在保证通信双方理解协议语义的基础上，还要保证高效、稳定的消息传输。Dubbo继承了当前主流的网络通信框架，主要包括如下几个：

Mina、Netty、Grizzly

⑤ 服务调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RMDO2jmD-1574038537490)(D:\TinkingCat\dubbo\assets\1573462073682.png)]

节点角色说明：

Provider: 暴露服务的服务提供方。

Consumer: 调用远程服务的服务消费方。

Registry: 服务注册与发现的注册中心。

Monitor: 统计服务的调用次数和调用时间的监控中心。

Container: 服务运行容器。

调用关系说明：

0.服务容器负责启动，加载，运行服务提供者。
1.服务提供者在启动时，向注册中心注册自己提供的服务。(springboot项目启动就会在zk中创建一个节点)
2.服务消费者在启动时，向注册中心订阅自己所需的服务。
3.注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
4.服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
5.服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心

Dubbo注册中心

对于服务提供方，它需要发布服务，而且由于应用系统的复杂性，服务的数量、类型也不断膨胀；
对于服务消费方，它最关心如何获取到它所需要的服务，而面对复杂的应用系统，需要管理大量的服务调用。
而且，对于服务提供方和服务消费方来说，他们还有可能兼具这两种角色，即既需要提供服务，有需要消费服务。

通过将服务统一管理起来，可以有效地优化内部应用对服务发布/使用的流程和管理。服务注册中心可以通过特定协议来完成服务对外的统一。

Dubbo提供的注册中心有如下几种类型可供选择：

Multicast注册中心
Zookeeper注册中心
Redis注册中心
Simple注册中心

Dubbo优缺点

优点：

1.透明化的远程方法调用
	-像调用本地方法一样调用远程方法；只需简单配置，没有任何API侵入。
2.软负载均衡及容错机制
    -可在内网替代nginx lvs等硬件负载均衡器。
3.服务注册中心自动注册 & 配置管理
	-不需要写死服务提供者地址，注册中心基于接口名自动查询提供者ip。
	-使用类似zookeeper等分布式协调服务作为服务注册中心，可以将绝大部分项目配置移入zookeeper集群。
4.服务接口监控与治理
	-Dubbo-admin与Dubbo-monitor提供了完善的服务接口管理与监控功能，针对不同应用的不同接口，可以进行 	多版本，多协议，多注册中心管理。

缺点：

只支持JAVA语言

IDEA搭建简单的dubbo项目

1.dubbo_demo:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tNh1EV7j-1574038537490)(D:\TinkingCat\dubbo\assets\1573642647333.png)]

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.ddmzx</groupId>
  <artifactId>dubbo_demo</artifactId>
  <packaging>pom</packaging>
  <version>1.0-SNAPSHOT</version>
  <modules>
    <module>dubbo_provider</module>
    <module>dubbo_api</module>
    <module>dubbo_consumer</module>
  </modules>

  <name>dubbo_demo</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <motan.version>0.3.0</motan.version>
    <dubbo.version>2.5.3</dubbo.version>
    <dubbox.version>2.8.4</dubbox.version>
    <spring.version>4.3.6.RELEASE</spring.version>
    <java.version>1.8</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>dubbo</artifactId>
      <version>2.5.3</version>
      <exclusions>
        <exclusion>
          <groupId>org.springframework</groupId>
          <artifactId>spring</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>com.github.sgroschupf</groupId>
      <artifactId>zkclient</artifactId>
      <version>0.1</version>
    </dependency>
    <!-- spring相关 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>4.3.12.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jms</artifactId>
      <version>4.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.7.4</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.11</version>
    </dependency>
  </dependencies>
  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

2.dubbo_api:

File->new Module,Parent，要选择dubbo_demo,和新建dubbo_provider一样

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>dubbo_demo</artifactId>
        <groupId>com.ddmzx</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo_api</artifactId>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

3.dubbo_provider:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lX6mg1Uo-1574038537491)(D:\TinkingCat\dubbo\assets\1573642743917.png)]

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>dubbo_demo</artifactId>
        <groupId>com.ddmzx</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo_provider</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.ddmzx</groupId>
            <artifactId>dubbo_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

4.dubbo_consumer:

当搭建网页时，该module要为web项目

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0ZTPUblC-1574038537492)(D:\TinkingCat\dubbo\assets\1573642951980.png)]

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>dubbo_demo</artifactId>
        <groupId>com.ddmzx</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo_consumer</artifactId>
    <packaging>war</packaging>

    <name>dubbo_consumer Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.ddmzx</groupId>
            <artifactId>dubbo_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>dubbo_consumer</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

项目结构为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KcVvw6bE-1574038537492)(D:\TinkingCat\dubbo\assets\1573643018640.png)]

在dubbo_api中定义服务接口：

package service;

public interface HelloService {

    String sayHello(String name);
}

在dubbo_provider中实现接口：

package service.impl;

import service.HelloService;

public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return "hello"+name;
    }
}

dubbo_provider项目中的resource文件包含dubbo-provider.xml和springmvc.xml配置文件，没有resource，自己新建，并标记为Resources Root

其中dubbo-provider.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:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://code.alibabatech.com/schema/dubbo
    http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="dubbo_provider"  />

    <!-- 使用zookeeper注册中心暴露服务地址 -->
    <dubbo:registry address="zookeeper://192.168.126.133:2181" />

    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20880" />

    <!-- 声明需要暴露的服务接口 -->
    <dubbo:service interface="service.HelloService" ref="helloService" />

    <!-- 接口实现类-->
    <bean id="helloService" class="service.impl.HelloServiceImpl"/>

</beans>

springmvc.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util-4.0.xsd"
       default-autowire="byName">

    <aop:aspectj-autoproxy />
    <context:component-scan base-package="service" />
    <import resource="classpath:dubbo-provider.xml" />
</beans>

编写测试类:

package test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;

public class ProviderTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:springmvc.xml");
        context.start();
        System.out.println("Dubbo provider");
        try {
            System.in.read();   // 按任意键退出
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

dubbo_consumer在resource下新建dubbo-consumer.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:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd ">
    <!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->
    <dubbo:application name="dubbo_consumer" />
    <!-- 使用multicast广播注册中心暴露发现服务地址 -->
    <dubbo:registry  protocol="zookeeper" address="zookeeper://192.168.126.133:2181" />
    <!-- 生成远程服务代理，可以和本地bean一样使用demoService -->
    <dubbo:reference id="helloService" interface="service.HelloService" />
</beans>

springmvc.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util-4.0.xsd"
       default-autowire="byName">

    <aop:aspectj-autoproxy />
    <context:component-scan base-package="service" />
    <import resource="classpath:/dubbo-consumer.xml" />
</beans>

编写消费者的测试：

package test;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.HelloService;
import java.io.IOException;
public class ConsumerTest {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "classpath:springmvc.xml" });

        context.start();
        HelloService demoService = (HelloService) context.getBean("helloService");

        System.out.println(demoService.sayHello("changan"));
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

按照先后顺序，首先启动Zookeeper：zkServer.cmd 然后启动服务生产者测试类，最后启动服务消费者的测试类，当控制台输出以下结果，则代表成功

log4j:WARN No appenders could be found for logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
Dubbo provider start...
 
Process finished with exit code 1

log4j:WARN Please initialize the log4j system properly.
Hello World！

dubbo-admin安装和使用

下载他们打包好的源代码吧：https://github.com/alibaba/dubbo/releases(https://github.com/apache/incubator-dubbo/releases)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H9AXzbLn-1574038537493)(D:\TinkingCat\dubbo\assets\692500-20180117153457303-1594897848.png)]

方法1、解压后，根目录里存在dubbo-admin，进入 mvn package -Dmaven.test.skip=true 安装完后，生成target目录，进入这个目录，找到dubbo-admin-2.6.0这个目录，把这个目录全部copy到tomcat的目录webapps下的ROOT下面（删除tomcat webapps目录下ROOT原有内容）

方法2、解压后，根目录里存在dubbo-admin，进入 mvn install -Dmaven.test.skip=true 安装完后，生成target目录，进入这个目录，找到dubbo-admin-2.6.0.war，把这个war包copy到tomcat的目录webapps下的ROOT下面（删除tomcat webapps目录下ROOT原有内容），然后使用jar xvf dubbo-admin-2.6.0.war解压war包，把解压后的内容全部放到ROOT目录下

启动tomcat，就可以看到dubbo-admin的界面，默认帐号密码root/root

启动tomcat方法：进入目录/home/admin/apache-tomcat-8.5.24/bin，然后 sh startup.sh

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CRUoCT7V-1574038537493)(D:\TinkingCat\dubbo\assets\692500-20180117160211443-624356164.png)]

我使用dubbo2.6.0和tomcat8.5.24是可以启动的；

但是使用dubbo2.5.4和tomcat8.4.24的话，dubbo-admin就起不来了

课程总结

重点

dubbo服务调用的理解，及Regiester-Provider-Consumer-Monitor的关系。
dubbo的multicast注册方式实现本地服务发布与服务调用的调试。
传统SSM单系统模式架构转为DUBBO多系统的架构方式。
Zookeeper注册中心的使用。

难点

Dubbo服务独立打包运行

面试题

如何实现Dubbo的本地调试？

通过取消连接注册中心，配置服务为直连模式绕过注册中心，从而实现本地调用。当服务调试稳定后，再使用Zookeeper注册中心，并把服务发布出去。

Dubbo的核心理念是什么？

① 服务定义、②服务注册、③服务监控、④远程通信与信息交换、⑤服务调用

Dubbo的注册中心的作用是什么？

通过将服务统一管理起来，可以有效地优化内部应用对服务发布/使用的流程和管理。服务注册中心可以通过特定协议来完成服务对外的统一

Dubbo监控中心是干嘛的？

监控中心负责为服务的监控运维采集各维度的数据，统计各服务的调用次数、时间等，统计先在服务端和消费端内存中汇总，每隔一分钟发送到监控中心服务器，并以报表的形式展现。

监控中心是独立于服务和管理控制台的，在整个dubbo服务治理环节不是必须的，用户可根据实际情况选择性安装。

监控中心如果出现异常（宕机），并不会影响Provider和Consumer之间的服务调用，但会丢失故障期间的监控数据，再生产环境不会有任何风险。

谈谈你对Zookeeper的理解？

ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。

ZooKeeper代码版本中，提供了分布式独享锁、选举、队列的接口。

Zookeeper作为Dubbo服务的注册中心，Dubbo原先基于数据库的注册中心，没采用Zookeeper，Zookeeper一个分布式的服务框架，是树型的目录服务的数据存储，能做到集群管理数据，这里能很好的作为Dubbo服务的注册中心，Dubbo能与Zookeeper做到集群部署，当提供者出现断电等异常停机时，Zookeeper注册中心能自动删除提供者信息，当提供者重启时，能自动恢复注册数据，以及订阅请求。我们先在windows上安装Zookeeper，我们安装最简单的单点，集群有兴趣的同学可以查找资料利用虚拟机搭建。