关于java:第一个基于DubboZookeeper搭建的项目

9次阅读

共计 6774 个字符，预计需要花费 17 分钟才能阅读完成。

文 | 平哥日期 | 20201013

具体代码详见 GitHub 仓库：点我跳转

此我的项目为本人学习 Dubbo+Zookeeper，搭建的第一个我的项目，次要架构就是一个父我的项目、三个子 Module：dubbo_provider、dubbo_consumer 和 dubbo_api，三个子 Module 别离继承父我的项目。

Dubbo 的近程拜访是基于接口的。Consumer 和 Provider 应用同一个接口，能够实现近程拜访。

Provider 给接口写实现，提供服务。
Consumer 应用接口，并通过 Dubbo 创立的动静代理对象，近程拜访 Provider。
把接口独立定义在一个工程（dubbo_api）中，做依赖治理。

p.s. 此我的项目重点是练习 Dubbo+Zookeeper，故没有写连贯数据库的内容，只是模仿了拜访数据库。

用 IDEA 创立我的项目，创立完我的项目目录如下：

间接上代码：

<?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.gcp</groupId>
    <artifactId>dubbo_pro01</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>dubbo_provider</module>
        <module>dubbo_consumer</module>
        <module>dubbo_api</module>
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>
    <dependencies>
        <!--springboot 启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--lombok 依赖 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--dubbo springboot 启动器 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>
        <!--curator 依赖 -->
        <!--Curator 提供了一套 Java 类库，能够更容易的应用 ZooKeeper。-->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>5.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>5.1.0</version>
        </dependency>
    </dependencies>
</project>

package com.gcp.pojo;
import lombok.Data;
@Data
public class User {
    private Long id;
    private String name;
    private String password;
}

package com.gcp.service;
import com.gcp.pojo.User;
/**
 * 用户服务接口
 */
public interface UserService {void register(User user);
    User getUserById(Long id);
}

Dubbo 服务提供者 Provider，是不须要定义 Controller 的，是间接通过 Service 提供服务的。
应用 Dubbo 框架提供的注解 @DubboService，申明以后的类型的对象，是一个 Dubbo 服务提供者。
让 Spring 容器初始化、治理，并通过 curator 框架，把服务信息注册到 Zookeeper 中。
在老版本的 Dubbo（2.6（含）以前）中，注解命名是 @Service。所以应用老版本开发的时候，留神导入的注解的包。
须要提供一个 application.yml 配置文件，阐明 Dubbo 应用的注册核心是什么，地址是什么。

在 pom.xml 文件中增加依赖：

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

UserMapper 接口：

import com.gcp.pojo.User;

/**
 * 模仿数据库拜访
 */
public interface UserMapper {void insert(User user);
    User selectById(Long id);
}

UserMapperImpl 实现类：

@Repository
public class UserMapperImpl implements UserMapper {
    @Override
    public void insert(User user) {System.out.println("数据库拜访：新增用户 -" + user);
    }

    @Override
    public User selectById(Long id) {User user = new User();
        user.setId(id);
        user.setName("name" + id);
        user.setPassword("password" + id);
        System.out.println("数据库拜访：主键查问用户 -" + user);
        return user;
    }
}

@DubboService(loadbalance = "roundrobin")，其中 loadbalance = "roundrobin" 意思是如果此服务有集群将采纳轮询的形式进行负载平衡拜访，
默认是 random：随机


@DubboService(loadbalance = "roundrobin")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public void register(User user) {System.out.println("UserService 实现类中：注册用户");
        userMapper.insert(user);
    }

    @Override
    public User getUserById(Long id) {System.out.println("UserService 实现类中：依据 id 查问用户");
        return userMapper.selectById(id);
    }
}

阐明：

dubbo 中，对每个服务提供者和消费者的治理，都是基于利用级别的。
都是应用命名作为惟一标记的。
同名的服务提供者或消费者，主动组成集群。
dubbo 利用默认应用的协定是 dubbo 协定，应用的端口默认为 20880。协定是能够配置的。

在 resources 文件夹下创立 application.yml：

dubbo: # dubbo 配置根节点
  registry: # 配置 dubbo 的注册核心 registry
    address: zookeeper://192.168.40.170:2181  # 提供注册核心的拜访地址。application: # 配置本 dubbo 利用信息
    name: gcp-dubbo-first-provider  # 配置本 dubbo 的利用名称，名称组成是：字母，数字，'-'，字母结尾
  protocol: # 协定，协定自定义配置的时候，所有的默认值生效。name: dubbo # 协定名
    port: 20880 # 端口，默认 20880

如何装置 Zookeeper 能够详见我另一篇文章

启动的每个 Dubbo 利用，肯定会在注册核心中注册信息。
服务提供者注册的是 /dubbo/xxx/providers
服务消费者注册的是 /dubbo/xxx/consumers

*

