zoukankan html css js c++ java

dubbo 入门篇以及如何代码实现

一、什么是dubbo

Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各个层之间解耦合

Dubbo是阿里巴巴SOA服务化治理方案的核心框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。其核心部分包含:

远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。
集群容错: 提供基于接口方法的透明远程过程调用，包括多协议支持，以及软负载均衡，失败容错，地址路由，动态配置等集群支持。
自动发现: 基于注册中心目录服务，使服务消费方能动态的查找服务提供方，使地址透明，使服务提供方可以平滑增加或减少机器。

那么，Dubbo能做什么？

1. 透明化的远程方法调用，底层封装了 Java NIO 通信框架 Netty、序列化及反序列化框架、以及应用层提供线程池和消息调度，使业务可以快速的实现跨进程的远程通信，就像调用本地服务那样去调用远程服务，而不需要关系底层的通信细节，例如链路的闪断、失败重试等，极大的提高了应用的开发效率。

2. 软负载均衡及容错机制，可以在内网替代 F5 等硬件负载均衡器，降低成本，减少单点。

3. 服务自动注册与发现，基于服务注册中心的订阅发布机制，不再需要写死服务提供方地址，注册中心基于接口名查询服务提供者的ip地址，并且能够平滑添加或删除服务提供者。

4. 服务治理，包括服务注册、服务降级、访问控制、动态配置路由规则、权重调节、负载均衡。

5. Spring 框架无缝集成、配置化发布服务。

Dubbo产生的背景

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

单一应用架构
- 当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。
- 此时，用于简化增删改查工作量的数据访问框架(ORM) 是关键。
垂直应用架构
- 当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。
- 此时，用于加速前端页面开发的Web框架(MVC) 是关键。
分布式服务架构
- 当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。
- 此时，用于提高业务复用及整合的分布式服务框架(RPC) 是关键。
流动计算架构
- 当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。
- 此时，用于提高机器利用率的资源调度和治理中心(SOA) 是关键。

为了解决这由于架构的演变所产生的问题几个问题，于是，dubbo 产生了。当然，解决这个问题的技术不止 dubbo 。

从上面 Dubbo 的服务治理图我们就可以看到，Duboo 很好了解决了上面所出现的一些问题。

所以，当你的系统架构发展到了这种阶段的时候，就需要考虑使用 Dubbo 了

二、Dubbo 的工作原理

1) 节点说明：

Provider：暴露服务的服务提供方
Consumer：调用远程服务的服务消费方
Registry：服务注册与发现的注册中心
Monitor：统计服务的调用次数和调用时间的监控中心
Container：服务运行容器

看了这几个概念后似乎发现，其实 Dubbo 的架构也是很简单的（其实现细节是复杂的），为什么这么说呢，有没有发现，其实很像 生产者-消费者 模型。只是在这种模型上，加上了 注册中心和监控中心 ，用于管理提供方提供的 url ，以及管理整个过程。

那么，整个发布-订阅的过程就非常的简单了。

启动容器，加载， 运行服务提供者 。

服务提供者在启动时，在注册中心 发布注册 自己提供的服务。

服务消费者在启动时，在注册中心订阅自己所需的服务。

如果考虑 失败或变更 的情况，就需要考虑下面的过程（当然这都是dubbo帮我们实现了）

注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

通过这番讲解，我相信 Dubbo 的架构我们也轻车熟路了，那就直接入手，开车吧。

三 Dubbo 开始入门通过配置.xml实现

3.1 服务端

首先，我们先把服务端的接口写好，因为其实 dubbo 的作用简单来说就是给消费端提供接口。

接口定义

　/**
　　 * xml方式服务提供者接口
　　 */
　　public interface ProviderService {

　　    String SayHello(String word);
　　}

View Code

这个接口非常简单，只是包含一个 SayHello 的方法。

接着，定义它的实现类。

/**
 * xml方式服务提供者实现类
 */
public class ProviderServiceImpl implements ProviderService{

    public String SayHello(String word) {
        return word;
    }
}

View Code

这样我们就把我们的接口写好了，那么我们应该怎么将我们的服务暴露出去呢？

导入 maven 依赖

<?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.ouyangsihai</groupId>
    <artifactId>dubbo-provider</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.alibaba/dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.10</version>
        </dependency>
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.5</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>2.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>2.8.0</version>
        </dependency>

    </dependencies>
</project>

View Code

这里使用的 dubbo 的版本是 2.6.6 ，需要注意的是，如果你只导入 dubbo 的包的时候是 会报错 的， 找不到 netty 和 curator 的依赖 ，所以，在这里我们需要把这两个的依赖加上，就不会报错了。

另外，这里我们使用 zookeeper 作为注册中心。

到目前为止，dubbo 需要的环境就已经可以了，下面，我们就把上面刚刚定义的接口暴露出去。

暴露接口（xml 配置方法）

