Dubbo

目录

什么是分布式系统

单机架构、集群架构、分布式架构

Dubbo的概念

Dubbo的核心组件

Dubbo的常用注解

Dubbo的高级特性：

        序列化特性安全

        地址缓存

        超时机制

        重试机制

        多版本灰度发布

        负载均衡 

        集群容错

        服务降级

        服务限流

        结果缓存

Dubbo实战：

        项目介绍

        搭建架构

        编写pojo实体类

        编写mapper持久层接口

        编写producer生产者代码

                 编写api模块代码

        编写consumer消费者代码

                引入相关依赖（dubbo、zookeeper、Dubbo_api）

                编写service层代码（这里的@Service就是Spring的注解）

                编写PageController（该控制层的作用就是跳转到对应页面）

                编写UserController

                编写index.html主页

                配置dubbo和zookeeper

                新增用户业务实现

                添加用户测试

                查询用户业务实现

                查询用户测试 

                修改用户业务实现

                修改用户测试 

                删除用户业务实现

---

部分图片来自百战尚学堂 

什么是分布式系统

分布式就是很多“人”一起干不一样的事，合起来就是一件大事，意思就是一个大的业务系统，拆分成一个个小的业务模块，分别部署到不同的机器上

优点：解耦，代码复用性更高，独立部署，独立测试

单机架构、集群架构、分布式架构

单机架构就是一个“人”干所有事，集群架构就是多个“人”干相同的事，分布式架构就是不同的“人”干不同的事，但是合起来就是在干一件大事

单机架构的缺点就是当这个“人”出了一些故障，那么整个系统都将崩溃，代码耦合度较高，复用性不高，测试起来复杂。优点就是体系小，开发快，集群架构也是类似的

分布式架构的优点就是代码耦合度低，没有单点故障问题，一个“人”出错了，并不会影响其他“人”，代码复用性高，测试方便。缺点就是会导致体系变得庞大

Dubbo的概念

Dubbo是一个RPC框架，作用就是让远程调用像本地调用一样简单、方便，通常使用Zookeeper Dubbo实现分布式系统

什么是RPC：RPC让你用别人家的东西就像自己家的一样。

RPC两个作用：

• 屏蔽远程调用跟本地调用的区别，让我们感觉就是调用项目内的方法
• 隐藏底层网络通信的复杂性，让我们更加专注业务逻辑。

常用的RPC框架

RPC是一种技术思想而非一种规范或协议。

常见 RPC 技术和框架：

• 阿里的 Dubbo/Dubbox、Google gRPC、Spring Cloud。

Dubbo的核心组件

注册中心Registry

在Dubbo微服务体系中，注册中心是其核心组件之一。Dubbo通过注册中心实现了分布式环境中各服务之间的注册与发现，是各个分布式节点之间的纽带。

其主要作用如下:

• 动态加入：一个服务提供者通过注册中心可以动态地把自己暴露给其他消费者，无须消费者逐个去更新配置文件。
• 动态发现：一个消费者可以动态地感知新的配置、路由规则和新的服务提供者，无须重启服务使之生效。
• 动态调整：注册中心支持参数的动态调整，新参数自动更新到所有相关服务节点。
• 统一配置：避免了本地配置导致每个服务的配置不一致问题。

 

服务提供者Provider

服务的提供方

服务消费者Consumer

调用远程服务的服务消费方

监控中心Monitor

主要负责监控统计调用次数和调用时间等。

Dubbo的常用注解

@Service、@Reference

@Service：将类注册到注册中心

@Reference：将类从注册中心拉取到本地

Dubbo的高级特性

        高级特性其实就是@Service、@Reference注解的一些属性        

        序列化特性安全

网络传输数据都是以二进制的形式进行传输的，但调用方请求的出入参数都是对象，此时就需要这些对象实现了Serializable方法，即可序列化，这样才能在网络中传输 

        打个比方：就像送快递一样，你的货物就相当于那个对象，货物需要打包相当于对象需要序列化为二进制，当对象到你手上的时候就是一串二进制，就像快递包到了你手上一样，此时就需要拆开快递包即可拿到自己的货物，就相当于反序列化一样将二进制变回对象

        地址缓存

注册中心挂了，服务是否可以正常访问？

答案：

因为dubbo服务消费者在第一次调用时，会将服务提供方地址缓存到本地，以后在调用则不会访问注册中心。服务提供者地址发生变化时，注册中心会通服务消费者。

        超时机制

问题：

• 服务消费者在调用服务提供者的时候发生了阻塞、等待的情形，这个时候，服务消费者会一直等待下去。
• 在某个峰值时刻，大呈的请求都在同时请求服务消费者，会造成线程的大呈堆积，势必会造成雪崩。
• dubbo利用超时机制来解决这个问题，设置一个超时时间，在这个时间段内，无法完成服务访问，则自动断开连接。

 

 

