基于Zookeeper + Dubbo 搭建的项目

基于Zookeeper + Dubbo 搭建的项目

项目简介

此项目为自己学习Dubbo+Zookeeper,搭建的第一个项目,主要架构就是一个父项目、三个子Module:dubbo_provider、 dubbo_consumer 和 dubbo_api,三个子Module分别继承父项目。

Dubbo的远程访问是基于接口的。Consumer和Provider使用同一个接口,可以实现远程访问。

  • Provider给接口写实现,提供服务。
  • Consumer使用接口,并通过Dubbo创建的动态代理对象,远程访问Provider。
  • 把接口独立定义在一个工程(dubbo_api)中,做依赖管理。

p.s. 此项目重点是练习Dubbo+Zookeeper,故没有写连接数据库的内容,只是模拟了访问数据库。

Step 1 创建项目并编写父项目Maven依赖

1.1 创建项目

用IDEA创建项目,创建完项目目录如下:
img

1.2 编写父项目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.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>

Step 2 编写dubbo_api

2.1 定义POJO类

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

2.2 定义Service接口

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

Step 3 编写dubbo_provider

说明

  • Dubbo服务提供者Provider,是不需要定义Controller的,是直接通过Service提供服务的。
  • 使用Dubbo框架提供的注解@DubboService,声明当前的类型的对象,是一个Dubbo服务提供者。
  • 让Spring容器初始化、管理,并通过curator框架,把服务信息注册到Zookeeper中。
  • 在老版本的Dubbo(2.6(含)以前)中,注解命名是@Service。所以使用老版本开发的时候,注意导入的注解的包。
  • 需要提供一个application.yml配置文件,说明Dubbo使用的注册中心是什么,地址是什么。

3.1 配置pom.xml

在pom.xml文件中添加依赖:

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

3.2 定义Mapper接口和类

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;
    }
}

3.3 定义Service实现类

@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);
    }
}

3.4 配置application.yml

说明:

  • 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可以详见我另一篇文章

3.5 创建SpringBoot启动程序

  • 启动的每个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客户端工具查看:
img

Step 4 编写dubbo_consumer

4.1 配置pom.xml

在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>

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

有人可能会疑惑,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);
    }
}

4.3 创建Controller类

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 "注册用户成功";
    }
}

4.4 配置注册中心地址

在 resources 文件夹下创建 application.yml:

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

4.5 创建Springboot启动类

在 com.gcp 包下创建 DbConsumerApplication:

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

4.6 启动测试

启动consumer的启动类,查看Zookeeper注册中心是否注册成功:
img

Step 5 项目整体测试

打开浏览器,输入consumer访问地址,测试是否可以正常访问:
img

后台输出:
consumer 子 Module:
img

provider 子 Module:
img

至此,项目搭建创建成功,大家可以自己多复制几个provider和consumer子Module的启动类,把端口都改成不一样试试集群轮询、随机访问的效果。

  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
好的,这里提供一个基于 Spring Cloud+Spring Boot+Nacos+Dubbo+mybatis plus+RocketMQ+Sentinel+Seata+mysql 的项目手脚架搭建步骤: 1. 首先需要搭建一个 Spring Cloud 项目,可以使用 Spring Initializr 快速创建。选择 Spring Boot 版本和其他依赖项,如 Eureka、Zuul、Config 等。 2. 集成 Nacos 作为注册中心和配置中心。在 pom.xml 中添加相关依赖项,并在 application.yml 中配置 Nacos 服务地址和相关配置。 3. 集成 Dubbo 作为 RPC 框架。在 pom.xml 中添加 DubboZookeeper 相关依赖项,并在 application.yml 中配置 Dubbo 的相关信息。 4. 集成 mybatis plus 作为 ORM 框架。在 pom.xml 中添加 mybatis plus 相关依赖项,并在 application.yml 中配置 mybatis plus 的相关信息。 5. 集成 RocketMQ 作为消息队列。在 pom.xml 中添加 RocketMQ 相关依赖项,并在 application.yml 中配置 RocketMQ 的相关信息。 6. 集成 Sentinel 作为流量控制和熔断降级框架。在 pom.xml 中添加 Sentinel 相关依赖项,并在 application.yml 中配置 Sentinel 的相关信息。 7. 集成 Seata 作为分布式事务框架。在 pom.xml 中添加 Seata 相关依赖项,并在 application.yml 中配置 Seata 的相关信息。 8. 集成 mysql 作为数据库。在 pom.xml 中添加 mysql 相关依赖项,并在 application.yml 中配置 mysql 的相关信息。 9. 编写业务代码,并在 Dubbo 接口上添加 @DubboService 注解,实现业务逻辑。在需要分布式事务的方法上添加 @GlobalTransactional 注解,实现分布式事务。 10. 在需要流量控制的方法上添加 @SentinelResource 注解,实现流量控制和熔断降级。 11. 在需要使用 RocketMQ 的地方,调用 RocketMQTemplate 发送消息,并编写监听器接收消息。 12. 在需要使用 Seata 的地方,调用 Seata 提供的 API 实现分布式事务。 以上是一个简单的搭建步骤,具体的细节还需要根据项目实际情况进行调整和优化。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值