Dubbo 启动器（dubbo-spring-boot-starter）默认不失效。
必须通过 @EnableDubbo 让启动器失效。
在 2.7.2- 以前版本中，局部配置默认不加载，须要应用 @EnableDubboConfig 让全副配置失效。
负载平衡策略：
设置负载平衡策略，能够在 @DubboService 或者 @DubboReference 注解上
加属性 loadbalance 进行配置。
消费者默认是不思考负载平衡策略的，是应用提供者定义的负载平衡策略。
如果消费者配置了负载平衡策略，则疏忽提供者配置的负载平衡策略。

在 com.gcp 包下创立 SpringBoot 启动类：

@SpringBootApplication
@EnableDubbo
// @EnableDubboConfig
public class DbProviderApplication {public static void main(String[] args) {SpringApplication.run(DbProviderApplication.class,args);
    }
}

此时可启动，测试看 Zookeeper 中是否胜利注册上服务，拜访 Linux 服务器，利用 Zookeeper 客户端工具查看：

在 pom.xml 文件中增加依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.gcp</groupId>
        <artifactId>dubbo_api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

有人可能会纳闷，Zookeeper 注册核心中曾经有提供的 Service 服务了，怎么本地还须要 Service？
阐明： 其实，dubbo 近程服务调用，是为了 封装通用规定 ，但各个子项目有本人的共性逻辑
如：用户的注册逻辑，在一个企业中是对立的。提供一个 Provider 实现注册逻辑；
对于 consumer 来说，是不同的，能够提供若干入口。如腾讯的用户注册，能够通过 QQ、QQ 音乐、QQ 空间等实现注册或登录。底层的用户是雷同的。

LocalUserService 接口：

package com.gcp.service;
import com.gcp.pojo.User;
/**
 * consumer 子 Module 的本地 Service
 */
public interface LocalUserService {void register(User user);
    User getById(Long id);
}

LocalUserServiceImpl 实现类：

@Service
public class LocalUserServiceImpl implements LocalUserService {

    /**
     * 近程服务的接口。通过注解 @DubboReference 实现动静代理创立
     * 规定：* 1、告诉 Dubbo 框架，依据配置找注册核心，发现服务的地址。*    拿接口名称作为 zookeeper 中节点的命名规定，获取地址。* 2、告诉 Spring，依据 Dubbo 框架的个性，创立接口的动静代理对象，并保护
     *    在 Spring 容器中。* 3、相似 @Autowired，把代理对象注入到以后的变量中。*/
    @DubboReference
    private UserService userService;
    @Override
    public void register(User user) {System.out.println("筹备调用近程服务，服务对象类型是：" + userService.getClass().getName());
        System.out.println("注册的用户是：" + user);
        userService.register(user);
    }
    @Override
    public User getById(Long id) {System.out.println("依据主键查问用户，主键是：" + id);
        return userService.getUserById(id);
    }
}

UserController 类：

@RestController
public class UserController {

    @Autowired
    private LocalUserService localUserService;
    @RequestMapping("findUser")
    public User findUser(Long id){return localUserService.getById(id);
    }
    @RequestMapping("registerUser")
    public String register(User user){localUserService.register(user);
        return "注册用户胜利";
    }
}

在 resources 文件夹下创立 application.yml：

dubbo:
  registry:
    address: zookeeper://192.168.40.170:2181

在 com.gcp 包下创立 DbConsumerApplication：

@SpringBootApplication
@EnableDubbo
public class DbConsumerApplication {public static void main(String[] args) {SpringApplication.run(DbConsumerApplication.class,args);
    }
}

启动 consumer 的启动类，查看 Zookeeper 注册核心是否注册胜利：

关上浏览器，输出 consumer 拜访地址，测试是否能够失常拜访：

后盾输入：
consumer 子 Module：

provider 子 Module：

至此，我的项目搭建创立胜利，大家能够本人多复制几个 provider 和 consumer 子 Module 的启动类，把端口都改成不一样试试集群轮询、随机拜访的成果。

具体代码详见 GitHub 仓库：点我跳转

正文完

java

发表至： java

2020-10-13

0

关于java:从理论走向实践金五银六Java线程池指南已上线一次性教给你

关于java:大学学什么专业好就业

关于java:Java开发手册解读大整数传输为何禁用Long类型

关于java:18个示例详解-Spring-事务传播机制附测试源码

关于数据库:滴滴导航若干关键功能的技术突破与实践

关于java:第一个基于DubboZookeeper搭建的项目

我的项目简介

Step 1 创立我的项目并编写父我的项目 Maven 依赖

1.1 创立我的项目

1.2 编写父我的项目 Maven 依赖

Step 2 编写 dubbo_api

2.1 定义 POJO 类

2.2 定义 Service 接口

Step 3 编写 dubbo_provider

阐明

3.1 配置 pom.xml

3.2 定义 Mapper 接口和类

3.3 定义 Service 实现类

3.4 配置 application.yml

3.5 创立 SpringBoot 启动程序

Step 4 编写 dubbo_consumer

4.1 配置 pom.xml

4.2 创立 consumer 本地 Service 接口和实现类

4.3 创立 Controller 类

4.4 配置注册核心地址

4.5 创立 Springboot 启动类

4.6 启动测试

Step 5 我的项目整体测试

站内搜索