[大数据]Dubbo开源服务框架

Dubbo框架

一、互联网架构演变趋势

• 单一应用架构：war文件B–S--DB,把系统所有功能耦合在一个应用中，部署简单，易于管理，测试成本高，迭代困难，可靠性差，代表技术：Struts2,SpringMvc,Spring,Mybatis等

• RPC架构：war–tomcat–8080,跨虚拟机调用，服务过多，管理成本高，服务治理，服务注册等问题，服务之间隔离的优点。代表技术：Thrift、Hession等

• SOA架构：面向独立服务架构，分布式环境，一个功能模块就是一个单独服务系统，服务与服务之间的的交互。代表技术：Mule,Wso2等

• 微服务架构：一种架构风格，更细的划分，微服务组成，测试容易，高内聚低耦合，每个服务可以独立测试，运维成本高，部署数据量较多（在SoA更加细分）

整体过程为：重项目的单一体制，逐渐分化，在进行单独功能分化，最后细微分化，最终目的还是高内聚内耦合

二、RPC基于RMI的简单实现

1、OSI模型

物理层，数据链路层，网络侧，传输层，会话层，表示层，应用层

2、RPC基本概念

远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC采用客户机/服务器模式。请求程序就是一个客户机，而服务提供程序就是一个服务器。

3、 RPC与HTTP、TCP／UDP、Socket的区别

• TCP/UDP: 都是传输协议，主要区别是tcp协议连接需要3次握手，断开需要四次挥手，是通过流来传输的，就是确定连接后，一直发送信息，传完后断开。udp不需要进行连接，直接把信息封装成多个报文，直接发送。所以udp的速度更快写，但是不保证数据的完整性。
• Http：超文本传输协议是一种应用层协议，建立在TCP协议之上。
• Socket：是在应用程序层面上对TCP/IP协议的封装和应用。其实是一个调用接口，方便程序员使用TCP/IP协议栈而已。程序员通过socket来使用tcp/ip协议。但是socket并不是一定要使用
• tcp/ip协议，Socket编程接口在设计的时候，就希望也能适应其他的网络协议。
• RPC是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。 所以RPC的实现可以通过不同的协议去实现比如可以使http、RMI等。

4、RPC的执行流程

首先，要解决通讯的问题，主要是通过在客户端和服务器之间建立TCP连接，远程过程调用的
所有交换的数据都在这个连接里传输。连接可以是按需连接，调用结束后就断掉，也可以是长连
接，多个远程过程调用共享同一个连接。
第二，要解决寻址的问题，也就是说，A服务器上的应用怎么告诉底层的RPC框架，如何连接到
B服务器（如主机或IP地址）以及特定的端口，方法的名称名称是什么，这样才能完成调用。比
如基于Web服务协议栈的RPC，就要提供一个endpoint URI，或者是从UDDI(一种目录服务，通
过该目录服务进行服务注册与搜索)服务上查找。如果是RMI调用的话，还需要一个RMI Registry
来注册服务的地址。
第三，当A服务器上的应用发起远程过程调用时，方法的参数需要通过底层的网络协议如TCP传
递到B服务器，由于网络协议是基于二进制的，内存中的参数的值要序列化成二进制的形式，也
就是序列化（Serialize）或编组（marshal），通过寻址和传输将序列化的二进制发送给B服务
器。
第四，B服务器收到请求后，需要对参数进行反序列化（序列化的逆操作），恢复为内存中的表
达方式，然后找到对应的方法（寻址的一部分）进行本地调用，然后得到返回值。
第五，返回值还要发送回服务器A上的应用，也要经过序列化的方式发送，服务器A接到后，再
反序列化，恢复为内存中的表达方式，交给A服务器上的应用

5、为什么需要RPC？

• 灵活部署
• 解耦

RPC框架一般都有注册中心，有丰富的监控管理；发布、下线接口、动态扩展等，对调用方来说是无感知、统一化的操作。第三个来说就是安全性。最后就是流行的服务化架构、服务化治理，RPC框架是一个强力的支撑。

三、RPC基于RMI的简单实现

主要建立一个maven聚合项目RPC_demo，其内部建立三个子项目，RPC_api,RPC_server,RPC_client进行测试

1、父项目依赖POM

