Dubbo:软件架构、RPC、dubbo概述、dubbo的使用直连方式

第一章：

（1）软件架构

（2）RPC

（3）dubbo概述

（4）dubbo的使用直连方式

1.1软件架构

（ 1 ）单一应用架构当网站流量很小时，应用规模小时，只需一个应用，将所有功能都部署在一起，以减少部署服务器数量和成本。此时，用于简化增删改查工作量的数据访问框架 (ORM) 是关键。数据库的处理时间影响应用的性能

这种结构的应用适合小型系统，小型网站，或者企业的内部系统，用户较少，请求量不大，对请求的处理时间没有太高的要求。将所有功能都部署到一个服务器，简单易用。开发项目的难度低。

缺点： 1、性能扩展比较困难 2、不利于多人同时开发 3、不利于升级维护 4、整个系统的空间占用比较大

（3）分布式服务架构

当应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。分布式系统将服务作为独立的应用，实现服务共享和重用。

1.2分布式系统

1.2.1 什么是分布式系统

分布式系统是若干独立计算机（服务器）的集合，这些计算机对于用户来说就像单个相关系统，分布式系统（distributed system）是建立在网络之上的服务器端一种结构。分布式系统中的计算机可以使用不同的操作系统，可以运行不同应用程序提供服务，将服务分散部署到多个计算机服务器上。

1.2.2 RPC ？

RPC 【Remote Procedure Call】是指远程过程调用，是一种进程间通信方式，是一种技术思想，而不是规范。它允许程序调用另一个地址空间（网络的另一台机器上）的过程或函数，而不用开发人员显式编码这个调用的细节。调用本地方法和调用远程方法一样。

RPC 的实现方式可以不同。例如 java 的 rmi, spring 远程调用等。

RPC 概念是在上世纪 80 年代由 Brue Jay Nelson(布鲁·杰伊·纳尔逊)提出。使用 PRC 可以将本地的调用扩展到远程调用（分布式系统的其他服务器）。

RPC 的特点：

1. 简单：使用简单，建立分布式应用更容易。 2. 高效：调用过程看起来十分清晰，效率高。 3. 通用：进程间通讯的方式，有通用的规则。

PRC 调用过程：

1.调用方 client 要使用右侧 server 的功能（方法），发起对方法的调用

2.client stub 是 PRC 中定义的存根，看做是 client 的助手。stub 把要调用的方法参数进行序列化，方法名称和其他数据包装起来。

3.通过网络 socket(网络通信的技术)，把方法调用的细节内容发送给右侧的 server

4.server 端通过 socket 接收请求的方法名称，参数等数据，传给 stub。

5.server 端接到的数据由 serverstub(server 的助手)处理，调用 server 的真正方法，处理业务 6.server 方法处理完业务，把处理的结果对象（Object）交给了助手，助手把 Object 进行序列化，对象转为二进制数据。

7. server 助手二进制数据交给网络处理程序

8. 通过网络将二进制数据，发送给 client。

9.client 接数据，交给 client 助手。

10.client 助手，接收数据通过反序列化为 java 对象（Object），作为远程方法调用结果。

其他： rpc 通讯是基于 tcp 或 udp 议

序列化方式（xml/json/二进制）

2.1 dubbo 概述

Apache Dubbo (incubating) |ˈdʌbəʊ| 是一款高性能、轻量级的开源 Java RPC 框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。 Dubbo 是一个分布式服务框架，致力于提供高性能和透明化的 RPC 远程服务调用方案、服务治理方案。

官网：http://dubbo.apache.org/zh-cn/

dubbo：发展历程：

面向接口代理：调用接口的方法，在 A 服务器调用 B 服务器的方法，由 dubbo 实现对 B 的调用，无需关心实现的细节，就像 MyBatis 访问 Dao 的接口，可以操作数据库一样。不用关心 Dao 接口方法的实现。这样开发是方便，舒服的。

2.2 基本架构

服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。

服务消费者（Consumer）: 调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者

监控中心（Monitor）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心

调用关系说明:

⚫ 服务容器负责启动，加载，运行服务提供者。

⚫ 服务提供者在启动时，向注册中心注册自己提供的服务。

⚫ 服务消费者在启动时，向注册中心订阅自己所需的服务。

⚫ 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

⚫ 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

⚫ 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

2.5 直连方式 dubbo

点对点的直连项目:消费者直接访问服务提供者，没有注册中心。消费者必须指定服务提供者的访问地址（url）。

消费者直接通过 url 地址访问固定的服务提供者。这个 url 地址是不变的。

创建服务的提供者：

