简单的Dubbo+zookeeper入门使用示例

最新推荐文章于 2022-02-06 16:06:42 发布
最新推荐文章于 2022-02-06 16:06:42 发布
阅读量297 收藏
点赞数
分类专栏： Dubbo 文章标签： Dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27607579/article/details/84571363
版权

Dubbo官方网址：

http://dubbo.apache.org/zh-cn/

本案例源码下载地址：

CSDN资源下载：dubbo简单入门级代码示例

百度网盘：https://pan.baidu.com/s/1cOcfzOCW9nBiSFrMJayG6w     提取码: nkqm 

使用工具：

IDE：IntelliJ IDEA 2017.2 x64

注册中心：zookeeper-3.4.5

dubbo：版本为2.5.3

安装zookeeper

在本案例中，使用zookeeper作为dubbo的注册中心，所以，我们需要先安装zookeeper，zookeeper怎么安装这里不再阐述，感兴趣的朋友可以看我的另一篇文章哈：

windows安装zookeeper 单机，伪集群，集群（集群未测试）

zookeeper安装完成后，就开始打开idea进行程序编写吧。

1. 首先，我们新建一个maven项目

直接next即可。

新建完maven工程后，因为我们需要编写 provider（服务提供者）和 consumer（服务消费者）以及一个common（公共资源，用于存放消费者和提供者需要进行RPC（远程过程调用）的接口和实体，以免进行RPC的时候需要在provider和consumer中同时维护两套需要保持一致性的接口和实体类），所以，我们使用maven的分模块方式进行程序编写，这样比较方便，所以，我们先删除工程的src文件夹。

然后，我们就来创建 provider 、consumer 和 common 的 module。

创建完module后，你会发现在src/main/java中点击右键无法创建class，如下图所示：

具体的解决方法这里不再阐述，可以参考我另一篇文章，方法也比较简单：

idea中maven的Modules中java文件夹无法创建class，test文件夹中测试类没有执行按钮的解决

到这里，provider 、consumer 和 common 三个modules全部创建好了。

之后，我们先在父maven的pom.xml里进行一些公用jar包的引入：

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>selfStudy</groupId>
    <artifactId>dubboSample</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>provider</module>
        <module>consumer</module>
        <module>common</module>
    </modules>

    <!-- 声明所用的jdk版本，以免每次maven重新编译时都会重置为1.5 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <!-- 引入的所有Jar包如下 -->
    <dependencies>
        <!-- springMVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

        <!-- dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.5.3</version>
        </dependency>

        <!-- zookeeper的客户端 -->
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
    </dependencies>

</project>

同时，因为common这个Module是用来存放一些provider和consumer在进行RPC时公用的接口和实体类的，因此provider和consumer两个module需要依赖common这个module。

只需在provider和consumer的pom.xml中分别对common的引用即可：

<!-- 添加对common的引用 -->
<dependencies>
    <dependency>
        <groupId>selfStudy</groupId>
        <artifactId>common</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

至此，所有公用Jar包引入完毕且依赖关系确认完毕。

我们假设目前需求如下，有一个小朋友要去买糖，他给出一定数量的钱，然后商店给他相应的糖。

那么我们需要有一个小孩买糖的功能，一个商店卖糖的功能。

Common

首先，我们在common类中编写需要用到的糖果实体类candy，小孩买糖的功能接口ToBuyService 以及 商店卖糖的功能接口 ShopService。

结构如下：

candy实体类代码：

package bean;

/**
 * 糖果
 */
public class Candy implements java.io.Serializable{

    // 糖果的名称
    private String name;
    // 糖果的味道
    private String taste;
    // 糖果的颜色
    private String color;

    public Candy(String name, String taste, String color) {
        this.name = name;
        this.taste = taste;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getTaste() {
        return taste;
    }

    public void setTaste(String taste) {
        this.taste = taste;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return String.format("糖果是：%s，味道是：%s，颜色是：%s", this.name, this.taste, this.color);
    }
}

ShopService代码：

package service;

import bean.Candy;

public interface ShopService {