<?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>org.example</groupId>
    <artifactId>RPC_demo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>RPC_server</module>
        <module>RPC_client</module>
        <module>RPC_api</module>
    </modules>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/>
        <!-- lookup parent from repository -->
    </parent>

        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
        </dependencies>

</project>

2、子项目配置与编写

• RPC_api
  不需要添加依赖

编写RPC_api的接口服务以及Pojo对象

//服务接口
/*提供服务*/
public interface UserServiceI {
    User selectUserById(Integer userId) throws RemoteException;
}

------------------------------------------------------
//User对象
public class User implements Serializable {
    private Integer id;
    private String name;
}//此处省略set get toString...

• RPC_server

注入api依赖：

<dependency>
      <!--rmi-api 依赖-->
      <groupId>com.yjxxt</groupId>
      <artifactId>RPC_api</artifactId>
      <version>1.0-SNAPSHOT</version>
 </dependency>

编写服务实现以及端口号配置（生产者）

//config/ServiceConfig.java
/*注册Server*/
@Configuration
public class ServiceConfig {
    @Autowired
    private UserServiceI userService;
    @Bean
    public RmiServiceExporter getRmiServiceExporter() {
        RmiServiceExporter rmiServiceExporter = new RmiServiceExporter();
        rmiServiceExporter.setServiceName("userService");
        rmiServiceExporter.setService(userService);
        rmiServiceExporter.setServiceInterface(UserServiceI.class);
        rmiServiceExporter.setRegistryPort(2002);
        return rmiServiceExporter;
    }
}
--------------------------------------------------------
//Service/UserServiceImp.java
@Service
public class UserServiceImp implements UserServiceI {
    @Override
    public User selectUserById(Integer userId) throws RemoteException {
        User user=new User();
        user.setId(100);
        user.setName("(*^_^*)");
        return user;
    }
}
-------------------------------------------------------------
//启动类
@SpringBootApplication
public class Start {
    public static void main(String[] args) {
        SpringApplication.run(Start.class,args);
    }
}

server:
  port: 8082

• RPC_client

同样注入api依赖

编写消费者以及配置：

//controller/UserController.java
@Controller
public class UserController implements CommandLineRunner {

    //注入远程代理
    @Autowired
    private UserServiceI userService;

    @Override
    public void run(String... args) throws Exception {
        System.out.println(userService.selectUserById(1));
    }
}
------------------------------------------------------------
//config/ClientConfig .java
@Configuration
public class ClientConfig {

    @Bean(name = "userService")
    public RmiProxyFactoryBean getUserService() {
        RmiProxyFactoryBean rmiProxyFactoryBean = new RmiProxyFactoryBean();
        rmiProxyFactoryBean.setServiceUrl("rmi://127.0.0.1:2002/userService");
        rmiProxyFactoryBean.setServiceInterface(UserServiceI.class);
        return rmiProxyFactoryBean;
    }
}
-----------------------------------------------------
//启动类
@SpringBootApplication
public class Start {
    public static void main(String[] args) {
        SpringApplication.run(Start.class,args);
    }
}

端口号配置为8081

3、启动测试

先启动生产者，否则报错

四、SpringBoot整合Dubbo

1、Dubbo入门

① 介绍 ?

高性能，轻量级，开源服务框架，Apache,智能容错负载均衡，六大特点

工作流程：

注册中心：multicast ,zookeeper,redis ,simple 首选zookeeper是一个树型目录服务，支持变更推送

② 常用标签

dubbo:registry :指定连接注册中心信息(配置注册中心) 
dubbo:protocol : 服务提供方注册服务采用的协议
dubbo:service : 对外暴露服务配置
dubbo:reference : 配置订阅的服务(接口的代理)
其他标签及属性用到了去api查询即可。

2、整合Dubbo框架

①Maven聚合项目

父项目子项目依赖：

-------------------------父项目依赖-----------------------------
 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version> <relativePath/>
        <!-- lookup parent from repository -->
 </parent>
    
      <dependencies>
            <!-- dubbo-spring-boot-starter -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>${dubbo.version}</version>
            </dependency>
      </dependencies> 
            
-------------------------子项目Provide依赖----------------------
   <!-- dubbo依赖 -->
    <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-spring-boot-starter</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
      <groupId>com.yjxxt</groupId>
      <artifactId>dubbo-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
