微服务-02-Dubbo

1. Dubbo简介

Dubbo是一款高性能、轻量级的开源Java RPC框架，可以和Spring框架无缝集成，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

Dubbo的主要核心部件：

1. Remoting：网络通信框架，实现了sync-over-async和request-response消息机制
2. RPC：一个远程过程调用的抽象，支持负载均衡、容灾和集群功能
3. Registry：服务目录框架用于服务的注册和服务事件发布和订阅

Dubbo官网：https://dubbo.apache.org/zh/

RPC(Remote Procedure Call，远程过程调用)在分布式系统中的系统环境建设和应用程序设计中的应用：

1. 分布式操作系统的进程间通讯
2. 构造分布式计算的软件环境
3. 远程数据库服务
4. 分布式应用程序设计
5. 分布式程序的调试

RPC调用：Dubbo可以充当客户端存根和服务端存根

Dubbo依赖关系*：图中只包含RPC的层，不包含Remoting的层，Remoting整体都隐含在Protocol中；蓝色的表示与业务有交互，绿色的表示只对Dubbo内部交互

1. Container：服务运行容器；负责启动、加载、运行服务提供者
2. Provider：暴露服务的服务提供方；在启动时向注册中心注册自己提供的服务
3. Consumer：调用远程服务的服务消费方；在启动时向注册中心订阅自己所需的服务
4. Registry：服务注册与发现的注册中心；返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者
5. 服务消费者从提供者地址列表中，基于软负载均衡算法选一台提供者进行调用，如果调用失败，再选另一台调用
6. Monitor：统计服务的调用次数和调用时间的监控中心；服务消费者和提供者在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心

• 可以使用ZooKeeper来充当注册中心

2. Dubbo基本使用*

示例：页面发送请求：user/findById.do?id=1根据id从数据库获取用户对象；使用Dubbo，完成服务消费者调用服务提供者的方法

2.1 创建父工程

不实现任何代码，完成依赖管理：

artifactId：dubbo_parent

    1.8
    1.8
    5.0.5.RELEASE
    2.6.2
    3.4.7
    4.0.1
    3.4.5
    5.1.47
    1.3.2
    1.1.9
    1.2.17
    1.7.25


    
        
        
            org.springframework
            spring-webmvc
            ${spring.webmvc.version}
        
        
        
            com.alibaba
            dubbo
            ${dubbo.version}
        
        
        
            org.apache.zookeeper
            zookeeper
            ${zookeeper.version}
        
        
            org.apache.curator
            curator-framework
            ${curator.verion}
        
        
            org.apache.curator
            curator-recipes
            ${curator.verion}
        
        
        
            org.mybatis
            mybatis
            ${mybatis.version}
        
        
            org.mybatis
            mybatis-spring
            ${mybatis-spring.version}
        
        
            com.alibaba
            druid
            ${druid.version}
        
        
            mysql
            mysql-connector-java
            ${mysql.version}
        
        
        
            org.springframework
            spring-tx
            ${spring.webmvc.version}
        
        
            org.springframework
            spring-jdbc
            ${spring.webmvc.version}
        
        
        
            log4j
            log4j
            ${log.version}
        
        
            org.slf4j
            slf4j-api
            ${slf4j.version}
        
        
            org.projectlombok
            lombok
            1.18.18
        
    

2.2 创建公共子模块

创建实体类：

artifactId：dubbo_common

    dubbo_parent
    com.52lhp
    1.0-SNAPSHOT

4.0.0

dubbo_common
jar


    
        org.projectlombok
        lombok
    

创建POJO：

package com.liu2m.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
    private Integer id;
    private String name;
    private String password;
    private Double balance;
}

2.3 创建接口子模块

接口子模块主要放业务接口的定义，它是服务消费者模块和服务提供者模块的公共依赖模块：

artifactId：dubbo_interface

    dubbo_parent
    com.52lhp
    1.0-SNAPSHOT

4.0.0

dubbo_interface
jar


    
        com.52lhp
        dubbo_common
        1.0-SNAPSHOT
    

定义业务接口：