    /**
     * 售卖糖果
     * @param money 金额
     * @return
     */
    Candy sellCandy(Integer money);

}

ToBuyService代码：

package service;

import bean.Candy;

public interface ToBuyService {

    /**
     * 买糖果
     * @param money 妈妈给的钱（给多给少看心情啊）
     * @return
     */
    Candy toBuyCandy(Integer money);

}

Provider

然后，我们需要编写provider的具体代码，provider作为服务提供者，自然就是商店啦，商店提供卖糖的功能实现类shopServicelImpl，作为服务提供者的启动类SellCandyApplication以及作为dubbo服务提供者的dubbo配置xml文件，商店的代码结构如下：

shopServicelImpl是ShopService的具体实现类，代码如下：

package service.impl;

import bean.Candy;
import org.springframework.stereotype.Service;
import service.ShopService;

@Service
public class ShopServiceImpl implements ShopService{

    /**
     * 售卖糖果
     * @param money 金额
     * @return
     */
    @Override
    public Candy sellCandy(Integer money) {
        Candy candy;
        switch (money) {
            case 1:
                candy = new Candy("大白兔", "甜的", "白色");
                break;
            case 5:
                candy = new Candy("卫龙", "辣的", "红色");
                break;
            case 10:
                candy = new Candy("有钱人吃砖", "火辣辣的", "疼");
                break;
            default:
                candy = new Candy("土", "苦的", "黑色");
                break;
        }
        return candy;
    }

}

SellCandyApplication是服务提供者的启动方法，代码如下：

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * 服务提供者启动方法
 */
public class SellCandyApplication {

    public static void main(String[] args) throws IOException {
        // 通过类路径加载器加载spring容器
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("dubbo-provider.xml");
        // 启动spring
        ioc.start();
        // 向控制台打印一段话，标志服务提供者开始提供服务
        System.out.println("商店开门啦！");
        // 将线程阻塞住，以免还没等到消费者调用，提供者就已经结束
        System.in.read();
    }

}

既然provider需要暴漏服务给消费者，自然少不了dubbo的配置文件，所以，在resources目录中新建了配置文件dubbo-provider.xml，具体内容如下：

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:context="http://www.springframework.org/schema/context"
       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://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

    <!-- Spring包扫描。base-package：要扫描的包路径 -->
    <context:component-scan base-package="service.impl"></context:component-scan>

    <!-- 此工程在dubbo中的项目名称。name：项目名称 -->
    <dubbo:application name="provider"></dubbo:application>

    <!-- dubbo的注册中心。 protocol：协议名称，address：注册中心的URL地址 -->
    <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>

    <!-- 服务提供者在接收服务消费者请求时的处理协议和端口。name：协议名称，port：端口号 -->
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>

    <!-- 实现了暴漏服务的接口的真实具体实现类。id：bean的唯一标识，class：具体实现类的位置 -->
    <bean id="shopServiceImpl" class="service.impl.ShopServiceImpl"></bean>

    <!-- 暴漏出需要提供服务的接口。interface：提供服务的接口的位置，ref：引入的具体实现bean的ID，就是上面的那个bean的ID -->
    <dubbo:service interface="service.ShopService" ref="shopServiceImpl"></dubbo:service>
</beans>

至此，provider也全部写完了，慈祥的商店老奶奶已经上线，接下来就是我们的小盆友了。

Consumer

小盆友具有去买糖的功能实现类ToBuyServiceImpl，作为消费者的启动类ToBuyApplication以及自身作为dubbo服务消费者的dubbo配置xml文件。

代码结构如下：

去买糖的功能实现类ToBuyServiceImpl：

package service.impl;

import bean.Candy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import service.ShopService;
import service.ToBuyService;

@Service
public class ToBuyServiceImpl implements ToBuyService{