-------------------------子项目Consumer依赖---------------------
 <!-- dubbo依赖 -->
    <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-spring-boot-starter</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
      <groupId>com.yjxxt</groupId>
      <artifactId>dubbo-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>

②编写dubbo_api

//pojo/user.java
public class User implements Serializable {
    private Integer id;
    private String name;
    }//省略了set.get...
//service/UserServerI 接口
public interface UserServerI {
    public User getUserById(Integer id);
}

③编写dubbo_provider

//server/UserServiceImp 实现api接口服务
@Service(version ="1.0")
public class UserServiceImp implements UserServerI {
    @Override
    public User getUserById(Integer id) {
        User user=new User();
        user.setName("张三");
        user.setId(100);
        return user;
    }
}
//启动类
@SpringBootApplication
public class ServiceStart {
    public static void main(String[] args) {
        SpringApplication.run(ServiceStart.class,args);
    }
}

项目配置文件

#防止端口冲突
server:
  port: 8001
dubbo:
  application:
    # 应用名称
    name: dubbo-provider
  registry:
    # 注册中心地址
    address: multicast://224.5.6.7:1234
    # 超时时间，单位毫秒
    timeout: 100000
    # 元中心地址
  protocol:
    ##协议名称
    name: dubbo
    port: 20880
  scan:
    ##配置服务所在包
    base-packages: com.yjxxt.provider.service

④编写dubbo_consumer

//controller/UserController .java
@Controller
public class UserController implements CommandLineRunner {

    @Reference(version = "1.0",parameters = {"unicast","false"})
    private UserServerI userServer;

    @Override
    public void run(String... args) throws Exception {
        System.out.println(userServer.getUserById(1));
    }
}
//启动类
@SpringBootApplication
public class ControllerStart {
    public static void main(String[] args) {
        SpringApplication.run(ControllerStart.class,args);
    }
}

项目配置

#防止端口冲突
server:
  port: 8002
dubbo:
  application:
    # 应用名称
    name: dubbo-consumer
  registry:
    # 注册中心地址
    address: multicast://224.5.6.7:1234

⑤测试

3、Zookeeper单机搭建?SpringBoot整合

• 什么是zookeeper?
  ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。ZooKeeper的目标就是封装好复杂易出错的关键服务，将简单易用的接口和性能高效、功能稳定的系统提供给用户。

①安装zookeeper(Linux）

zookeeper下载

安装配置流程

//创建安装目录
mkdir -p /usr/local/zookeeper
//将文件解压到该目录
tar -zxvf apache-zookeeper-3.6.1-bin.tar.gz -C /usr/local/zookeeper/
//创建data数据目录，和日志目录log
mkdir -p /usr/local/zookeeper/apache-zookeeper-3.6.1-bin/data
mkdir -p /usr/local/zookeeper/apache-zookeeper-3.6.1-bin/log
//修改配置文件(复制zoo_sample.cfg-->zoo.cfg)
//修改data,log两个文件路径即可保存退出
//启动切换到bin目录下
./zkServer.sh start

成功

②SpringBoot整合zookeeper

直接修改上面的SpringBoot_dubbo项目
依赖引入父子项目都要引入（除api子项目）

//父项目
 <!--zookeeper 注册中心客户端引入 curator客户端 -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-dependencies-zookeeper</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
            </dependency>
            <dependency>
                <groupId>com.netflix.curator</groupId>
                <artifactId>curator-framework</artifactId>
                <version>1.1.10</version>
            </dependency>
-------------------------------------------------------------
//子项目
<dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-dependencies-zookeeper</artifactId>
      <type>pom</type>
    </dependency>

修改配置

③启动测试

./zkCli.sh启动客户端查看

4、Zookeeper集群搭建

详细介绍

集群搭建完毕之后，直接修改项目的配置文件将地址改成集群地址即可

5、Zookeeper概念

?Zookeeper详细概念

服务开发最佳实践：

分包原则，重用发布等价原则，共同重用原则

粒度：直接扣的声明多个方法，每个服务方法应该代表一个功能，依业务场景为单位划分

远程服务不要basemapper，可以在service中搞

兼容性：向后兼容

枚举值：完备集，可以，业务种类变化不建议

序列化：POJO对象，参数返回接口不建议

异常：建议错误返回异常

调用：Provider端需要对输入参数进行校验