服务生产者端配置超时时间

使用timeout属性配置超时时间，默认值1000，单位毫秒。

@Service(timeout = 3000) //当前服务3秒超时

 

消费端配置超时时间

@Reference(timeout=2000)// 远程注入

private IOrderService iOrderService;

        重试机制

超时问题：

如果出现网络抖动，则会出现请求失败。

如何解决

Dubbo提供重试机制来避免类似问题的发生。

重试机制配置

@Service(timeout = 3000,retries = 2)

        多版本灰度发布

Dubbo提供多版本的配置，方便我们做服务的灰度发布，或者是解决不兼容的问题。

灰度发布(金丝雀发布)：

当出现新功能时，会让一部分用户先使用新功能，用户反馈没问题时，再将所有用户迁移到新功能。

版本迁移步骤

1. 在低压力时间段，先升级一半提供者为新版本
2. 再将所有消费者升级为新版本
3. 然后将剩下的一半提供者升级为新版本

多版本配置

老版本服务提供者配置

@Service(version = "1.0.0")        设置版本为1.0

新版本服务提供者配置

@Service(version = "2.0.0")        设置版本为2.0

新版本服务消费者配置

@Reference(version="2.0.0")        代表拉取的是2.0版本的该对象

private IOrderService iOrderService;// 订单服务

 

如果不需要区分版本，可以按照以下的方式配置 ：

@Reference(version="*")

private IOrderService iOrderService;// 订单服务

        负载均衡 

Dubbo是一个分布式服务框架，能避免单点故障和支持服务的横向扩容。一个服务通常会部署多个实例。

问题：

订单服务生产者会出现单点故障。

如何从多个服务 Provider 组成的集群中挑选出一个进行调用，就涉及到一个负载均衡的策略。

Dubbo内置负载均衡策略

1. RandomLoadBalance：随机负载均衡，随机的选择一个，默认负载均衡。
2. RoundRobinLoadBalance：轮询负载均衡。
3. LeastActiveLoadBalance：最少活跃调用数，相同活跃数的随机。
4. ConsistentHashLoadBalance：一致性哈希负载均衡，相同参数的请求总是落在同一台机器上。

负载均衡策略配置

如果不指定负载均衡，默认使用随机负载均衡。我们也可以根据自己的需要，显式指定一个负载均衡。

生产者服务

@Service(timeout=3000,retries=3,loadbalance="roundrobin")

消费者服务

@Reference(timeout=2000,loadbalance="roundrobin")

 

参数：

• random：随机负载均衡
• leastactive：最少活跃调用数，相同活跃数的随机
• roundrobin：轮询负载均衡
• consistenthash：一致性哈希负载均衡

        集群容错

Dubbo框架为服务集群容错提供了一系列好的解决方案，在此称为dubbo服务集群容错模式。

容错模式

• Failover Cluster：失败重试。默认值。当出现失败，重试其它服务器，默认重试2次，使用retries配置。一般用于读操作
• Failfast Cluster : 快速失败，只发起一次调用，失败立即报错。通常用于写操作。
• Failsafe Cluster : 失败安全，出现异常时，直接忽略。返回一个空结果。日志不重要操作。
• Failback Cluster : 失败自动恢复，后台记录失败请求，定时重发。非常重要的操作。
• Forking Cluster：并行调用多个服务器，只要有一个成功即返回。
• Broadcast Cluster：广播调用所有提供者，逐个调用，任意一台报错则报错。 同步要求高的可以使用这个模式。

集群容错配置

在消费者服务配置

@Reference(cluster = "failover")

private IOrderService iOrderService;

        服务降级

服务降级，当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行。

两种场景：

• 当下游的服务因为某种原因响应过慢，下游服务主动停掉一些不太重要的业务，释放出服务器资源，增加响应速度！
• 当下游的服务因为某种原因不可用，上游主动调用本地的一些降级逻辑，避免卡顿，迅速返回给用户！

为什么需要降级

当访问量剧增、服务出现问题（如响应时间慢或不响应）或非核心服务影响到核心流程的性能时，仍然需要保证服务还是可用的，即使是有损服务。

 

服务降级方式

第一种

mock=force:return null

含义：

表示消费方对该服务的方法调用都直接返回null值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。

 

第二种

mock=fail:return null

含义：

表示消费方对该服务的方法调用在失败后，再返回null值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

服务降级演示

@Reference(timeout = 2000,mock = "force:return null")

private IOrderService iOrderService;

        服务限流

并发控制

@Service(executes = 10)

注意：

服务端并发执行（或占用线程池线程数）不能超过10个

 

连接控制

@Service(actives= 10)

注意：