    // 这里自动注入的就是dubbo-consumer.xml中通过dubbo:reference标签引入的shopService了
    @Autowired
    ShopService shopService;

    /**
     * 买糖
     * @param money 妈妈给的钱（给多给少看心情啊）
     * @return
     */
    @Override
    public Candy toBuyCandy(Integer money) {
        // 通过dubbo:reference标签引入的shopService来调用服务提供者（也就是商店）所暴漏的远程服务（也就是卖糖）
        return shopService.sellCandy(money);
    }

}

作为消费者的启动类ToBuyApplication：

import bean.Candy;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.ToBuyService;

import java.util.Scanner;

public class ToBuyApplication {

    public static void main(String[] args) {
        // 通过类路径加载器加载spring容器
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("dubbo-consumer.xml");
        // 通过spring容器获取bean
        ToBuyService toBuyService = ioc.getBean(ToBuyService.class);
        // 用于获取控制台输入
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 读取控制台中用户输入的金额
            System.out.println("小老弟，阿姨今天给你多少钱买糖啊？");
            Integer money = scanner.nextInt();
            // 调用bean的方法
            Candy candy = toBuyService.toBuyCandy(money);
            // 将结果打印输出
            System.out.println(candy);
        }
    }

}

以及作为dubbo消费者的dubbo配置xml文件：

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:context="http://www.springframework.org/schema/context"
       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://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

    <!-- Spring包扫描。base-package：要扫描的包路径 -->
    <context:component-scan base-package="service.impl"></context:component-scan>

    <!-- 此工程在dubbo中的项目名称。name：项目名称 -->
    <dubbo:application name="consumer"></dubbo:application>

    <!-- dubbo的注册中心。 protocol：协议名称，address：注册中心的URL地址 -->
    <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>

    <!-- 引入远程服务提供者暴漏的服务接口以便进行方法调用。interface：服务提供者暴漏的接口位置，需要与对应的dubbo-provider.xml的dubbo:service接口中的interface保持一致，id：引入的接口作为bean的id -->
    <dubbo:reference interface="service.ShopService" id="shopService"></dubbo:reference>

</beans>

至此，我们的代码就写完了，来运行一下试试吧！

1. 首先启动服务提供者，运行SellCandyApplication类中的main方法：

2. 其次启动服务消费者，运行ToBuyApplication类中的main方法：

至此，我们的简单入门级dubbo+zookeeper示例就编写结束啦，感谢看到这的小伙伴，谢谢您！

 