首先，我们在我们项目的 resource 目录下 创建 META-INF.spring 包 ，然后再创建 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="provider" owner="sihai">
        <dubbo:parameter key="qos.enable" value="true"/>
        <dubbo:parameter key="qos.accept.foreign.ip" value="false"/>
        <dubbo:parameter key="qos.port" value="55555"/>
    </dubbo:application>

    <dubbo:monitor protocol="registry"/>

    <!--dubbo这个服务所要暴露的服务地址所对应的注册中心-->
    <!--<dubbo:registry address="N/A"/>-->
    <dubbo:registry address="N/A" />

    <!--当前服务发布所依赖的协议；webserovice、Thrift、Hessain、http-->
    <dubbo:protocol name="dubbo" port="20880"/>

    <!--服务发布的配置，需要暴露的服务接口-->
    <dubbo:service
            interface="com.sihai.dubbo.provider.service.ProviderService"
            ref="providerService"/>

    <!--Bean bean定义-->
    <bean id="providerService" class="com.sihai.dubbo.provider.service.ProviderServiceImpl"/>

</beans>

① 上面的文件其实就是类似 spring 的配置文件，而且，dubbo 底层就是 spring。

② 节点：dubbo:application 就是整个项目在分布式架构中的唯一名称，可以在 name 属性中配置，另外还可以配置 owner 字段，表示属于谁。下面的参数是可以不配置的，这里配置是因为出现了端口的冲突，所以配置。

③ 节点：dubbo:monitor 监控中心配置，用于配置连接监控中心相关信息，可以不配置，不是必须的参数。

④ 节点：dubbo:registry 配置注册中心的信息，比如，这里我们可以配置 zookeeper 作为我们的注册中心。 address 是注册中心的地址，这里我们配置的是 N/A 表示由 dubbo 自动分配地址。或者说是一种直连的方式，不通过注册中心。

⑤ 节点：dubbo:protocol 服务发布的时候 dubbo 依赖什么协议，可以配置 dubbo、webserovice、Thrift、Hessain、http等协议

⑥ 节点：dubbo:service 这个节点就是我们的重点了，当我们服务发布的时候，我们就是通过这个配置将我们的服务发布出去的。 interface 是接口的包路径， ref 是第 ⑦ 点配置的接口的 bean。

⑦ 最后，我们需要像配置 spring 的接口一样，配置接口的 bean。

到这一步，关于服务端的配置就完成了，下面我们通过 main 方法 将接口发布出去。

复制代码
package com.sihai.dubbo.provider;

import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ProtocolConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.ServiceConfig;
import com.alibaba.dubbo.container.Main;
import com.sihai.dubbo.provider.service.ProviderService;
import com.sihai.dubbo.provider.service.ProviderServiceImpl;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * xml方式启动
 *
 */
public class App 
{
    public static void main( String[] args ) throws IOException {
        //加载xml配置文件启动Spring容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("META-INF/spring/provider.xml");
        context.start();
        System.in.read(); // 按任意键退出
    }
}

发布接口非常简单，因为 dubbo 底层就是依赖 spring 的，所以，我们只需要通过 ClassPathXmlApplicationContext 拿到我们刚刚配置好的 xml ，然后调用 context.start() 方法就启动了。

你以为到这里就结束了了，并不是的，我们拿到 dubbo 暴露出去的 url 分析分析。

dubbo 暴露的 url

dubbo://192.168.234.1:20880/com.sihai.dubbo.provider.service.ProviderService?anyhost=true&application=provider&bean.name=com.sihai.dubbo.provider.service.ProviderService&bind.ip=192.168.234.1&bind.port=20880&dubbo=2.0.2&generic=false&interface=com.sihai.dubbo.provider.service.ProviderService&methods=SayHello&owner=sihai&pid=8412&qos.accept.foreign.ip=false&qos.enable=true&qos.port=55555&side=provider&timestamp=1562077289380

① 首先，在形式上我们发现，其实这么牛逼的 dubbo 也是用 类似于 http 的协议 发布自己的服务的，只是这里我们用的是 dubbo 协议 。

② dubbo://192.168.234.1:20880/com.sihai.dubbo.provider.service.ProviderService 上面这段链接就是 ? 之前的链接，构成： 协议://ip:端口/接口 。发现是不是也没有什么神秘的。

分析后你发现，这些都是刚刚在 provider.xml 中配置的字段，然后通过 & 拼接而成的，闻到了 http 的香味了吗？

终于，dubbo 服务端入门了。下面我们看看拿到了 url 后，怎么消费呢？

3.2 消费端

上面提到，我们在服务端提供的只是点对点的方式提供服务，并没有使用注册中心，所以，下面的配置也是会有一些不一样的。

消费端环境配置

首先，我们在消费端的 resource 下建立配置文件 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="consumer" owner="sihai"/>

    <!--dubbo这个服务所要暴露的服务地址所对应的注册中心-->
    <!--点对点的方式-->
    <dubbo:registry address="N/A" />
    <!--<dubbo:registry address="zookeeper://localhost:2181" check="false"/>-->

    <!--生成一个远程服务的调用代理-->
    <!--点对点方式-->
    <dubbo:reference id="providerService"
                     interface="com.sihai.dubbo.provider.service.ProviderService"
                     url="dubbo://192.168.234.1:20880/com.sihai.dubbo.provider.service.ProviderService"/>

    <!--<dubbo:reference id="providerService"
                     interface="com.sihai.dubbo.provider.service.ProviderService"/>-->

