Rangka kerja RPC tulisan tangan sebenarnya bukan hanya untuk berpura-pura menjadi 13!

Dalam temuduga, senang ditanya oleh penemuduga:

Bagaimana untuk mereka bentuk rangka kerja RPC?

Anda mungkin belum ditanya, mungkin anda bertuah, atau mungkin anda belum berada di tahap ini. Biasanya gaji bulanan lebih daripada 20k, dan pada dasarnya mereka akan bertanya beberapa soalan reka bentuk.

Dari perspektif penemuduga: Menanyakan soalan jenis ini adalah lebih baik daripada bertanya esei lapan bahagian, yang melibatkan banyak perkara teknikal. Contohnya: pengetahuan tentang corak reka bentuk, protokol komunikasi, ejen dinamik, virtualisasi, kumpulan benang, dsb.

Baiklah, jangan terlalu jauh, mari kita mula bercakap tentang topik hari ini.

RPC ialah panggilan prosedur Jauh mungkin ramai yang tidak memahami perkataan ini secara ringkas:

Panggil perkhidmatan jauh seperti memanggil kaedah tempatan.

Sebagai contoh, kes berikut: perkhidmatan pengendalian pengguna:

public interface UserService{
    String findUserNameById(Integer userId);
}
@Service
public class UserServiceImpl implements UserService{
    String findUserNameById(Integer userId){
        //查数据或查缓存获取到用户名
        return "田哥"
    }
}

Kini pengawal ingin memanggil kaedah findUserNameById UserServiceImpl untuk mendapatkan nama pengguna.

@RestController
public class UserController{
    @Resource
    private UserService userService;
    
    @GetMapping("/test")
    public String test(){
        return userService.findUserNameById(1);
    }
}

Dengan mengandaikan bahawa tiga kelas UserController, UserServiceImpl dan UserService semuanya berada dalam projek yang sama, adalah sangat mudah untuk pengawal memanggil kaedah findUserNameById.

Namun, jika controller adalah projek lain dan ingin dipanggil seperti di atas (perbezaan halus, perasaan masih sama), maka kita boleh menggunakan rangka kerja RPC.

1 Antara muka UserService perlu diletakkan dalam projek berasingan, yang biasanya kami panggil projek api.

2. UserServiceImpl perlu diletakkan dalam projek berasingan, yang biasanya kami panggil projek pembekal.

3. Pengawal, melalui web dan projek (pengguna) lain

4 Jadikan API ke dalam pakej balang, dan kemudian rujuknya dalam kedua-dua projek pengguna dan projek pembekal.

Rangka kerja RPC di pasaran, seperti Dubbo (Alibaba), Jimat (FaceBook), gRpc (Google), brpc (Baidu), dll., semuanya memfokuskan pada aspek yang berbeza untuk menyelesaikan tujuan asal sangat sempurna, dan ada yang ingin mencapai kesempurnaan, manakala yang lain lebih suka kesederhanaan yang melampau.

Prinsip RPC

Berbalik kepada apa yang kami katakan tadiPanggil perkhidmatan jauh seperti panggilan tempatan, apakah sokongan teknikal yang diperlukan?

• Proksi dinamik, kerana projek pengguna kami hanya mempunyai antara muka UserService takrifan dan tiada kelas pelaksanaan Ingin memanggil kaedah antara muka? Kemudian anda hanya boleh membuat objek proksi. .
• Komunikasi rangkaian, proses silang pasti akan melibatkan komunikasi rangkaian.
• Protokol penghantaran rangkaian, pengguna dan pembekal Mesti ada standard untuk maklumat parameter berulang-alik Bagaimana anda menyampaikannya kepada saya? .
• Pusat Pendaftaran, jika penyedia melakukan penempatan kluster (perkhidmatan yang sama digunakan pada berbilang mesin), maka kita perlu melakukan penyelenggaraan manual pada pengguna Jika volum meningkat, beban kerja boleh dibayangkan. .
• Penghalaan dinamik
, jika penyedia digunakan dalam kelompok (perkhidmatan yang sama digunakan pada berbilang mesin), kami tidak boleh membiarkan pengguna jatuh pada nod yang sama, supaya sumber tidak dapat digunakan sepenuhnya, dan
• hujan dan embun maharaja purba akan dikongsi sama
  . Penghalaan dinamik melibatkan pelbagai algoritma, seperti rawak, pengundian, pemberatan, dsb.
Mengapa perlu pusat pendaftaran saya telah kongsikan sebelum ini:
• Temuduga Meituan: Bagaimana untuk mereka bentuk pusat pendaftaran?