Hatoandaburedo
关注
专栏目录
SSM框架下Dubbo+Zookeeper入门学习一
xiaobudingya的博客
11-18 217
这是bilibili学习后我做的笔记总结，感谢大佬们分享。 如果想看视频直接跳转 从垂直项目架构到SOA项目架构 一、垂直项目架构 传统的垂直架构，分为表现层，业务逻辑层和数据访问层。整个项目打包放在一个tomcat里面。这种垂直的架构对于维护来说是特别的方便的，但是一但修改某一小段代码就要重新打包部署。 特点： 1、 耦合度比较高。 2、不利于扩展。 3、不利于团队协同合作。 二、SOA架构 S...
SpringBoot整合dubbo2.7.8+zookeeper3.4.14
01-27
本文将深入探讨如何将SpringBoot 2.4.2与Dubbo 2.7.8以及Zookeeper 3.4.14整合，帮助初学者快速入门。 首先，SpringBoot是由Pivotal团队开发的一个框架，它简化了Spring应用的初始搭建和配置过程。通过内置的Tomcat...
Dubbo+zookeeper 入门简单实例
03-23
Dubbo入门实例Demo
dubbo+zookeeper例子
weixin_33775572的博客
07-12 166
0.原理 Alibaba有好几个分布式框架，主要有：进行远程调用(类似于RMI的这种远程调用)的(dubbo、hsf)，jms消息服务(napoli、notify)，KV数据库(tair)等。这个框架/工具/产品在实现的时候，都考虑到了容灾，扩展，负载均衡，于是出现一个配置中心(ConfigServer)的东西来解决这些问题。 基本原理如图： 在我们的系统中，经常会有一些...
Dubbo+Zookeeper入门实例
屌丝程序员的奋斗之路
05-20 7782
现在的公司接口调用是通过dubbo来实现的，所以这两天就了解了一下dubbo是如何进行通信的，写了一个最简单的例子。自上得来终觉浅，绝知此事要躬行。      一.dubbo介绍                Dubbo是一个分布式服务框架，Dubbo的架构如图所示： 节点角色说明： Provider: 暴露服务的服务提供方。 Consumer: 调用远程服务
zookeeper快速入门
weixin_34332905的博客
03-19 85
一。zookeeper简介 zookeeper 是apache旗下的hadoop子项目，它一个开源的，分布式的服务协调器。同样通过zookeeper可以实现服务间的同步与配置维护。通常情况下，在分布式应用开发中，协调服务这样的工作不是件容易的事，很容易出现死锁，不恰当的选举竞争等。zookeeper就是担负起了分布式协调的重担。 zookeeper的特...
dubbo+zookeeper简单的demo实例
qq_40065816的博客
07-11 469
初学dubbo的浅解： 1.什么是dubbo: Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA（将项目拆分为多个独立的服务，以实现各模块功能独立互不影响）服务治理方案。 2.dubbo的作用： 网上很多，可自行查看，简单来说，就是用来解决service层的压力。 3.dubbo使用原理： 共有五个节点，每个对应如下： Consumer：调用远程服务的...
dubbo+zookeeper+ssm入门案例
02-08
综合以上分析，这个入门案例将涵盖如何设置Zookeeper服务注册中心，如何使用Dubbo创建服务提供者和服务消费者，以及如何在SSM框架下实现业务逻辑并将其与Dubbo服务集成。学习这个案例，可以帮助开发者深入理解分布式...
DUBBO+Zookeeper小例子
03-14
本示例"**DUBBO+Zookeeper小例子**"旨在演示如何利用SpringMVC、Dubbo和Zookeeper来实现一个微服务架构。这是一次将这些组件集成到一起的实际操作，通过IDEA（IntelliJ IDEA）开发环境进行。在开始之前，确保你已...
Dubbo+zookeeper入门实例
Dem0_0的博客
02-06 1081
Dubbo入门实例，服务方+消费方
zookeeper与dubbo快速入门案例
希冀
11-20 549
文章目录zookeeper&dubbo1. 概述1.1. 什么是zookeeper1.2. 本质及主要作用1.2.1. 统一命名服务1.2.2. 配置管理1.2.3. 集群管理2. 下载及安装2.1. 安装2.2. 配置文件解读2.3. 启动zookeeper2.4. 客户端连接3. Znode数据模型3.1. 数据结构图3.2. 节点类型3.3. 节点属性4. 通知机制（watch）4.1. watch机制特点4.2. shell客户端演示5. java客户端6. dubbo入门6.1. 架构
Dubbo+Zookeeper的简单入门案例
weixin_30496431的博客
06-13 226
1.1 Dubbo简介 Apache Dubbo是一款高性能的Java RPC框架。其前身是阿里巴巴公司开源的一个高性能、轻量级的开源Java RPC框架，可以和Spring框架无缝集成。 什么是RPC？ RPC全称为remote procedure call，即远程过程调用。比如两台服务器A和B，A服务器上部署一个应用，B服务器上部署一个应用，A服务器上的应用想调用B服务器上的...
Dubbo+ZooKeeper搭建的简单示例
weixin_30672019的博客
08-14 173
一、简介 　　基于Dubbo + ZooKeeper实现的分布式架构，调用接口方法就像调用本地方法一样调用远程服务。 　　来自Dubbo官网的架构图： 　　节点角色说明 节点角色说明 Provider 暴露服务的服务提供方 Consumer 调用远程服务的服务消费方 Registry 服务注册与发现...
dubbo学习2：安装zookeeper 环境下的dubbo例子
胡小海丶
06-13 132
   先要在自己的电脑上配置zookeeper注册中心   在百度上搜到的资料 ：  可以再http://hadoop.apache.org/zookeeper/来获取  Zookeeper 的启动脚本在 bin 目录下，Windows 下的启动脚本是 zkServer.cmd。 在你执行启动脚本之前，还有几个基本的配置项需要配置一下，Zookeeper 的配置文件在 conf 目录下...
