最简单的Dubbo案例之一：dubbo实现服务提供者+消费者，无zookeeper方式点对点直连

最新推荐文章于 2024-09-21 15:55:12 发布

小崔爱读书

最新推荐文章于 2024-09-21 15:55:12 发布

阅读量1.4k

点赞数 3

分类专栏：分布式和大数据文章标签： zookeeper dubbo 分布式 java spring

本文链接：https://blog.csdn.net/cuipy/article/details/120687811

版权

分布式和大数据专栏收录该内容

20 篇文章 3 订阅

订阅专栏

本文详细介绍了如何使用Dubbo创建两个项目，分别是服务提供者(say-provider)和服务消费者(say-consumer)，在不依赖Zookeeper的情况下，通过配置实现点对点直连。内容包括各个模块的pom.xml配置，dubbo的provider和consumer配置，以及SayService接口的实现和测试。项目结构简洁，旨在帮助读者深入理解Dubbo的基本工作原理。

摘要由CSDN通过智能技术生成

1. 概述

2. 项目结构

3. parent项目开发

4. say-provider项目：服务提供者开发

4.1. pom.xml

4.2. dubbo-provider.xml 文件

4.3. SayService接口

4.4. SayServiceImpl 类

4.5. TestMain 类启动项目代码

5. say-consumer项目：服务消费者开发

5.1. pom.xml文件

5.2. dubbo-consumer.xml文件

本文是最简单的 dubbo 案例三部曲之一。

后续会推出《最简单的Dubbo案例之二：dubbo实现服务提供者+消费者，SpringBoot + dubbo 无zookeeper方式点对点直连》和《最简单的Dubbo案例之三：dubbo实现服务提供者+消费者，SpringBoot + dubbo + zookeeper 》

1. 概述

本文描述了使用dubbo 创建两个项目：服务提供者项目 + 服务消费者项目，并在不采用zookeeper注册中心的方式，实现点对点直连。

本文实现的功能非常简单，服务提供者提供一个方法 String sayHi(String uname) ，调用该方法传入用户姓名，并返回 hello,uname 的字符串。

本文集中在 dubbo 的直连实现，摒弃了Spring框架，SpringBoot框架，也没有数据库读写，因此不存在任何复杂技术干扰和复杂业务干扰，可清清楚楚、简单明白的理解 dubbo 。

2. 项目结构

本项目基于 maven 开发，结构如下图：

从图中可以看出，我做了一个 dubbo1 的 maven 项目，这个项目啥功能也没有，只是作为 parent项目，方便多模块管理。

say-provider模块是服务提供者，say-consumer模块是服务消费者。

say-provider的功能就是提供了一个方法 String sayHi(String uname) , 调用这个方法就返回字符串 hello,uname ，功能就是这么简单。

say-consumer的功能就是调用 say-provider 模块的方法的 sayHi。

这两个模块之间是基于 dubbo 实现 rpc 的。

功能就是这么简单，咋地！！

3. parent项目开发

parent项目指的是 dubbo1 项目

这个项目啥也没有，就一个 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.pingbu</groupId>
    <artifactId>dubbo1</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
    </properties>

    <modules>
        <module>say-provider</module>
        <module>say-consumer</module>
    </modules>

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

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.11</version>
        </dependency>

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.68.Final</version>
        </dependency>
        
    </dependencies>

</project>

解释几个：

1 packaging项目要取值 pom ，因为这个项目是一个 parent项目，这是maven的规定。

2 dubbo 需要依赖 netty ，所以要加入 netty-all 依赖。

3 这个项目是不急于 zookeeper 的，即点对点直连的，因此依赖中 zookeeper 相关的都不需要。

4. say-provider项目：服务提供者开发

服务提供者就是指 say-provider 模块，结构如下图：

该项目继承自 dubbo1 项目，先看看 pom.xml 文件。

4.1. 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>
    <dependencies>

    </dependencies>

    <parent>
        <groupId>com.pingbu</groupId>
        <artifactId>dubbo1</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>com.pingbu</groupId>
    <artifactId>say-provider</artifactId>
    <version>1.0-SNAPSHOT</version>

    
</project>

这个pom.xml文件没什么可说的。