占用连接的请求的数不能超过10个。

        结果缓存

 

//通过注解中的cache属性配置结果缓存机制

@Reference(cache="lru")

Dubbo实战

        项目介绍

需求：完成用户的增删改查操作

技术栈：

        前端：html、thymeleaf

        分布式：Dubbo、Zookeeper、SpringMVC

        持久化：MySql、MyBatisPlus

项目架构：

        搭建架构

1、在Dubbo_father的pom文件中定义需要用的依赖的版本并配置jdk版本，在配置中有一个标签叫做dependencyManagement，这个标签的作用就是声明该依赖的版本，当子模块引入该依赖时，无需定义版本，可以直接使用父项目定义好的版本

1.  
   <?xml version="1.0" encoding="UTF-8"?>
2.  
   <project xmlns="http://maven.apache.org/POM/4.0.0"
3.  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.  
   <modelVersion>4.0.0</modelVersion>
6.  
    
7.  
   <groupId>com.itbaizhan</groupId>
8.  
   <artifactId>Dubbo_father</artifactId>
9.  
   <packaging>pom</packaging>
10.  
    <version>1.0-SNAPSHOT</version>
11.  
    <modules>
12.  
    <module>Dubbo_producer</module>
13.  
    <module>Dubbo_api</module>
14.  
    <module>dubbo_consumer</module>
15.  
    </modules>
16.  
     
17.  
    <properties>
18.  
    <dubbo.spring.starter.version>2.7.6</dubbo.spring.starter.version>
19.  
    <dubbo.registry.zookeeper.version>2.7.6</dubbo.registry.zookeeper.version>
20.  
    <mybatisplus.spring.starter.version>3.5.0</mybatisplus.spring.starter.version>
21.  
    <mysql.connector.version>5.1.49</mysql.connector.version>
22.  
    </properties>
23.  
     
24.  
    <!-- 通过management提前声明这些依赖所使用的版本，等子项目使用的时候即可不需要定义版本，直接使用父项目声明的版本 -->
25.  
    <dependencyManagement>
26.  
    <dependencies>
27.  
    <!-- Dubbo 依赖 -->
28.  
    <dependency>
29.  
    <groupId>org.apache.dubbo</groupId>
30.  
    <artifactId>dubbo-spring-boot-starter</artifactId>
31.  
    <version>${dubbo.spring.starter.version}</version>
32.  
    </dependency>
33.  
    <!-- zookeeper 注册中心 依赖 -->
34.  
    <dependency>
35.  
    <groupId>org.apache.dubbo</groupId>
36.  
    <artifactId>dubbo-registry-zookeeper</artifactId>
37.  
    <version>${dubbo.registry.zookeeper.version}</version>
38.  
    </dependency>
39.  
    <!-- Mybatis plus 依赖 -->
40.  
    <dependency>
41.  
    <groupId>com.baomidou</groupId>
42.  
    <artifactId>mybatis-plus-boot-starter</artifactId>
43.  
    <version>${mybatisplus.spring.starter.version}</version>
44.  
    </dependency>
45.  
    <!--MySQL 数据库依赖 -->
46.  
    <dependency>
47.  
    <groupId>mysql</groupId>
48.  
    <artifactId>mysql-connector-java</artifactId>
49.  
    <version>${mysql.connector.version}</version>
50.  
    </dependency>
51.  
    </dependencies>
52.  
    </dependencyManagement>
53.  
     
54.  
    <!-- 设置jdk版本 -->
55.  
    <build>
56.  
    <plugins>
57.  
    <plugin>
58.  
    <groupId>org.apache.maven.plugins</groupId>
59.  
    <artifactId>maven-compiler-plugin</artifactId>
60.  
    <version>3.1</version>
61.  
    <configuration>
62.  
    <source>11</source>
63.  
    <target>11</target>
64.  
    </configuration>
65.  
    </plugin>
66.  
    </plugins>
67.  
    </build>
68.  
     
69.  
     
70.  
     
71.  
    </project>

因为Dubbo_consumer模块是SpringBoot项目，所以他的父项目是SpringBoot的起步依赖spring-boot-stater-parent，所以我们需要添加第二个父项目，通过dependencyManagement标签即可实现

1.  
   <?xml version="1.0" encoding="UTF-8"?>
2.  
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
4.  
   <modelVersion>4.0.0</modelVersion>
5.  
   <parent>
6.  
   <groupId>org.springframework.boot</groupId>
7.  
   <artifactId>spring-boot-starter-parent</artifactId>
8.  
   <version>2.7.11</version>
9.  
   <relativePath/> <!-- lookup parent from repository -->
10.  
    </parent>
11.  
    <!-- 引入第二个父亲 -->
12.  
    <dependencyManagement>
13.  
    <dependencies>
