微服务-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接口的映射文件:




    

创建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)

你可能感兴趣的:(微服务-02-Dubbo)