package com.liu2m.service;

import com.liu2m.pojo.User;

public interface UserService {
    User findById(int id);
}

2. 4 创建服务提供者子模块

服务提供者模块需要在容器启动时，把服务注册到zookeeper；对接口的实现，调用dao完成数据库的操作：

artifactId：dubbo_provider

    dubbo_parent
    com.52lhp
    1.0-SNAPSHOT

4.0.0

dubbo_provider
war


    
        com.52lhp
        dubbo_interface
        1.0-SNAPSHOT
    
    
        org.springframework
        spring-webmvc
    
    
        com.alibaba
        dubbo
    
    
        org.apache.zookeeper
        zookeeper
    
    
        org.apache.curator
        curator-framework
    
    
        org.apache.curator
        curator-recipes
    
    
        org.mybatis
        mybatis
    
    
        org.mybatis
        mybatis-spring
    
    
        com.alibaba
        druid
    
    
        mysql
        mysql-connector-java
    
    
        org.springframework
        spring-tx
    
    
        org.springframework
        spring-jdbc
    

创建UserDao接口：

package com.liu2m.dao;

import com.liu2m.pojo.User;

public interface UserDao {
    User findById(Integer id);
}

创建UserDao接口的映射文件：

    
        SELECT * FROM user WHERE id = #{id}
    

创建UserServiceImpl实现类：

package com.liu2m.service;

import com.liu2m.dao.UserDao;
import com.liu2m.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;

public class UserServiceImpl implements UserService {
    @Autowired
    UserDao userDao;

    @Override
    public User findById(int id) {
        return userDao.findById(id);
    }
}

创建Spring整合MyBatis的配置文件spring-dao.xml

创建Spring事务配置文件：spring-tx.xml

创建spring-provider.xml配置文件：

启动Zookeeper

启动项目：只要能启动spring的容器(加载spring的配置文件)就可以启动项目，因此有3种方式：

1. 方式1：用程序加载spring-provider.xml

   package com.liu2m;
   
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   import java.io.IOException;
   
   public class ProviderApplication {
       public static void main(String[] args) throws IOException {
           new ClassPathXmlApplicationContext("classpath:spring-provider.xml");
           System.in.read();
       }
   }
   

2. 方式2：在web.xml中使用监听器

   
   
       
       
           contextConfigLocation
           classpath:spring-provider.xml
       
       
       
           org.springframework.web.context.ContextLoaderListener
       
   
   

3. 方式3：在web.xml中使用DispatcherServlet

2.5 创建服务消费者子模块

在Dubbo中，服务端抛出自定义异常时，要在接口方法中声明，否则会被Dubbo转成RuntimeException

服务消费者模块需要在容器启动时去注册中心订阅服务；引用接口，接收参数调用服务，返回结果

artifactId：double_consumer

    dubbo_parent
    com.52lhp
    1.0-SNAPSHOT

4.0.0

double_consumer
war


    
        com.52lhp
        dubbo_interface
        1.0-SNAPSHOT
    
    
        org.springframework
        spring-webmvc
    
    
        com.fasterxml.jackson.core
        jackson-core
        2.9.0
    
    
        com.fasterxml.jackson.core
        jackson-databind
        2.9.0
    
    
        com.fasterxml.jackson.core
        jackson-annotations
        2.9.0
    
    
        javax.servlet
        servlet-api
        2.5
        provided
    

    
        com.alibaba
        dubbo
    
    
        org.apache.zookeeper
        zookeeper
    
    
        org.apache.curator
        curator-framework
    
    
        org.apache.curator
        curator-recipes
    

创建UserController：

package com.liu2m.controller;

import com.liu2m.pojo.User;
import com.liu2m.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping("/findById")
    public User findById(int id) {
        // 调用服务，返回JSON
        return userService.findById(id);
    }
}

创建spring-consumer.xml配置文件：

创建spring-mvc.xml配置文件：

启动zookeeper