14.  
    <dependency>
15.  
    <groupId>com.itbaizhan</groupId>
16.  
    <artifactId>Dubbo_father</artifactId>
17.  
    <type>pom</type>
18.  
    <version>1.0-SNAPSHOT</version>
19.  
    <scope>import</scope>
20.  
    </dependency>
21.  
    </dependencies>
22.  
    </dependencyManagement>
23.  
    <groupId>com.itbaizhan</groupId>
24.  
    <artifactId>dubbo_consumer</artifactId>
25.  
    <version>0.0.1-SNAPSHOT</version>
26.  
    <name>dubbo_consumer</name>
27.  
    <description>Demo project for Spring Boot</description>
28.  
    <properties>
29.  
    <java.version>11</java.version>
30.  
    </properties>
31.  
    <dependencies>
32.  
    <dependency>
33.  
    <groupId>org.springframework.boot</groupId>
34.  
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
35.  
    </dependency>
36.  
    <dependency>
37.  
    <groupId>org.springframework.boot</groupId>
38.  
    <artifactId>spring-boot-starter-web</artifactId>
39.  
    </dependency>
40.  
     
41.  
    <dependency>
42.  
    <groupId>org.projectlombok</groupId>
43.  
    <artifactId>lombok</artifactId>
44.  
    <optional>true</optional>
45.  
    </dependency>
46.  
    <dependency>
47.  
    <groupId>org.springframework.boot</groupId>
48.  
    <artifactId>spring-boot-starter-test</artifactId>
49.  
    <scope>test</scope>
50.  
    </dependency>
51.  
    </dependencies>
52.  
     
53.  
    <build>
54.  
    <plugins>
55.  
    <plugin>
56.  
    <groupId>org.springframework.boot</groupId>
57.  
    <artifactId>spring-boot-maven-plugin</artifactId>
58.  
    <configuration>
59.  
    <excludes>
60.  
    <exclude>
61.  
    <groupId>org.projectlombok</groupId>
62.  
    <artifactId>lombok</artifactId>
63.  
    </exclude>
64.  
    </excludes>
65.  
    </configuration>
66.  
    </plugin>
67.  
    </plugins>
68.  
    </build>
69.  
     
70.  
    </project>

        编写pojo实体类

创建数据库和表

1.  
   创建数据库
2.  
   create database test;
3.  
   创建用户表
4.  
   CREATE TABLE user
5.  
   (
6.  
   id BIGINT(20) NOT NULL COMMENT '主键ID',
7.  
   name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
8.  
   age INT(11) NULL DEFAULT NULL COMMENT '年龄',
9.  
   PRIMARY KEY(id)
10.  
    );

创建User实体类（User实体类需要实现Serializable接口，前面有提到过）

1.  
   package com.itbaizhan.pojo;
2.  
    
3.  
   import lombok.AllArgsConstructor;
4.  
   import lombok.Data;
5.  
   import lombok.NoArgsConstructor;
6.  
    
7.  
   import java.io.Serializable;
8.  
    
9.  
   /**
10.  
    * 用户实体类
11.  
    */
12.  
    @Data
13.  
    @AllArgsConstructor
14.  
    @NoArgsConstructor
15.  
    public class User implements Serializable {
16.  
    public Long id;//用户id
17.  
    public String name;//用户名字
18.  
    public int age;//用户年龄
19.  
    }

mapper模块引入pojo模块

        编写mapper持久层接口

引入MybatisPlus和mysql依赖

1.  
   <?xml version="1.0" encoding="UTF-8"?>
2.  
   <project xmlns="http://maven.apache.org/POM/4.0.0"
3.  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.  
   <parent>
6.  
   <artifactId>Dubbo_producer</artifactId>
7.  
   <groupId>com.itbaizhan</groupId>
8.  
   <version>1.0-SNAPSHOT</version>
9.  
   </parent>
10.  
    <modelVersion>4.0.0</modelVersion>
11.  
     
12.  
    <artifactId>mapper</artifactId>
13.  
     
14.  
    <dependencies>
15.  
    <!-- 引入pojo -->
16.  
    <dependency>
17.  
    <groupId>com.itbaizhan</groupId>
18.  
    <artifactId>pojo</artifactId>
19.  
    <version>1.0-SNAPSHOT</version>
20.  
    </dependency>
21.  
    <!-- MyBatisPlus依赖 -->
22.  
    <dependency>
23.  
    <groupId>com.baomidou</groupId>
24.  
    <artifactId>mybatis-plus-boot-starter</artifactId>
25.  
    </dependency>
26.  
    <!-- MySql依赖 -->
27.  
    <dependency>
28.  
    <groupId>mysql</groupId>
29.  
    <artifactId>mysql-connector-java</artifactId>
30.  
    </dependency>