dubbo+zookeeper示例记录
weixin_30323631的博客
07-25 107
提示：要直接看搭建例子的可以跳到 三 一.项目架构的发展 传统的mvc架构项目将整个系统功能实现全部写在一个项目中，部署在一个机器上，随着用户量的增涨，单个项目服务器无法承受暴增的用户请求时需要增加服务器数量，并通过负载均衡集群将项目部署到多个服务器上，提高项目可处理的用户请求总数。 当mvc架构项目中的某个或某几个模块的用户请求量较大，其他模块用户请求量较小，此时负载均衡集群依...
dubbo+zookeeper分布式服务【个人理解分享】
ningDr的博客
08-29 1025
看了一篇文章，介绍dubbo的原理，但是跟着做了下，发现该文章存在些许问题，及一些令新手比较费解的知识点没有介绍，在此篇博文仅介绍个人观点及代码实测结论。 百科dubbo，其实讲的已经比较详细。文后附上测试代码，方便大家测试 下面是dubbo的原理图： 一、首先，搭建zookeeper【动物饲养员，刚看到zookeeper懵逼状态，后来偶然看到这个翻译，恍然大悟】 下载地址：http:...
Dubbo和Zookeeper实战，看这篇就够了
公号：黎杜编程
01-13 6633
前沿：在当下流行的分布式架构中Dubbo是非常流行的一门技术，借着这几天有空学习学习，并在后面的项目中进行实战，为后面的分布式项目做铺垫。 Dubbox简介 Dubbox 是一个分布式服务框架，其前身是阿里巴巴开源项目Dubbo ，被国内电商及互联网项目中使用，后期阿里巴巴停止了该项目的维护，当当网便在Dubbo基础上进行优化，并继续维护，为了与原有的Dubbo区分，故将其命名为Dubbox。 D...
一文入坑分布式框架Dubbo + Zookeeper【纯代码实例篇】
qq_43097201的博客
09-25 344
Dubbo是一款非常优秀的RPC框架，Zookeeper主要是作为服务发现与注册中心的组件 1、首先我们需要在本地安装zookeeper，由于官方网站下载的速度很慢，这里我直接提供压缩包。大家只需要解压后修改一下config目录下的 zoo.cfg <zoo_sample.cfg改名而来> 的data、log目录即可。（详情参考网上zookeeper安装教程） 链接：https://pan.baidu.com/s/1faoS6t2CUCEOQNuDRhaHQA 提取码：llhm 2、安装
Dubbo zookeeper 初探
tag16的博客
11-03 101
[size=medium]转，原贴地址：http://blog.csdn.net/wxwzy738/article/details/16330383 建议参考资料： http://blog.csdn.net/lin_fs/article/details/7395307 http://blog.csdn.net/goliathray/article/details/856580...
Dubbo搭建与使用入门示例教程
资源摘要信息: "本示例文档旨在介绍如何使用Dubbo框架快速搭建一个简单的分布式服务架构。Dubbo是由阿里巴巴开源的一个高性能、轻量级的Java RPC框架。通过本示例，读者将学会如何创建一个提供服务的dubbo server...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值