在web.xml中配置DispatcherServlet，然后启动Tomcat

    
        dispatcherServlet
        org.springframework.web.servlet.DispatcherServlet
        
            contextConfigLocation
            classpath:spring-mvc.xml
        
        1
    
    
        dispatcherServlet
        *.do
    
    
    
        CharacterEncodingFilter
        org.springframework.web.filter.CharacterEncodingFilter
        
            encoding
            UTF-8
        
    
    
        CharacterEncodingFilter
        /*
    

3. Dubbo监控中心

1. 启动zookeeper，若8080与zookeeper端口冲突，则会一闪而过，可以修改Tomcat端口

2. 将dubbo-admin.war放到Tomcat的webapps下

3. 启动Tomcat后dubbo-admin.war会自动解压，修改WEB-INF下的dubbo.properties：

   # 当前使用的ZooKeeper的ip和端口
   dubbo.registry.address=zookeeper://localhost:2181
   # root用户的密码
   dubbo.admin.root.password=root
   # guest用户的密码
   dubbo.admin.guest.password=guest
   

4. 重启Tomcat，访问http://localhost:8088/dubbo-admin/，输入用户名和密码

5. 启动服务提供者子模块或服务消费者子模块后，可以在服务治理-->服务中可视化查看

4. Dubbo相关配置

4.1 注解实现服务提供者

1. 在spring-provider.xml中配置包扫描

2. 去掉spring-provider.xml中的以下配置：

3. 在服务提供者的接口实现类上添加com.alibaba.dubbo.config.annotation.Service注解

4.2 注解实现服务提供者

1. 在spring-consumer.xml中配置包扫描

2. 去掉spring-consumer.xml中的以下配置：

3. 把Controller类的UserService上的注解Autowired换成com.alibaba.dubbo.config.annotation.Reference注解

4.3 服务接口访问协议

dubbo协议：默认端口20880

1. 连接个数：单连接
2. 连接方式：长连接
3. 传输协议：TCP
4. 传输方式：NIO异步传输
5. 序列化：Hessian二进制序列化
6. 适用范围：传入传出参数数据包较小(建议小于100K)，消费者比提供者个数多，单一消费者无法压满提供者，尽量不要用dubbo协议传输大文件或超大字符串

rmi协议：

1. 连接个数：多连接
2. 连接方式：短连接
3. 传输协议：TCP
4. 传输方式：同步传输
5. 序列化：Java标准二进制序列化
6. 适用范围：传入传出参数数据包大小混合，消费者与提供者个数差不多，可传文件

Dubbo各种协议详解参考：https://www.cnblogs.com/duanxz/p/3555876.html

4.4 负载均衡*

Dubbo提供了多种均衡策略，如：随机random(默认)、轮询roundrobin、最少活跃数leastactive、一致哈希consistenhash

配置负载均衡策略，两者取一：

1. 服务提供者：@Service(loadbalance = "roundrobin")
2. 服务消费者：@Reference(loadbalance = "roundrobin")

5. 配合Dubbo实现ZooKeeper配置中心

1. 把配置信息存入zookeeper(创建节点数据)

   create /config config
   create /config/jdbc.driver 'com.mysql.jdbc.Driver'
   create /config/jdbc.url 'jdbc:mysql://localhost:3306/db01?useSSL=false'
   create /config/jdbc.username 'root'
   create /config/jdbc.password '123456'
   

2. 在dubbo_common子模块中导入坐标

   
       org.springframework
       spring-webmvc
   
   
       com.alibaba
       dubbo
   
   
       org.apache.zookeeper
       zookeeper
   
   
       org.apache.curator
       curator-framework
   
   
       org.apache.curator
       curator-recipes
   
   
       org.mybatis
       mybatis
   
   
       org.mybatis
       mybatis-spring
   
   
       com.alibaba
       druid
   
   
       mysql
       mysql-connector-java
   
   
       org.springframework
       spring-tx
   
   
       org.springframework
       spring-jdbc
   
   

3. 启动时从zookeeper读取配置信息并监听zookeeper中的配置信息目录：在dubbo_common子模块中创建一个类，继承PropertyPlaceholderConfigurer类重写processProperties方法，实现ApplicationContextAware接口重写setApplicationContext方法

   package com.liu2m.utils;
   
   import org.apache.curator.RetryPolicy;
   import org.apache.curator.framework.CuratorFramework;
   import org.apache.curator.framework.CuratorFrameworkFactory;
   import org.apache.curator.framework.recipes.cache.TreeCache;
   import org.apache.curator.framework.recipes.cache.TreeCacheEvent;
   import org.apache.curator.framework.recipes.cache.TreeCacheListener;
   import org.apache.curator.retry.ExponentialBackoffRetry;
   import org.springframework.beans.BeansException;
   import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
   import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.ApplicationContextAware;
   import org.springframework.context.support.AbstractApplicationContext;
   
   import java.util.Properties;
   
   public class SettingCenterUtils extends PropertyPlaceholderConfigurer implements ApplicationContextAware {
       private CuratorFramework zookeeperClient;
       private AbstractApplicationContext applicationContext;
       private boolean first = true;
   
       public SettingCenterUtils() {
           // 创建zookeeper客户端并启动
           String connectString = "127.0.0.1:2181";
           int sessionTimeoutMs = 1000;
           int connectionTimeoutMs = 1000;
           RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 1);
           zookeeperClient = CuratorFrameworkFactory.newClient(connectString, sessionTimeoutMs, connectionTimeoutMs, retryPolicy);
           zookeeperClient.start();
       }
   
       /**
        * 重写processProperties方法
        * 相当于标签
        */
       @Override
       protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props) throws BeansException {
           // 加载zookeeper配置信息
           loadZk(props);
           if (first) { // 保证添加监听的方法只执行一次
               // 监听zookeeper中的配置信息目录
               addWatch();
               first = false;
           }
           super.processProperties(beanFactoryToProcess, props);
       }
   
       // 重写设置ApplicationContext的方法
       @Override
       public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
           // AbstractApplicationContext父类提供了refresh方法，可以刷新spring容器中的对象，因此强转
           this.applicationContext = (AbstractApplicationContext) applicationContext;
       }
   
       // 读取zookeeper中的配置
       private void loadZk(Properties props) {
           try {
               // 读取配置信息
               String driver = new String(zookeeperClient.getData().forPath("/config/jdbc.driver"));
               String url = new String(zookeeperClient.getData().forPath("/config/jdbc.url"));
               String username = new String(zookeeperClient.getData().forPath("/config/jdbc.username"));
               String password = new String(zookeeperClient.getData().forPath("/config/jdbc.password"));
               // 将配置信息设置到Properties中
               props.setProperty("jdbc.driver", driver);
               props.setProperty("jdbc.url", url);
               props.setProperty("jdbc.username", username);
               props.setProperty("jdbc.password", password);
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
       /**
        * 监听zookeeper中的配置信息目录：
        * 1. 不要关闭client，否则无法进行监控
        * 2. 修改完成后必须刷新spring容器中的对象
        */
       private void addWatch() {
           TreeCache treeCache = new TreeCache(zookeeperClient, "/config");
           try {
               // 开始缓存
               treeCache.start();
               // 添加监听对象
               treeCache.getListenable().addListener(new TreeCacheListener() {
                   @Override
                   public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception {
                       // 如果修改了配置，则zookeeper进行通知，重新读取配置信息，刷新spring容器
                       if (event.getType() == TreeCacheEvent.Type.NODE_UPDATED) {
                           // 打印修改的结点，便于查看
                           System.out.println("path = " + event.getData().getPath() +
                                   ", data = " + new String(event.getData().getData()));
                           // 刷新spring容器中的对象
                           // 刷新时会执行一次processProperties方法，可以重新读取zookeeper中的配置信息
                           applicationContext.refresh();
                       }
                   }
               });
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   

4. 修改dubbo_provider子模块的spring-dao.xml，去掉引入jdbc配置文件的标签，然后对PropertyPlaceholderConfigurer的子类进行IoC：

5. 启动服务提供者和服务消费者，在zookeeper中修改配置信息测试(建议创建两个数据库，然后修改url)