31.  
    </dependencies>
32.  
    </project>

 编写UserMapper

1.  
   package com.itbaizhan.mapper;
2.  
    
3.  
   import com.baomidou.mybatisplus.core.mapper.BaseMapper;
4.  
   import com.itbaizhan.pojo.User;
5.  
    
6.  
   public interface UserMapper extends BaseMapper<User> {
7.  
   }

        编写producer生产者代码

将producer修改为SpringBoot项目，因为SpringBoot项目的父类是spring-boot-stater-parent，而本身项目的父类是dubbo_producer，所以需要通过dependencyManagement引入第二个父项目

1.  
   <?xml version="1.0" encoding="UTF-8"?>
2.  
   <project xmlns="http://maven.apache.org/POM/4.0.0"
3.  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.  
   <parent>
6.  
   <groupId>org.springframework.boot</groupId>
7.  
   <artifactId>spring-boot-starter-parent</artifactId>
8.  
   <version>2.7.11</version>
9.  
   <relativePath/> <!-- lookup parent from repository -->
10.  
    </parent>
11.  
     
12.  
    <dependencyManagement>
13.  
    <dependencies>
14.  
    <!-- 引入第二个父项目 -->
15.  
    <dependency>
16.  
    <artifactId>Dubbo_producer</artifactId>
17.  
    <groupId>com.itbaizhan</groupId>
18.  
    <version>1.0-SNAPSHOT</version>
19.  
    </dependency>
20.  
    </dependencies>
21.  
    </dependencyManagement>
22.  
    <modelVersion>4.0.0</modelVersion>
23.  
     
24.  
    <artifactId>producer</artifactId>
25.  
     
26.  
     
27.  
    </project>

引入mapper模块，通过依赖传递的方式引入pojo模块

1.  
   <dependencies>
2.  
   <dependency>
3.  
   <groupId>com.itbaizhan</groupId>
4.  
   <artifactId>mapper</artifactId>
5.  
   <version>1.0-SNAPSHOT</version>
6.  
   </dependency>
7.  
   </dependencies>

 

 编写启动类并扫描持久层接口创建相应的实现类放到spring容器中

 

1.  
   package com.itbaizhan.producer;
2.  
    
3.  
   import org.springframework.boot.SpringApplication;
4.  
   import org.springframework.boot.autoconfigure.SpringBootApplication;
5.  
    
6.  
   @SpringBootApplication
7.  
   @MapperScan("com.itbaizhan.mapper")
8.  
   public class ProducerApplication {
9.  
   public static void main(String[] args) {
10.  
    SpringApplication.run(ProducerApplication.class,args);
11.  
    }
12.  
    }

 配置数据源

1.  
   spring:
2.  
   datasource:
3.  
   driver-class-name: com.mysql.jdbc.Driver
4.  
   url: jdbc:mysql://192.168.138.101/test
5.  
   username: root
6.  
   password: 123456

        编写api模块代码

添加pojo模块依赖

1.  
   <?xml version="1.0" encoding="UTF-8"?>
2.  
   <project xmlns="http://maven.apache.org/POM/4.0.0"
3.  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.  
   <parent>
6.  
   <artifactId>Dubbo_father</artifactId>
7.  
   <groupId>com.itbaizhan</groupId>
8.  
   <version>1.0-SNAPSHOT</version>
9.  
   </parent>
10.  
    <modelVersion>4.0.0</modelVersion>
11.  
     
12.  
    <artifactId>Dubbo_api</artifactId>
13.  
    <dependencies>
14.  
    <dependency>
15.  
    <groupId>com.itbaizhan</groupId>
16.  
    <artifactId>pojo</artifactId>
17.  
    <version>1.0-SNAPSHOT</version>
18.  
    </dependency>
19.  
    </dependencies>
20.  
     
21.  
     
22.  
    </project>

编写api模块service层接口（该接口的作用是定义producer模块的service规范）

1.  
   package com.itbaizhan.service;
2.  
    
3.  
   import com.itbaizhan.pojo.User;
4.  
    
5.  
   import java.util.List;
6.  
    
7.  
   public interface UserService {
8.  
   //新增用户
9.  
   public void add(User user);
10.  
     
11.  
    //根据id删除用户
12.  
    public void delete(Long userId);
13.  
     
14.  
    //根据id修改用户
15.  
    public void update(User user);
16.  
     
17.  
    //查询所有用户
18.  
    public List<User> selectAll();
19.  
    //根据id查询用户
20.  
    public User selectById();
21.  
     
22.  
    }

producer模块引入相关依赖

1.  
   <?xml version="1.0" encoding="UTF-8"?>
2.  
   <project xmlns="http://maven.apache.org/POM/4.0.0"
3.  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.  
   <parent>