pom.xml:引入dubbo的依赖：




  4.0.0

  com.wkcto.dubbo
  001-link-userservice-provider
  1.0.0
  war

  001-link-userservice-provider Maven Webapp
  
  http://www.example.com

  
    UTF-8
    1.7
    1.7
  

  
    
      junit
      junit
      4.11
      test
    

    
    
      org.springframework
      spring-context
      4.3.16.RELEASE
    
    
      org.springframework
      spring-webmvc
      4.3.16.RELEASE
    

    
    
      com.alibaba
      dubbo
      2.6.2
    
  

  
    
     
       
         maven-compiler-plugin
         3.1
         
           1.8
           1.8

User类：

package com.wkcto.model;

import java.io.Serializable;

public class User  implements Serializable {
    private Integer id;
    private String username;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

UserService接口：

package com.wkcto.service;

import com.wkcto.model.User;

public interface UserService {

    //根据用户标识获取用户信息
    User queryUserById(Integer id);
}

UserServiceImpl：

package com.wkcto.service.impl;

import com.wkcto.model.User;
import com.wkcto.service.UserService;

public class UserServiceImpl implements UserService {
    @Override
    public User queryUserById(Integer id) {

        //调用持久层去查用户信息，这里只是模仿直接创建一个用户信息就行了
        User user=new User();
        user.setId(1001);
        user.setUsername("lisi");
        user.setAge(23);
        return user;
    }
}

服务创建好之后如何把这个服务暴露出去呢？这就用到dubbo的核心配置文件，跟spring的配置文件一样

dubbo-userservice-provider.xml：

web.xml:定义监听器、加载配置文件：




    
    
        contextConfigLocation
        classpath:dubbo-userservice-provider.xml
    

   
    
        org.springframework.web.context.ContextLoaderListener

配置tomcat：

创建服务的消费者：

创建一个新的Model：

把001-link-userservice-provider打成一个架包，发到本地仓库：002Model会引用001

按两下Ctrl

引入依赖pom.xml:引入提供者的依赖，让消费者知道有哪些接口可以用




  4.0.0

  com.wkcto.dubbo
  002-link-consumer
  1.0.0
  war

  002-link-consumer Maven Webapp
  
  http://www.example.com

  
    UTF-8
    1.7
    1.7
  

  
    
      junit
      junit
      4.11
      test
    

    
    
      org.springframework
      spring-context
      4.3.16.RELEASE
    
    
      org.springframework
      spring-webmvc
      4.3.16.RELEASE
    

    
    
      com.alibaba
      dubbo
      2.6.2
    

    
    
      com.wkcto.dubbo
      001-link-userservice-provider
      1.0.0

消费者的核心配置文件：

dubbo-consumer.xml：

spring配置文件application.xml:

web.xml:




    
    
        DispatcherServlet
        com.alibaba.dubbo.remoting.http.servlet.DispatcherServlet
        
        
            contextConfigLocation
            classpath:application.xml,classpath:dubbo-consumer.xml
        

    
    
    
        DispatcherServlet
        
        /
    

   
    
        org.springframework.web.context.ContextLoaderListener

控制器：UserController：

package com.wkcto.dubbo.web;

import com.wkcto.model.User;
import com.wkcto.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/user")
    public String userDetil(Model model,Integer id){
        User user=userService.queryUserById(id);
        model.addAttribute("user",user);
        return "userDetail";
    }
}

创建jsp页面userDetail.jsp:

<%--
  Created by IntelliJ IDEA.
  User: DELL
  Date: 2022/7/13
  Time: 17:30
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
%>


    用户详情
    


  用户详情
  用户标识：${user.id}
  用户名称：&{user.username}

配置tomcat：

先运行项目一服务提供者的tomcat，在运行项目二消费者的tomcat

在地址栏输入：地址

消费者依赖了提供者，就不在需要使用这个userService接口了，在控制类中可以直接new出来接口的实现类，调用里面的方法，这样就跟dubbo没有关系了

dubbo是面向的这个接口，以接口为粒度，这里可以new出接口的实现类，就不需要dubbo，基于这种情况，dubbo要求这个工程里面需要一个接口工程

中间是接口工程，左边是消费者，右边是服务提供者

服务提供者：把你暴露的接口放到这个接口工程里面

服务消费者：从接口工程里面获得暴露的接口

这样就不能new出来这个实现类了，只能通过RPC远程方法协议调用

Dubbo:软件架构、RPC、dubbo概述、dubbo的使用 直连方式

Java相关栏目本月热门文章

Dubbo:软件架构、RPC、dubbo概述、dubbo的使用直连方式