Le framework RPC manuscrit n'est vraiment pas seulement destiné à faire semblant d'avoir 13 ans !

Lors de l'entretien, il est facile de se faire demander par l'intervieweur :

Comment concevoir un framework RPC ?

On ne vous l'a peut-être pas demandé, peut-être avez-vous de la chance, ou peut-être n'êtes-vous pas encore à ce niveau. Habituellement, le salaire mensuel est supérieur à 20 000 et ils poseront essentiellement des questions de conception.

Du point de vue de l'intervieweur : il vaut mieux poser ce type de questions que de poser un essai en huit parties, qui implique de nombreux points techniques. Par exemple : connaissances sur les modèles de conception, les protocoles de communication, les agents dynamiques, la virtualisation, les pools de threads, etc.

D’accord, n’allons pas trop loin, commençons par parler du sujet d’aujourd’hui.

RPC est un appel de procédure à distance. De nombreuses personnes ne comprennent peut-être pas particulièrement ces mots. Pour le dire simplement :

Appelez un service distant, tout comme appeler une méthode locale.

Par exemple, le cas suivant : un utilisateur exploitant un service :

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

Maintenant, un contrôleur souhaite appeler la méthode findUserNameById de UserServiceImpl pour obtenir le nom d'utilisateur.

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

En supposant que les trois classes UserController, UserServiceImpl et UserService sont toutes dans le même projet, il est très simple pour le contrôleur d'appeler la méthode findUserNameById.

Cependant, si le contrôleur est un autre projet et veut être appelé comme ci-dessus (différence subtile, le ressenti est toujours le même), alors nous pouvons utiliser le framework RPC.

1. L'interface UserService doit être placée dans un projet distinct, que nous appelons généralement un projet API.

2. UserServiceImpl doit être placé dans un projet distinct, que nous appelons généralement le projet fournisseur.

3. Contrôleur, via le Web et d'autres projets (consommateurs)

4. Transformez l'API en package jar, puis référencez-la à la fois dans le projet consommateur et dans le projet fournisseur.

Les frameworks RPC sur le marché, tels que Dubbo (Alibaba), Thrift (FaceBook), gRpc (Google), brpc (Baidu), etc., se concentrent tous sur différents aspects pour résoudre l'objectif initial. Certains veulent l'être. extrêmement parfait, et certains veulent atteindre la perfection, certains recherchent la performance ultime, tandis que d'autres préfèrent l'extrême simplicité.

Principe RPC

Retour à ce que nous avons dit plus tôtAppelez un service à distance comme un appel local, quel support technique est nécessaire ?

• Procuration dynamique, car notre projet consommateur n'a que des définitions d'interface UserService et aucune classe d'implémentation Vous souhaitez appeler une méthode d'interface ? Ensuite, vous pouvez uniquement créer un objet proxy.
• Encodage, c'est-à-dire que le consommateur doit transmettre les paramètres de la demande au fournisseur. Le processus de transmission réseau encode d'abord nos paramètres, puis les transmet au fournisseur.
• Communication réseau, les processus croisés impliqueront certainement une communication réseau.
• Protocole de transmission réseau, consommateur et fournisseur. Il doit y avoir une norme pour les informations sur les paramètres qui vont et viennent, comment me les transmettre sinon, comment puis-je savoir ce que vous voulez exprimer ?
• Sérialisation et désérialisation
• Compression des données Lors de la transmission de données sur le réseau, si les données sont trop volumineuses, nous devons déterminer si les données peuvent être compressées.
• Registration Center, si le fournisseur effectue un déploiement de cluster (le même service est déployé sur plusieurs machines), alors nous devons effectuer une maintenance manuelle sur le consommateur. Si le volume augmente, la charge de travail peut être imaginée.
• Conscience dynamique du service en ligne et hors ligne Si le fournisseur est en panne ou qu'un nouveau nœud est déployé, le consommateur a besoin de savoir quels services sont hors ligne et quels services sont en ligne.
• Routage dynamique, si le fournisseur est déployé dans un cluster (le même service est déployé sur plusieurs machines), on ne peut pas laisser tomber les consommateurs sur le même nœud, de sorte que les ressources ne peuvent pas être pleinement utilisées, et le la pluie et la rosée de l'ancien empereur seront partagées à parts égales . Le routage dynamique implique une variété d'algorithmes, tels que la randomisation, l'interrogation, la pondération, etc.

Pourquoi un centre d'enregistrement est-il nécessaire ? Je l'ai déjà partagé :

Interview Meituan : Comment concevoir un centre d'enregistrement ?

造轮子

根据上面的这些原理，田哥也搞了一个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即可

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!