Cette fois, je partage avec vous comment consommer des services. L'article précédent parle de l'utilisation de Feign pour la consommation, cet article utilise les services de consommation REST + Ribbon et personnalise un simple composant de consommation par le biais du sondage. Le but de cet article est: l'idée de personnaliser les services de consommation; S'il y a des avantages, s'il vous plaît "comme":
REST + Ruban réalise les services à la consommation
En tant que consommateur de services, nous avons fait deux processus principaux pour distinguer 1) l'obtention de services et 2) des services d'appel. Alors, comment obtenir des services et comment appeler des services? Jetons un coup d'œil à un diagramme manuel ci-dessous:
On peut voir à partir du diagramme manuel que le consommateur obtient d'abord l'adresse d'interface réelle du fournisseur de services, puis appelle l'interface via l'adresse; Ensuite, pour l'architecture de microservice, il n'est certainement pas conseillé d'obtenir une certaine IP ou un port de classe, puis d'appeler l'interface, donc un concept de ServiceId a émergé dans le microservice; Le processus simple a été introduit, et ce qui suit est un exemple pour l'analyser; Ajoutez d'abord des dépendances telles que:
<dependency> <proupId> org.springframework.boot </proupId> <Artifactid> printemps-boot-starter-web </ artifactid> </peedency> <dependency> <proupId> org.springframework.cloud </prouprid> <ptifactid> printemps-Cloud-starter-eurek
Utilisons le Eureka_Server (Centre de service) et Eureka_Provider (fournisseur de services) construits dans l'article précédent pour effectuer des cas de test. Ici, je redéfinis le module Eureka_Consumer_Ribbon en tant que service de consommation; Créez d'abord la classe et le code de couche de service:
@ServicePublic Class UserService implémente userInterface {@Autowired Protected RestTemplate RestTemplate; @Override public morp <list <mouser>> getUsers (morq rq) {return null; } @Override public String getmsg () {String str = restTemplate.getForObject ("http: // eureka-provider / msg", string.class); retour STR; }}Utilisez principalement la fonction RestTemplate.getForObject de RestTemplate, puis vous devez définir un contrôleur pour répondre aux données obtenues sur la page. Pour plus de simplicité, utilisez simplement l'interface de service GetMSG pour tester:
@RestControllerPublic Class UserController {@Autowired Private UserService UserService; @Getmapping ("/ msg") String public getmsg () {return userservice.getmsg (); }}Enfin, nous ajoutons le code suivant à la classe de démarrage. Notez que la balise @loadBalanced doit être ajoutée, car la dépendance Eureka que nous avons introduite contient du ruban (version dalston.release). Le ruban résume l'algorithme d'équilibrage de charge. Si cette annotation n'est pas ajoutée, l'URL de la méthode de repos doit être le chemin d'url disponible. Bien sûr, si l'annotation est ajoutée ici, vous pouvez utiliser le serviced mentionné ci-dessus:
@ SpringbootApplication @veablediscoveryClient // Consumer Client Class public eurekaconsumerBbonApplication {@Bean @loadBalanced // Load Balancing RestTemplate RestTemplate () {return new RestTemplate (); } public static void main (String [] args) {SpringApplication.run (eurekaconsumerBbonApplication.class, args); }}Ce qui suit est l'effet affiché par le consommateur:
Rest + Poll Composants de consommation simples personnalisés
Le composant de consommation personnalisé est presque le même que le dessin manuel du visage. Il s'agit d'abord d'obtenir l'adresse d'interface réelle du fournisseur de services, puis d'appeler l'URL via le repos pour obtenir la sortie de résultat correspondante; Voici une classe de composants Shenniubanlance:
/ ** * Créé par Shenniu le 2018/6 * <p> * REST + Eureka + Client personnalisé * / @ ComponentPublic classe ShenniUbanlance {@Autowired private restrontlate RestTemplate; @Autowired Private DiscoveryClient DiscoveryClient; / ** * Service Real Adresse concurrenthashmap <"Nom de l'application de service", ("IP d'interface réelle", nombre de visites)> * / public static concurrenthashmap <string, list <moservice>> ServicesMap = new concurrentHashMap <> (); / ** * Définissez des informations sur les fournisseurs de services sur map * / public void setServicesMap () {// Obtenez tous les fournisseurs de services application list <string> appnames = découverteClient.getServices (); // Stockage La vraie adresse à mapper pour (String AppName: AppNames) {// Obtenez des informations d'une liste de fournisseurs de services <ferviceInstance> instanceInfos = DiscoveryClient.getInstances (appname); if (instanceInfos.iSempty ()) {continue; } List <moservice> Services = new ArrayList <> (); instanceInfos.ForEach (b -> {moservice Service = new Moservice (); // Nombre de service accessible.setwatch (0l); // Adresse de l'interface réelle Service.SetUrl (b.Getturi (). toString ()); Services.Add (service);}); // S'il y en a, mettez à jour ServicesMap.put (appname.tolowercase (), services); }} / ** * Service sélectionné en fonction de l'application * * @param appname * @return * / public moservice ChoiceServiceByAppName (String Appname) lève exception {appname = appname.tolowercase (); // Certains services de collecte de services d'applications <moservice> ServiceMap = ServicesMap.get (appname); if (ServiceMap == null) {// initialiser tous les services d'applications setServicesMap (); ServiceMap = ServicesMap.get (appname); if (ServiceMap == null) {lancez une nouvelle exception ("Échec de la recherche" + appname + "Services associés"); }} // Filtrez la méthode de sondage de service avec le plus petit nombre de visites Moservice Moservice = ServiceMap.Stream (). Min (comparateur.comPARING (MOSERVICE :: GetWatch)) .get (); // Enregistrement de chargement +1 moservice.setwatch (moservice.getwatch () + 1); retour moservice; } / ** * Rafraîchir automatiquement les informations du fournisseur de service pour mapper * / @scheduled (fixeDelay = 1000 * 10) public void refreshServicesMap () {setServicesMap (); } / ** * Obtenez le service de demande pour obtenir les données de retour * * @param appname Nom de l'application ApplicationName * @param ServiceName ServiceName * @Param MAP Demande Paramètre sur URL * @param tclass RETOUR TYPE * @param <T> * @return * / public <T> t GetServicedata (String AppName, tRun ServiceName, map <string,?> Map, map, map, map, map, t> t> {t ResultAly, map <string,?>? Essayez {// filtre pour obtenir le service réel Moservice Service = ChoiceServiceByAppName (appname); // demande l'URL de la chaîne de service apiUrl = service.getUrl () + "/" + ServiceName; System.out.println (APIURL); result = map! = null? restTemplate.getForObject (apiurl, tclass, map): restTemplate.getForObject (apiUrl, tclass); } catch (exception ex) {ex.printStackTrace (); } Retour Résultat; } / ** * Informations de service * / classe publique Moservice {/ ** * Nombre de disques de charge * / Long Watch privé; / ** * Adresse d'interface réelle: http://xxx.com/api/add * / URL de chaîne privée; public long getWatch () {return watch; } public void setwatch (longue montre) {this.watch = watch; } public String getUrl () {return url; } public void setUrl (string url) {this.url = url; }}}Ce qui précède est le code d'implémentation principal. Logique de code: définissez les informations du fournisseur de services sur map-》 Selon l'application pour obtenir la méthode d'interrogation, le service -》 demande au service d'obtenir les données de retour; Le principe de la mise en œuvre du sondage consiste à utiliser un numéro d'enregistrement de charge, qui a automatiquement +1 après chaque demande. Lorsque vous souhaitez obtenir un certain fournisseur de services, une instance de la valeur minimale est filtrée via le numéro d'enregistrement et l'URL de l'adresse d'interface réelle est stockée; L'appel doit seulement être comme ça (bien sûr, il peut être appelé comme annotations):
@Override public String getmsg () {string str = banlance.getServceData ("eureka-provider", "msg", null, string.class); retour STR; }Il convient de noter ici que nous avons ajouté l'annotation @loadBalanced dans le Rest -mplate précédent, de sorte que la demande de repos doit être accessible dans un non IP (c'est-à-dire ServiceID) pour répondre normalement, sinon une erreur sera invitée à:
Autrement dit, vous n'avez plus besoin d'utiliser IP car il existe un mécanisme d'équilibrage de charge; Lorsque nous supprimons cette annotation, nos composants personnalisés pourront s'exécuter avec succès et les rendus sont les mêmes que ceux de l'exemple 1, et la carte ne sera pas collée;
Actualiser les informations du fournisseur de services utilisant
Dans l'architecture de microservice, si un service est raccroché, les informations de cache de service du client doivent être mises à jour dans le temps, sinon elle peut demander à l'URL de baisse. Sur la base de cette considération, j'ai utilisé la balise Actived pour effectuer un rafraîchissement chronométré; Ajoutez d'abord @enablesCheDuling à la classe de démarrage, puis définissez un service qui clignote les informations de service telles que:
/ ** * Rafraîchissez automatiquement les informations du fournisseur de service pour mapper * / @scheduled (fixeDelay = 1000 * 10) public void refreshServicesMap () {setServicesMap (); }Afin de faciliter l'effet de test, lorsque le serveur, le fournisseur (2) et le consommateur ont été lancés, nous commençons un service de fournisseur avec Port 2005; Ensuite, actualisez l'interface du consommateur pour voir l'effet:
Pour le moment, vous pouvez voir que l'interface appelant le port de 2005 a été appelée avec succès. Une fois le service le plus récent ou non valide ajouté au service chronométré @Scheduled, il répondra aux besoins de ce dont vous avez besoin; Si vous pensez que ce contenu vous est utile, veuillez l'aimer, merci. J'espère que cela sera utile à l'apprentissage de tous, et j'espère que tout le monde soutiendra davantage Wulin.com.