6.  
   <groupId>org.springframework.boot</groupId>
7.  
   <artifactId>spring-boot-starter-parent</artifactId>
8.  
   <version>2.7.11</version>
9.  
   <relativePath/> <!-- lookup parent from repository -->
10.  
    </parent>
11.  
     
12.  
    <dependencyManagement>
13.  
    <dependencies>
14.  
    <!-- 引入第二个父项目 -->
15.  
    <dependency>
16.  
    <groupId>com.itbaizhan</groupId>
17.  
    <artifactId>Dubbo_father</artifactId>
18.  
    <type>pom</type>
19.  
    <version>1.0-SNAPSHOT</version>
20.  
    <scope>import</scope>
21.  
    </dependency>
22.  
    </dependencies>
23.  
    </dependencyManagement>
24.  
     
25.  
    <modelVersion>4.0.0</modelVersion>
26.  
     
27.  
    <artifactId>producer</artifactId>
28.  
     
29.  
    <dependencies>
30.  
    <dependency>
31.  
    <groupId>com.itbaizhan</groupId>
32.  
    <artifactId>mapper</artifactId>
33.  
    <version>1.0-SNAPSHOT</version>
34.  
    </dependency>
35.  
    <!-- 引入dubbo -->
36.  
    <dependency>
37.  
    <groupId>org.apache.dubbo</groupId>
38.  
    <artifactId>dubbo-spring-boot-starter</artifactId>
39.  
    </dependency>
40.  
    <!-- 引入zookeeper -->
41.  
    <dependency>
42.  
    <groupId>org.apache.dubbo</groupId>
43.  
    <artifactId>dubbo-registry-zookeeper</artifactId>
44.  
    </dependency>
45.  
    <!-- 引入dubbo_api模块 -->
46.  
    <dependency>
47.  
    <groupId>com.itbaizhan</groupId>
48.  
    <artifactId>Dubbo_api</artifactId>
49.  
    <version>1.0-SNAPSHOT</version>
50.  
    </dependency>
51.  
    </dependencies>
52.  
    </project>

编写producer模块service层代码(类的上方需要添加Dubbo的@Service注解，将该类注册到注册中心)

1.  
   package com.itbaizhan.producer.service;
2.  
    
3.  
   import com.itbaizhan.mapper.UserMapper;
4.  
   import com.itbaizhan.pojo.User;
5.  
   import org.apache.dubbo.config.annotation.Service;
6.  
   import org.springframework.beans.factory.annotation.Autowired;
7.  
    
8.  
   import java.util.List;
9.  
    
10.  
    @Service
11.  
    public class UserService implements com.itbaizhan.service.UserService {
12.  
     
13.  
    @Autowired
14.  
    private UserMapper userMapper;
15.  
     
16.  
    /**
17.  
    * 添加用户
18.  
    * @param user
19.  
    */
20.  
    @Override
21.  
    public void add(User user) {
22.  
    userMapper.insert(user);
23.  
    }
24.  
     
25.  
    /**
26.  
    * 根据id删除用户
27.  
    * @param userId
28.  
    */
29.  
    @Override
30.  
    public void delete(Long userId) {
31.  
    userMapper.deleteById(userId);
32.  
    }
33.  
     
34.  
    /**
35.  
    * 根据id修改用户
36.  
    * @param user
37.  
    */
38.  
    @Override
39.  
    public void update(User user) {
40.  
    userMapper.updateById(user);
41.  
    }
42.  
     
43.  
    /**
44.  
    * 查询所有用户
45.  
    * @return
46.  
    */
47.  
    @Override
48.  
    public List<User> selectAll() {
49.  
    return userMapper.selectList(null);
50.  
    }
51.  
     
52.  
    /**
53.  
    * 根据id查询用户
54.  
    * @param userId
55.  
    * @return
56.  
    */
57.  
    @Override
58.  
    public User selectById(Long userId) {
59.  
    return userMapper.selectById(userId);
60.  
    }
61.  
    }

 配置dubbo和zookeeper

1.  
   dubbo:
2.  
   #项目名字
3.  
   application:
4.  
   name: myProducer
5.  
   #注册中心地址
6.  
   registry:
7.  
   address: zookeeper://192.168.138.101:2181
8.  
   timeout: 50000
9.  
   #端口号和协议名
10.  
    protocol:
11.  
    port: 20880
12.  
    name: dubbo
13.  
    #扫描的包
14.  
    scan:
15.  
    base-packages: com.itbaizhan.producer.service

运行producer模块启动类，通过dubbo-admin查看是否注册到了注册中心

        编写consumer消费者代码

                引入相关依赖（dubbo、zookeeper、Dubbo_api）

1.  
   <!-- 引入dubbo -->
2.  
   <dependency>
3.  
   <groupId>org.apache.dubbo</groupId>
