Salut je suis Shendi
Introduction détaillée à Dubbo, à la méthode API et à la méthode SpringBoot
J'ai déjà utilisé le framework RPC écrit par moi-même, car il est écrit par moi-même, et sa fonction n'est pas aussi bonne que le framework open source sur le marché, y compris la série Spring Cloud plus tard. Si je l'écris encore moi-même, Je dois faire de l'intégration, etc. Charge de travail énorme.
Partant de l'idée de ne pas faire de roues sans faire de roues, j'ai commencé à me renseigner sur Dubbo
Doubbo
Apache Dubbo est un framework WEB et RPC hautes performances facile à utiliser. Il fournit également des fonctionnalités, des outils et les meilleures pratiques pour créer des microservices au niveau de l'entreprise tels que la découverte de services, la gouvernance du trafic, l'observabilité et l'authentification.
Les microservices développés à l'aide de Dubbo ont des capacités natives de découverte d'adresses à distance et de communication entre eux.En utilisant les riches fonctionnalités de gouvernance de service fournies par Dubbo, les demandes de gouvernance de service telles que la découverte de service, l'équilibrage de charge et la planification du trafic peuvent être réalisées. Dubbo est conçu pour être hautement évolutif, et les utilisateurs peuvent facilement mettre en œuvre diverses logiques personnalisées pour l'interception du trafic et la sélection de l'emplacement.
Document officiel : https://cn.dubbo.apache.org/zh-cn/index.html
RPC, Distribué, Microservices
Voici une brève introduction, RPC est Remote Procedure Call (appel de procédure à distance), via RPC, vous pouvez faire un appel de programme la fonction d'autres programmes de périphérique (via le réseau)
Distribué signifie que plusieurs programmes communiquent via le réseau pour former un système, généralement en utilisant RPC pour obtenir des
Les microservices divisent un programme en plusieurs programmes et les programmes communiquent de manière distribuée.
démarrage rapide
commencer le gardien du zoo
Zookeeper est actuellement utilisé dans les documents officiels, donc zookeeper doit d'abord être installé. Pour l'installation et l'utilisation de zookeeper, veuillez vous référer à cet article
Introduction détaillée à l'installation de Zookeeper, facile à utiliser
Développer des applications de microservice basées sur l'API Dubbo
Tout projet Maven, modifiez pom.xmlet ajoutez le contenu suivant
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo</artifactId>
<version>3.2.0-beta.4</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-x-discovery</artifactId>
<version>4.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.8.0</version>
<exclusions>
<exclusion>
<groupId>io.netty</groupId>
<artifactId>netty-handler</artifactId>
</exclusion>
<exclusion>
<groupId>io.netty</groupId>
<artifactId>netty-transport-native-epoll</artifactId>
</exclusion>
</exclusions>
</dependency>
Remarque : la plupart des packages dépendants utilisent org.apache.dubbo
fournisseur de services
Créer deux nouveaux packages, un api, qui contient la définition de l'interface de service, et un fournisseur, qui contient l'implémentation spécifique de l'interface de service
Créez une nouvelle interface sous le package api, le contenu est le suivant
public interface ITest {
String sayHi(String name);
}
Créez une nouvelle classe dans le package du fournisseur pour implémenter cette interface et publiez le serveur, le contenu est le suivant
import org.apache.dubbo.config.ProtocolConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.ServiceConfig;
import org.apache.dubbo.config.bootstrap.DubboBootstrap;
import demo.api.ITest;
public class Test implements ITest {
public static void main(String[] args) {
// 定义具体的服务
ServiceConfig<ITest> service = new ServiceConfig<>();
service.setInterface(ITest.class);
service.setRef(new Test());
// 启动 Dubbo
DubboBootstrap.getInstance()
.application("first-dubbo-provider")
.registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
.protocol(new ProtocolConfig("dubbo", -1))
.service(service)
.start()
.await();
}
public String sayHi(String name) {
return "hi, " + name;
}
}
Le zookeeper ci-dessus est l'adresse du zookeeper, si la chaîne au-dessus du port est modifiée, elle doit être modifiée en conséquence
Maintenant, le fournisseur de services peut être démarré et la console affichera de nombreuses informations après le démarrage...
Attendez un moment, si vous voyez les informations suivantes, cela signifie que le démarrage est réussi
Réponse ping obtenue pour l'identifiant de session :…
Cette chose sera sortie tout le temps, c'est le journal du mécanisme de battement de coeur de ZK
Décrivez brièvement les fonctions implémentées ci-dessus, ce qui équivaut à fournir une interface sayHi. L'interface reçoit un paramètre name et renvoie une chaîne. Le contenu de la chaîne est hi, + le paramètre name passé
consommateur de services
Créer un nouveau package clientpour stocker les clients (consommateurs)
Créez une nouvelle classe Test2 sous le package pour vous abonner au service fourni et appelez
Le contenu est le suivant
import java.io.IOException;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.bootstrap.DubboBootstrap;
import com.alibaba.dubbo.config.ReferenceConfig;
import demo.api.ITest;
public class Test2 {
public static void main(String[] args) throws IOException {
ReferenceConfig<ITest> reference = new ReferenceConfig<>();
reference.setInterface(ITest.class);
DubboBootstrap.getInstance()
.application("first-dubbo-consumer")
.registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
.reference(reference);
ITest service = reference.get();
String message = service.sayHi("dubbo");
System.out.println("Receive result ======> " + message);
System.in.read();
}
}
Après l'exécution, beaucoup d'informations sont sorties, et enfin les informations suivantes peuvent être vues
Selon le code ci-dessus, un simple appel RPC via la découverte de service est implémenté. Le code est simple et vous pouvez savoir ce que cela signifie en un coup d'œil.
Développer des applications de microservice basées sur SpringBoot
Similaire au développement d'API, mais SpringBoot se caractérise par une méthode de configuration basée sur des annotations, qui permet un développement rapide
L'exemple du site officiel est l'utilisation du multi-module Maven, il y a trois modules, respectivement
- interface
- fournisseur
- consommateur
Dans ce qui précède, nous savons que le fournisseur et le consommateur doivent définir la partie interface, le fournisseur implémente l'interface et le consommateur utilise l'interface.Afin de partager la partie interface, le multi-module utilisé dans l'exemple officiel
L'IDEA utilisée par l'exemple officiel, je liste le processus Eclipse ici
(Bien sûr, il est également possible de ne pas utiliser plusieurs modules, ou il peut être divisé en un projet ou deux projets)
Créez un nouveau projet Maven, sélectionnez pom pour Packaging et ajoutez les dépendances suivantes à pom.xml
<properties>
<dubbo.version>3.2.0-beta.4</dubbo.version>
<spring-boot.version>2.7.8</spring-boot.version>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencyManagement>
<dependencies>
<!-- Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- Dubbo -->
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-bom</artifactId>
<version>${dubbo.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-dependencies-zookeeper-curator5</artifactId>
<version>${dubbo.version}</version>
<type>pom</type>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring-boot.version}</version>
</plugin>
</plugins>
</pluginManagement>
</build>
Créez ensuite trois nouveaux modules, à savoir
- démo-consommateur (consommateur)
- fournisseur de démonstration (fournisseur)
- interface de démonstration (interface partagée)
Clic droit sur le projet -> Nouveau -> Autre -> Maven -> Module Maven
L'emballage sélectionne le pot et crée un module
Modifiez le contenu pom.xml de demo-provider et demo-consumer, copiez le contenu requis par SpringBoot et ajoutez les dépendances suivantes
<dependencies>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-samples-spring-boot-interface</artifactId>
<version>${project.parent.version}</version>
</dependency>
<!-- dubbo -->
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-dependencies-zookeeper-curator5</artifactId>
<type>pom</type>
<exclusions>
<exclusion>
<artifactId>slf4j-reload4j</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
</exclusions>
</dependency>
<!-- spring boot starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies>
En plus des dépendances ci-dessus, il est également nécessaire d'introduire la partie commune, demo-interface
<dependency>
<groupId>demo-interface</groupId>
<artifactId>demo-interface</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
Poste une photo du projet
Partie commune (démo-interface)
Le module demo-interface est une partie commune.Créez un nouveau package sous src/main/java nommé demo, et créez une nouvelle interface nommée Service sous le package.
Le comportement utilisé par le consommateur fournisseur est défini dans le Service, le contenu est le suivant
Parce que ce module n'a besoin que de créer une interface, le pom n'a fondamentalement pas besoin d'introduire de dépendances
fournisseur de services (fournisseur de démonstration)
Les fournisseurs et les consommateurs doivent introduire des parties communes, comme mentionné ci-dessus
Le module demo-provider est le fournisseur, créez un nouveau package nommé demo.provider et créez une nouvelle classe sous le package nommé ServerImpl
ServerImpl implémente le service d'interface fourni par la partie commune (interface), comme suit
package demo.provider;
import org.apache.dubbo.config.annotation.DubboService;
import demo.Service;
@DubboService
public class ServiceImpl implements Service {
@Override
public String sayHi(String name) {
return "hi, " + name;
}
}
@DubboServiceLa différence avec le développement basé sur l'API est qu'il y a une annotation supplémentaire sur la classe
L'annotation @DubboService est une annotation utilisée pour marquer les interfaces des fournisseurs de services. La fonction de cette annotation est de marquer une interface en tant que fournisseur de services Dubbo, afin que la classe d'implémentation de l'interface puisse être enregistrée et exposée par Dubbo en tant que service pouvant être appelé par d'autres services. La classe d'implémentation d'interface marquée par l'annotation @DubboService sera analysée par le framework Dubbo, et l'objet proxy d'interface de service correspondant sera automatiquement généré et enregistré dans le registre Dubbo pour que d'autres consommateurs de services puissent l'appeler. L'utilisation de cette annotation peut simplifier les étapes de publication et d'exposition des services Dubbo et améliorer l'efficacité du développement.
Créez ensuite une classe de démarrage SpringBoot ProviderApplicationavec le contenu suivant
@SpringBootApplication
@EnableDubbo
public class ProviderApplication {
public static void main(String[] args) {
SpringApplication.run(ProviderApplication.class, args);
}
}
Une annotation a été ajoutée @EnableDubbo. Après avoir essayé, il n'y a aucun problème sans cette annotation (mais il vaut mieux l'ajouter pour éviter d'autres problèmes)
Modifiez le fichier de configuration de SpringBoot, car le projet Maven que j'ai créé, vous devez créer une nouvelle application.properties ou application.yml sous src/main/resources
propriétés
dubbo.application.name=demo-provider
dubbo.protocol.name=dubbo
dubbo.protocol.port=-1
dubbo.registry.address=zookeeper://${zookeeper.address:127.0.0.1}:2181
yml
dubbo:
application:
name: dubbo-springboot-demo-provider
protocol:
name: dubbo
port: -1
registry:
address: zookeeper://${
zookeeper.address:127.0.0.1}:2181
De cette façon, le fournisseur de services fait du bon travail
consommateur de service (démo-consommateur)
demo-consumer est un module consommateur, créez un nouveau package demo.consumer et créez une classe de démarrage ConsumerApplication sous le package, le contenu est le suivant
package demo.consumer;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableDubbo
public class ConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerApplication.class, args);
}
}
Ici, vous devez écrire une interface Web, vous devez donc ajouter des dépendances Web dans pom.xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
Créez une nouvelle classe nommée TestControl avec le contenu suivant
package demo.consumer;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import demo.Service;
@RestController
public class TestControl {
@DubboReference
private Service service;
@GetMapping("/")
public String test(String name) {
return service.sayHi(name);
}
}
Une interface Web est définie ci-dessus, la route est /, l'interface reçoit un nom de paramètre, l'interface appellera la fonction sayHi du montant du service et le paramètre name est transmis.
Le service utilise ici @DubboReferencel'injection d'annotations, et appeler sayHi équivaut en fait à appeler sayHi de la classe d'implémentation de demo-provider
Je ne veux pas comprendre le principe ici, devinez juste un peu, selon ma pensée, il devrait être grosso modo que le fournisseur et le consommateur se connectent à zookeeper, le consommateur communique avec le fournisseur via zookeeper, et le consommateur utilise le objet injecté par @DubboReference. Supposons que RPC envoie des données au fournisseur. Par exemple, la classe est Service et la fonction est sayHi, puis envoyez un Service|sayHi. Après avoir reçu les données, le fournisseur trouvera la classe d'implémentation correspondante, et implémentez la fonction de la classe d'implémentation, puis exécutez les données renvoyées. , le reste concerne les détails, tels que les paramètres, etc. Bien sûr, j'utilise juste mes idées pour implémenter un tel framework ici, et fournir une idée simple. Pour connaître les détails, vous devez toujours regarder le code source, la documentation et le débogage
Le fichier de configuration SpringBoot est le même que le fournisseur, mais server.port est requis pour définir le port Web
De cette façon, le consommateur a également fait du bon travail
Obtenir un service non pas via des annotations, mais via le contexte
Étendons-le ici. Parfois, les annotations ne peuvent pas être utilisées pour injecter des objets. À ce stade, vous devez obtenir des objets fournisseur d'autres manières.
Obtenez le code comme suit
ReferenceConfig<Service> referenceConfig = new ReferenceConfig<>();
referenceConfig.setInterface(Service.class);
Service service = referenceConfig.get();
démarrer l'application
courir ProviderApplicationetConsumerApplication
Il convient de noter que le fournisseur doit être démarré avant de démarrer le consommateur, sinon le module consommateur signalera une erreur et entraînera l'arrêt de l'ensemble du programme. Ce problème est @DubboReferencecausé par des annotations. Par défaut, il vérifiera si le fournisseur correspondant est disponible au démarrage. Bien entendu, la vérification peut être annulée via la configuration ou autre.
Il existe plusieurs solutions
-
Ajoutez le paramètre check = false à l'annotation, par exemple
@DubboReference(check = false) -
Ajouter du contenu au fichier de configuration SpringBoot
-
les propriétés augmentent
dubbo.consumer.check=false -
augmentation de yml
-
dubbo: consumer: check: false
-
-
Ajoutez le code suivant dans la classe de démarrage ou la classe de configuration
-
@Bean public ConsumerConfig consumerConfig() { ConsumerConfig consumerConfig = new ConsumerConfig(); consumerConfig.setCheck(false); return consumerConfig; }
-
Après le démarrage, le service client explosera certaines erreurs, mais cela n'affecte pas, accédez à l'adresse via le navigateur, l'effet est le suivant
problème résolu
[DUBBO] qos-server can not bind localhost:22222, dubbo version: 3.2.0-beta.4, current host: 192.168.0.108, error code: 7-4. This may be caused by , go to https://dubbo.apache.org/faq/7/4 to find instructions.
java.net.BindException: Address already in use: bind
...
Fail to start qos server: , dubbo version: 3.2.0-beta.4, current host: 192.168.0.108, error code: 7-4. This may be caused by , go to https://dubbo.apache.org/faq/7/4 to find instructions.
java.net.BindException: Address already in use: bind
Cette erreur signifie que le port du service qos est occupé, car le serveur qos sera démarré automatiquement au démarrage avec Dubbo.Le port par défaut est 22222. J'ai démarré le fournisseur et le consommateur sur le même ordinateur ci-dessus, j'ai donc signalé cette erreur.
Le serveur QoS (Quality of Service) de Dubbo est un serveur indépendant, qui est utilisé pour fournir l'assurance qualité du service Dubbo et surveiller et gérer les indicateurs liés au service.
Il peut être résolu en modifiant le fichier de configuration SpringBoot
propriétés
# 是否启用,默认启用
dubbo.application.qosEnable=true
# 端口，默认22222
dubbo.application.qosPort=12345
dubbo.application.qosAcceptForeignIp=false
Jusqu'à présent, l'utilisation de base a été correcte
FIN