2020-05-05

Dubbo

Dubbo & ZooKeeper 简单入门

Dubbo & ZooKeeper

分布式的基本定义

分布式系统是若干个独立计算机的集合，这些计算机对于用户来说就像单个相关系统

利用更多机器，进行更多计算

使用廉价的机器完成更高性能的计算机才能完成的工作

应用架构的演变

单一的小型应用
垂直应用架构（多个应用放在多个多个服务器上）
- 界面-逻辑实现分离
- 应用
分布式服务架构

RPC

远程过程调用

相对于本地过程调用，本地A方法调用本地B方法

远程过程调用，本地的A方法调用另外一台电脑上的B方法

他允许程序调用另一个地址空间的过程或函数，而不用程序员显式编码这个远程调用的细节，使调用本地的过程和调用远程的过程代码基本相同

ZooKeeper

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

安装zookeeper

下载地址：https://zookeeper.apache.org/releases.html

下载安装完成后，需要配置一个文件才能进行运行

在安装目录下conf文件夹下配置一个zoo.cfg

需要把zoo_sample.cfg复制一份，然后进行配置

如果出错，确保环境变量中JAVA_HOME配置正确

启动zookeeper

启动bin目录下

以管理员身份启动 zkServer.cmd，服务端程序

如果没有闪退就证明启动成功了，如果闪退可能是Java环境变量的问题

再启动zkCli.cmd，这是客户端程序

Dubbo Admin

为了方便我们管理Dubbo，我们使用Dubbo Admin来进行管理

下载Dubbo Admin 的方式很简单

https://github.com/apache/dubbo-admin/tree/master

直接clone或者下载下来都行

因为这个只有源码，只能自己进行构建，我们使用maven进行构建

在项目根目录打开cmd

mvn clean package

便会自动开始打包

Dubbo Admin默认的端口是7001端口

server.port=7001
spring.velocity.cache=false
spring.velocity.charset=UTF-8
spring.velocity.layout-url=/templates/default.vm
spring.messages.fallback-to-system-locale=false
spring.messages.basename=i18n/message
spring.root.password=root
spring.guest.password=guest

dubbo.registry.address=zookeeper://127.0.0.1:2181

这里面的东西都能进行更改

如果zookeeper的端口号进行了修改的话，这里也要同步进行修改

打包好的jar在dubbo-admin/target文件夹下，cd到那边，在这里进行启动

java -jar jar包名

基本上就成功运行了

重要提醒：打开dubbo-admin之前要打开zookeeper

Dubbo

面向接口代理的高性能RPC调用
智能负载均衡
服务自动注册与发现

快速开始

导入依赖

这里没有使用spring boot，使用的是一个普通的maven项目

<!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dubbo</artifactId>
    <version>2.6.2</version>
</dependency>

因为zookeeper的注册也需要使用jar包

Dubbo 支持 zkclient 和 curator 两种 Zookeeper 客户端实现

这里注意

Dubbo从 2.2.0 版本开始缺省为 zkclient 实现
Dubbo从 2.3.0 版本开始支持可选 curator 实现

根据我这里的Dubbo版本，我们使用curator实现

<!-- https://mvnrepository.com/artifact/org.apache.curator/curator-framework -->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>4.2.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.curator/curator-recipes -->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>4.2.0</version>
</dependency>

场景描述

这里分为两个角色生产者(服务提供者)和消费者(服务使用者)

生产者提供服务，消费者消费服务

定义生产者提供服务的类

public interface UserService()
{
    User findUserById(String id);
}

消费者使用的类是

public interface OrderService()
{
    void addOrder();
}

这是两个接口

其中消费者使用的方法中会调用这个生产者的UserService

代码编写

定义公共的接口项目

在官方文档中指出

http://dubbo.apache.org/zh-cn/docs/user/best-practice.html

建议将服务接口、服务模型、服务异常等均放在 API 包中，因为服务模型和异常也是 API 的一部分，这样做也符合分包原则：重用发布等价原则(REP)，共同重用原则(CRP)。

所以我们在使用Dubbo的时候最好建立一个API包

在项目中新建API模块，取名service-api，这是一个maven项目，里面存放的内容有

Bean
Service的接口
...等公共的部分

所以我们在里面新建一个包，com.dubboLearn.pojo，编写Bean

public class User {
    private String UserId;
    private String UserName;
}

新建一个包com.dubboLearn.service编写Service，里面的内容和刚刚场景描述中的相同

编写服务提供者

新建一个模块dubbo-provider，也是一个普通的maven项目，在pom.xml文件中需要导入依赖

<dependency>
    <groupId>com.dubboLearn</groupId>
    <artifactId>service-api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

这样构建的时候就导入了Api模块的依赖

编写服务的实现类，在com.dubboLearn.service.impl包下新建UserServiceImpl