4.  
   <artifactId>dubbo-spring-boot-starter</artifactId>
5.  
   </dependency>
6.  
   <!-- 引入zookeeper -->
7.  
   <dependency>
8.  
   <groupId>org.apache.dubbo</groupId>
9.  
   <artifactId>dubbo-registry-zookeeper</artifactId>
10.  
    </dependency>
11.  
    <!-- 引入dubbo_api模块 -->
12.  
    <dependency>
13.  
    <groupId>com.itbaizhan</groupId>
14.  
    <artifactId>Dubbo_api</artifactId>
15.  
    <version>1.0-SNAPSHOT</version>
16.  
    </dependency>

                编写service层代码（这里的@Service就是Spring的注解）

通过@Reference拉取Dubbo_api模块的UserService，那么此时会有小伙伴问了：我们注册的是producer模块的UserService，为什么拉取的确实Dubbo_api模块的UserService呢？

这是因为采用了jdk动态代理的模式，就是拉取这个接口的实现类，以接口引用的方式实现调用

1.  
   package com.itbaizhan.dubbo_consumer.service;
2.  
    
3.  
   import com.itbaizhan.pojo.User;
4.  
   import org.apache.dubbo.config.annotation.Reference;
5.  
   import org.springframework.stereotype.Service;
6.  
    
7.  
   import java.util.List;
8.  
    
9.  
   @Service
10.  
    public class UserService {
11.  
    @Reference
12.  
    private com.itbaizhan.service.UserService userService;
13.  
     
14.  
    //新增用户
15.  
    public void add(User user){
16.  
    userService.add(user);
17.  
    }
18.  
     
19.  
    //根据id删除用户
20.  
    public void delete(Long userId){
21.  
    userService.delete(userId);
22.  
    }
23.  
     
24.  
    //根据id修改用户
25.  
    public void update(User user){
26.  
    userService.update(user);
27.  
    }
28.  
     
29.  
    //查询所有用户
30.  
    public List<User> selectAll(){
31.  
    return userService.selectAll();
32.  
    }
33.  
     
34.  
    //根据id查询用户
35.  
    public User selectById(Long userId){
36.  
    return userService.selectById(userId);
37.  
    }
38.  
    }

                 编写PageController（该控制层的作用就是跳转到对应页面）

1.  
   package com.itbaizhan.dubbo_consumer.controller;
2.  
    
3.  
   import org.springframework.stereotype.Controller;
4.  
   import org.springframework.web.bind.annotation.PathVariable;
5.  
   import org.springframework.web.bind.annotation.RequestMapping;
6.  
    
7.  
   @Controller
8.  
   public class PageController {
9.  
    
10.  
    @RequestMapping("/{page}")
11.  
    public String page(@PathVariable String page){
12.  
    return page;
13.  
    }
14.  
    }

                编写UserController

1.  
   package com.itbaizhan.dubbo_consumer.controller;
2.  
    
3.  
   import com.itbaizhan.dubbo_consumer.service.UserService;
4.  
   import com.itbaizhan.pojo.User;
5.  
   import org.springframework.beans.factory.annotation.Autowired;
6.  
   import org.springframework.stereotype.Controller;
7.  
   import org.springframework.ui.Model;
8.  
   import org.springframework.web.bind.annotation.GetMapping;
9.  
   import org.springframework.web.bind.annotation.PostMapping;
10.  
    import org.springframework.web.bind.annotation.RequestMapping;
11.  
     
12.  
    import java.util.List;
13.  
     
14.  
    @Controller
15.  
    @RequestMapping("/user")
16.  
    public class UserController {
17.  
    @Autowired
18.  
    private UserService userService;
19.  
     
20.  
    //新增用户
21.  
    @PostMapping("/add")
22.  
    public String add(User user){
23.  
    userService.add(user);
24.  
    return "redirect:/ok";
25.  
    }
26.  
     
27.  
    //根据id删除用户
28.  
    @GetMapping("/delete")
29.  
    public String delete(Long userId){
30.  
    userService.delete(userId);
31.  
    return "redirect:/ok";
32.  
    }
33.  
     
34.  
    //根据id修改用户
35.  
    @GetMapping("/preUpdate")
36.  
    public String preUpdate(Long userId, Model model){
37.  
    User user = userService.selectById(userId);
38.  
    model.addAttribute("user",user);
39.  
    return "update";
40.  
    }
41.  
     
42.  
    //根据id查询用户
43.  
    @PostMapping("/update")
44.  
    public String update(User user){
45.  
    userService.update(user);
46.  
    return "redirect:/ok";
47.  
    }
48.  
     
49.  
    //查询所有用户
50.  
    @GetMapping("/selectAll")
51.  
    public String selectAll(Model model){
52.  
    List<User> userList = userService.selectAll();
53.  
    model.addAttribute("userList",userList);
54.  
    return "showuser";
55.  
    }
56.  
     
57.  
    }