</beans>

分析

① 发现这里的 dubbo:application 和 dubbo:registry 是一致的。

② dubbo:reference ：我们这里采用 点对点 的方式，所以，需要配置在服务端暴露的 url 。

maven 依赖

和服务端一样

<?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.ouyangsihai</groupId>
    <artifactId>dubbo-consumer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.ouyangsihai</groupId>
            <artifactId>dubbo-provider</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.10</version>
        </dependency>
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.5</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>2.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>2.8.0</version>
        </dependency>
    </dependencies>
</project>

View Code

调用服务

package com.sihai.dubbo.consumer;

import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ReferenceConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.sihai.dubbo.provider.service.ProviderService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * xml的方式调用
 *
 */
public class App 
{
    public static void main( String[] args ) throws IOException {

        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("consumer.xml");
        context.start();
        //拿到容器中的bean,也可以通过注入的方式（@AutoWired）
        ProviderService providerService = (ProviderService) context.getBean("providerService");
        //感觉就和调用自己的类方法一样
        String str = providerService.SayHello("hello");
        System.out.println(str);
        System.in.read();

    }
}

如此，我们就成功调用接口了。

四可以通过.properties 配置实现，

.xml 配置的优先级>.properties 所以一般通用的配置，放到.properties 里面方便其他项目拷贝，

五 springboot 配置dubbo

5.1 SpringBoot添加Dubbo和Zookeeper依赖：

  <!--spring-boot-starter-dubbo-->
        <dependency>
            <groupId>com.gitee.reger</groupId>
            <artifactId>spring-boot-starter-dubbo</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- 引入zookeeper，去除其中的log4j，否则会因为日志原因导致堆栈溢出 -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.10</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

View Code

springboot-dubbo-api：

定义服务接口ProviderService ：

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

springboot-dubbo-provider：

application.yml配置信息：

server:
    port: 8081
spring:
  dubbo:
    application:
      name: service-provider
    base-package: com.lin.service # dubbo服务发布者所在的包
    registry:
      address: 192.168.0.116 # zookeeper注册中心的地址
      port: 2181       # zookeeper注册中心的端口
      protocol: zookeeper
      register: true
    protocol:
      name: dubbo
      port: 20880
      accesslog: true
    provider:
      retries: 1
      delay: -1

服务实现类：

@Service(version = "1.0.0") //此处Service 是 com.alibaba.dubbo.config.annotation.Service
@Component
public class ProviderServiceImpl implements ProviderService {
    @Override
    public String sayHello(String name) {
        return "Hello "+name;
    }
}

消费方

application.yml配置信息：

server:
    port: 8082
spring:
  dubbo:
    application:
      name: service-consumer
    base-package: com.lin.service  # dubbo服务调用者所在的包
    registry:
      address: 192.168.0.116  # zookeeper注册中心的地址
      port: 2181              # zookeeper注册中心的端口
      protocol: zookeeper
      subscribe: true
    protocol:
      name: dubbo
      host: 192.168.0.116
    consumer:
      timeout: 1000
      check: false  # 服务启动时检查被调用服务是否可用
      retries: 2    # 服务调用重试次数

调用服务提供者的服务：

@RestController
public class Consumer   {

    // 使用兼容注入，可以使用dubbo原生注解@Reference注入
    @Reference(version = "1.0.0")
    public ProviderService service;

    @GetMapping(value = "/hello/{name}")
    public String hello(@PathVariable String name){
        return service.sayHello(name);
    }
}

测试：

浏览器访问消费者的接口，返回的是提供者的处理请求

查看服务提供者和消费者是否注册到Zookeeper注册中心：

完成

查看全文

相关阅读:
[硬件]_ELVE_VS2015下opencv3.3的配置问题
 [Linux]_ELVE_ssh登录远程阿里服务器
 [python]_ELVE_pip2和pip3如何共存
 U盘无法打开提示格式化？如何进行恢复
 [转]pycharm的一些快捷键
 文件上传Django
ansible编译安装--操作系统环境Redhat6.4
django的models字段介绍
 paramiko模块
 mysql安装等操作

原文地址：https://www.cnblogs.com/hup666/p/13455895.html

dubbo 入门篇 以及如何代码实现

那么，Dubbo能做什么？

二、Dubbo 的工作原理

1) 节点说明：

三 Dubbo 开始入门 通过配置.xml实现

3.1 服务端

导入 maven 依赖

暴露接口（xml 配置方法）

dubbo 暴露的 url

3.2 消费端

消费端环境配置

分析

maven 依赖

调用服务

dubbo 入门篇以及如何代码实现

三 Dubbo 开始入门通过配置.xml实现