public class UserServiceImpl implements UserService {

    public static Map<String,User> userMap;
    static {
        userMap = new HashMap<String, User>();
        userMap.put("1",new User("1","lucas"));
    }
    public User findUserById(String id) {
        return UserServiceImpl.userMap.get(id);
    }

}

我们这里使用的假数据，由静态代码块进行初始化

现在我们将配置dubbo并暴露服务

因为dubbo的底层也使用spring进行项目的管理，我们可以使用spring配置文件进行配置

在官方文档中

http://dubbo.apache.org/zh-cn/docs/user/quick-start.html

创建，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://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
       http://dubbo.apache.org/schema/dubbo
       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 提供方应用信息，用于计算依赖关系 -->
    <!-- 只要不和别的服务同名就行 -->
    <dubbo:application name="server-provider"  />

    <!-- 使用zookeeper注册中心暴露服务地址 -->
    <!-- 指定注册中心的位置 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" />
    <!-- 也可以这样写 -->
    <!-- <dubbo:registry protocol="zookeeper" address="zookeeper://127.0.0.1:2181"/> -->

    <!-- 用dubbo协议在20880端口暴露服务 -->
    <!-- 指定通信规则 -->
    <dubbo:protocol name="dubbo" port="20880" />

    <!-- 声明需要暴露的服务接口 -->
    <!-- ref指向真正实现的类 -->
    <dubbo:service interface="com.dubboLearn.service.UserService" ref="userService" />

    <!-- 和本地bean一样实现服务 -->
    <!-- 注册这个bean到 spring 容器 -->
    <bean id="userService" class="com.dubboLearn.service.impl.UserServiceImpl" />
</beans>

启动这个服务

编写main方法

public static void main(String[] args) throws IOException {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:provider.xml");
    //启动Ioc容器
    context.start();
    //阻塞进程，不让容器关闭
    System.in.read();
}

此时如果报错可能是jar包导入的不对，导入的是阿里的依赖，不是阿帕奇的

如果zookeeper启动的话，那么项目启动就会成功，在Dubbo admin控制台中也能看得见v

编写服务的使用者

新建一个模块dubbo-consumer，是一个普通的maven项目

和provider一样，新建一个包com.dubboLearn.service.impl，新建一个类OrderServiceImpl

编写实现类

public class OrderServiceImpl implements OrderService {
    
    private UserService userService;

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    
    public void addOrder() {
        User user = userService.findUserById("1");
        if (user!=null)
            System.out.println(user.getUserName()+"订购了一些东西");
    }
}

配置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://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
       http://dubbo.apache.org/schema/dubbo
       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->
    <dubbo:application name="dubbo-consumer"  />

    <!-- 使用multicast广播注册中心暴露发现服务地址 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" />

    <!-- 生成远程服务代理，可以和本地bean一样使用UserService -->
    <!-- 声明需要访问的服务的接口，在本地IOC容器中生成代理 -->
    <dubbo:reference id="userService" interface="com.dubboLearn.service.UserService" />

    <!-- 在容器中注册我们刚刚写好的Bean -->
    <bean id="orderService" class="com.dubboLaern.service.impl.OrderServiceImpl">
        <property name="userService" ref="userService"/>
    </bean>
</beans>

启动消费者

public static void main(String[] args) throws IOException {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("consumer.xml");
    OrderService orderService = context.getBean("orderService", OrderService.class);
    orderService.addOrder();
    System.in.read();
}

这样调用就成功了

dubbo 监控中心

在刚刚的Dubbo Admin文件夹中有一个dubbo-monitor，在里面构建项目，构建完会有一个压缩包，解压

里面有一个conf文件夹，文件夹下有一个properties文件，里面的文件按需更改

值得注意的是

dubbo.protocol.port=7070

这个可能会用到

在bin目录下找到start.bat，启动，访问刚刚配置文件中的端口号，如果能访问成功那就证明配置没问题

配置注册的服务

在provider.xml中配置

使用以下两种都可以

```
 <dubbo:monitor protocol="registry"/>
```

 <dubbo:monitor address="127.0.0.1:7070"/>

第一个表示从注册中心寻找

第二个表示直接连接监控中心，address中填的端口号就是刚刚配置的端口号

这样监控中心就有服务的信息了

当然，在consumer那边也是可以配置的

# Dubbo

Dubbo & ZooKeeper 简单入门

Dubbo & ZooKeeper

分布式的基本定义

RPC

ZooKeeper

安装zookeeper

启动zookeeper

Dubbo Admin

Dubbo

快速开始

导入依赖

场景描述

代码编写

定义公共的接口项目

编写服务提供者

启动这个服务

编写服务的使用者

配置dubbo

启动消费者

dubbo 监控中心

配置注册的服务

评论

分类

标签云

链接

最新文章

标签

最新文章

标签

Your browser is out-of-date!