58.  
     

                编写index.html主页

1.  
   <!DOCTYPE html>
2.  
   <html lang="en">
3.  
   <head>
4.  
   <meta charset="UTF-8">
5.  
   <title>主页</title>
6.  
   </head>
7.  
   <body>
8.  
   <a href="/adduser">添加用户</a>
9.  
   <a href="/user/selectAll">查询用户</a>
10.  
    </body>
11.  
    </html>

                配置dubbo和zookeeper

1.  
   dubbo:
2.  
   #项目名字
3.  
   application:
4.  
   name: myConsumer
5.  
   #注册中心地址
6.  
   registry:
7.  
   address: zookeeper://192.168.138.101:2181
8.  
   timeout: 50000
9.  
   #端口号和协议名
10.  
    protocol:
11.  
    port: 20881
12.  
    name: dubbo
13.  
    #扫描的包
14.  
    scan:
15.  
    base-packages: com.itbaizhan.dubbo_consumer.service

运行producer模块和consumer模块，访问localhost:8080/index

此时发现整个项目可以正常运行，那么我们就可以继续编写页面了

                新增用户业务实现

编写adduser.html

1.  
   <!DOCTYPE html>
2.  
   <html lang="en">
3.  
   <head>
4.  
   <meta charset="UTF-8">
5.  
   <title>添加用户</title>
6.  
   </head>
7.  
   <body>
8.  
   <form action="/user/add" method="post">
9.  
   用户名:<input type="text" name="name">&nbsp;&nbsp;&nbsp;
10.  
    年龄:<input type="text" name="age"><br/>
11.  
    <input type="submit" value="提交">
12.  
    </form>
13.  
     
14.  
    </body>
15.  
    </html>

编写ok.html

1.  
   <!DOCTYPE html>
2.  
   <html lang="en">
3.  
   <head>
4.  
   <meta charset="UTF-8">
5.  
   <title>操作成功</title>
6.  
   </head>
7.  
   <body>
8.  
   操作成功,点击<a href="/index.html">返回首页</a>
9.  
   </body>
10.  
    </html>

                添加用户测试：

点击添加用户 

点击提交

 查看是否添加用户成功

测试成功之后编写查询所有用户（需要用到thymeleaf）

                查询用户业务实现

编写showuser.html对用户有两个操作，修改和删除

1.  
   <!DOCTYPE html>
2.  
   <html lang="en" xmlns:th="http://www.thymeleaf.org">
3.  
   <head>
4.  
   <meta charset="UTF-8">
5.  
   <title>用户列表</title>
6.  
   </head>
7.  
   <body>
8.  
   <table border="1px solid black" align="center">
9.  
   <tr>
10.  
    <th>id</th>
11.  
    <th>用户姓名</th>
12.  
    <th>用户年龄</th>
13.  
    <th>操作</th>
14.  
    </tr>
15.  
    <tr th:each="user:${userList}">
16.  
    <td th:text="${user.id}"></td>
17.  
    <td th:text="${user.name}"></td>
18.  
    <td th:text="${user.age}"></td>
19.  
    <td>
20.  
    <a th:href="@{/user/preUpdate(userId=${user.id})}">修改</a>&nbsp;
21.  
    <a th:href="@{/user/delete(userId=${user.id})}">删除</a>
22.  
    </td>
23.  
    </tr>
24.  
    </table>
25.  
    </body>
26.  
    </html>

                查询用户测试 

点击查询用户 

 

                修改用户业务实现

编写update.html

1.  
   <!DOCTYPE html>
2.  
   <html lang="en" xmlns:th="http://www.thymeleaf.org">
3.  
   <head>
4.  
   <meta charset="UTF-8">
5.  
   <title>修改用户</title>
6.  
   </head>
7.  
   <body>
8.  
   <form action="/user/update" method="post">
9.  
   <!-- userId的隐藏域 -->
10.  
    <input type="hidden" name="id" th:value="${user.id}">
11.  
    用户名:<input type="text" name="name" th:value="${user.name}">&nbsp;&nbsp;&nbsp;
12.  
    年龄:<input type="text" name="age" th:value="${user.age}"><br/>
13.  
    <input type="submit" value="修改">
14.  
    </form>
15.  
    </body>
16.  
    </html>

                修改用户测试 

点击修改用户 

 

修改用户数据，点击修改按钮过后跳转到操作成功页面，回到首页再次查询用户会发现，用户数据已经更改

                删除用户业务实现

删除用户的业务在实现查询用户业务的时候已经写好了，只要点击删除即可删除用户

这篇好文章是转载于：学新通技术网