• 造轮子

  根据上面的这些原理，田哥也搞了一个RPC框架，命名为mink（一个动物的名称）。

  --mink
  ----mink-rpc rpc基本功能
  ----mink-registry 服务注册与发现
  ----mink-spring 集成SpringBoot

  然后，我们把mink-spring打成jar包，服务发布和服务引用都把这个jar给依赖进去。

  

  

  

  
  

  框架使用

  上面，我们创造了轮子，下面，我们就来看如何使用。

  

  mink-demo就是一个Spring Boot项目，有三个module。

  

  
  

  我们把mink-api打成jar包，共consumer和provider使用。

  也就是我们在consumer和provider都引入：

  <dependency>
      <groupId>com.tian</groupId>
      <artifactId>mink-api</artifactId>
      <version>1.0-SNAPSHOT</version>
  </dependency>

  下面，我们来看看provider端的代码：

  <dependency>
     <groupId>com.tian</groupId>
     <artifactId>mink-spring</artifactId>
     <version>1.0-SNAPSHOT</version>
  </dependency>
  <dependency>
     <groupId>com.tian</groupId>
     <artifactId>mink-api</artifactId>
     <version>1.0-SNAPSHOT</version>
  </dependency>
  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter</artifactId>
     <version>2.5.4</version>
  </dependency>

  我们的mink框架，只需要引入mink-spring依赖即可。

  接着就是properties的配置：

  mink.rpc.servicePort=20880
  mink.rpc.registryType=0
  mink.rpc.registryAddress=127.0.0.1:2181

  再来看看具体服务实现类：

  package com.tian.service;
  
  import com.tian.annotation.MinkService;
  
  /**
   * @author tianwc  公众号：java后端技术全栈、面试专栏
   * @version 1.0.0
   * @description 用户服务
   * @createTime 2022年08月23日 18:16
   */
  @MinkService
  public class UserServiceImpl implements UserService {
      @Override
      public String findUserNameByiD(Integer id) {
          System.out.println("服务调用");
          return "tian";
      }
  }

  这一步，我们只需要在实现类上加上注解@MinkService即可。

  最后就是项目启动类：

  @ComponentScan(basePackages = {"com.tian.service","com.tian"})
  @SpringBootApplication
  public class Application {
      public static void main(String[] args) {
          SpringApplication.run(Application.class, args);
      }
  }

  我们启动项目（注册中心用的是zookeeper）：

  

  
  

  从日志中可以看出，我们的服务已经成功注册到注册中心了。

  下面，我们来看看consumer端代码。

  首先来看看依赖：

  <dependency>
     <groupId>com.tian</groupId>
     <artifactId>mink-spring</artifactId>
     <version>1.0-SNAPSHOT</version>
  </dependency>
  <dependency>
     <groupId>com.tian</groupId>
     <artifactId>mink-api</artifactId>
     <version>1.0-SNAPSHOT</version>
  </dependency>
  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter</artifactId>
     <version>2.5.4</version>
  </dependency>
  
     org.springframework.boot
     spring-boot-starter-web
     2.5.4
  

  这依赖也很简单，没什么好说的。

  再来看看properties配置项：

  mink.rpc.registryType=0
  mink.rpc.registryAddress=127.0.0.1:2181
  
  server.port=8090

  是不是也很简单？

  再来看看我们的controller代码：

  package com.tian.controller;
  
  import com.tian.annotation.MinkReference;
  import com.tian.service.UserService;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  /**
   * @author tianwc  公众号：java后端技术全栈、面试专栏
   * @version 1.0.0
   * @description 消费端
   * @createTime 2022年08月23日 23:08
   */
  @RestController
  public class UserController {
  
      @MinkReference
      private UserService userService;
  
      @RequestMapping("/test")
      public String test() {
          return userService.findUserNameByiD(1);
      }
  }

  需要用到对应服务，只需要添加注解@MinkReference即可。

  最后就是项目启动类，简单的不行。

  @SpringBootApplication
  public class Application {
      public static void main(String[] args) {
          SpringApplication.run(Application.class, args);
      }
  }

  启动日志：

  

  访问：http://localhost:8090/test

  

  成功！整个过程，非常轻松地集成mink框架并在业务代码中使用。

  总结起来，其实就三步：

  1、pom中添加依赖

  2、properties文件中配置注册中心信息

  3、使用的时候加上注解@MinkReference或 @MinkService即可

Atas ialah kandungan terperinci Rangka kerja RPC tulisan tangan sebenarnya bukan hanya untuk berpura-pura menjadi 13!. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!