4.2. 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="SayProvider" owner="pingbu">
        <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 version="1.0.0"
            interface="com.pingbu.dubbo1.provider.SayService"
            ref="sayService"/>

    <!--Bean bean定义-->
    <bean id="sayService" class="com.pingbu.dubbo1.provider.SayServiceImpl"/>

</beans>

这个文件其实是一个 spring 配置文件。

由于 dubbo 底层是基于 spring 的，所以，我虽然没有引入spring的依赖，但可以直接使用spring。

这个文件的几部分解释一下：

1 dubbo:application 配置应用名称的，或者叫服务名称，熟悉分布式架构开发的朋友们都知道，在分布式架构开发中需要将服务注册到注册中心，每个服务必须有一个唯一的名字。这个属性就是配置这个名字的。至于这个属性的其他功能，不赘述。本文档属于入门级别的，不增加复杂度。

2 dubbo:registry 指向注册中心，这里的值为 N/A ，就是说不需要注册到注册中心。

这里又带出一个知识点 --- 注册中心，一般我们用 zookeeper 做 dubbo服务的注册中心。本文采用直连方式，因此没有注册中心。

3 dubbo:protocol dubbo通信采用的协议和端口，就是dubbo的服务提供者和消费者之间的通信协议。

4 dubbo:service 这是暴露一个dubbo接口，服务提供者提供出来一个api 。interface指向的接口，ref 指向的是 spring 的依赖对象名称。

4.3. SayService接口

这个接口定义非常简单，代码如下：

package com.pingbu.dubbo1.provider;

public interface SayService {

    String sayHi(String uname);


}

4.4. SayServiceImpl 类

依旧直接上代码，不解释。

package com.pingbu.dubbo1.provider;

public class SayServiceImpl implements SayService {
    @Override
    public String sayHi(String uname) {
        return "hello , "+uname;
    }
}

4.5. TestMain 类启动项目代码

本项目是演示项目，为了简单方便，采用了test方式启动。代码见TestMain类

package com.pingbu.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

public class TestMain {

    @Test
    public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("dubbo-provider.xml");
        context.start();

        try {
            System.in.read(); // 按任意键退出
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

没啥可说的，执行就启动了。

启动后，就有了服务提供者了，消费者就可以调用了，那么我们就开始写消费端的代码吧。

5. say-consumer项目：服务消费者开发

惯例，还是先看项目结构：

令人瞠目结舌的简单。

里面就三文件，一个 dubbo-consumer.xml ，一个SayService接口 ，再就是程序启动测试代码 TestMain 类。

5.1. 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>
    <dependencies>

    </dependencies>

    <parent>
        <groupId>com.pingbu</groupId>
        <artifactId>dubbo1</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>com.pingbu</groupId>
    <artifactId>say-consumer</artifactId>
    <version>1.0-SNAPSHOT</version>


</project>

5.2. 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="SayConsumer" owner="pingbu"/>

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

    <!--生成一个远程服务的调用代理-->
    <!--点对点方式-->
    <dubbo:reference id="sayService" version="1.0.0"
                     interface="com.pingbu.dubbo1.consumer.SayService"
                     url="dubbo://127.0.0.1:20880/com.pingbu.dubbo1.provider.SayService"/>

</beans>

简单解释一下：

dubbo:refererence 定义的要调用的服务提供者的api .

非常奇怪的是，我在写这个代码的时候，定义的接口的包名和服务提供者的包名不同，居然可以执行，实话实话，我百度了很长时间，资料都说这个包名需要一致，而且，我在springboot 框架下测试也是必须一致的，但这个项目就是可以执行，我也不清楚为什么，有经验的高手可以指教一下。

5.3. SayService接口

没什么可说的，就是与服务提供者一样的接口。

唯一奇怪的就是我用了不同的包名，居然可以用，刚刚我也说了，我确实不知道为什么。

package com.pingbu.dubbo1.consumer;

public interface SayService {

    String sayHi(String uname);

}

5.4. TestMain启动类

代码如下：

package com.pingbu.test;


import com.pingbu.dubbo1.consumer.SayService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestMain {

    @Test
    public void test1(){
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("dubbo-consumer.xml");
        context.start();
        SayService sayService = (SayService) context.getBean("sayService");
        String str = sayService.sayHi("老田!");
        System.out.println(str);
    }

}

看代码的功能就是spring方式加载配置文件，然后获取 bean SayService，然后调用执行这个 bean。

执行ok，就说明框架没问题了。