Depuis l'open source de spring-cloud-alibaba, l'enregistrement et la découverte de services utilisant nacos dans springcloud sont devenus très faciles, il suffit d'introduire "spring-cloud-starter-alibaba-nacos-discovery", puis d'ouvrir @EnableDiscoveryClient peut remplacer de manière transparente les registres tels que eureka et consul.
Ce qui suit montre comment utiliser nacos dans springcloud en donnant un cas simple.
principe nacos-discovery-stater
Voyons d'abord le principe d'enregistrement et de découverte de service dans nacos dans springcloud.
enregistrement des services
spring-cloud-starter-alibaba-nacos-discovery suit la norme spring-cloud-common et implémente les trois interfaces AutoServiceRegistration, ServiceRegistry et Registration.
Dans la phase de démarrage de l'application springcloud, l'événement WebServerInitializedEvent est surveillé. Lorsque le conteneur Web est initialisé, c'est-à-dire après avoir reçu l'événement WebServerInitializedEvent, l'action d'enregistrement sera déclenchée et la méthode register de ServiceRegistry sera appelée pour s'enregistrer. le service au serveur Nacos.
découverte de services
NacosServerList implémente l'interface com.netflix.loadbalancer.ServerList et effectue l'injection automatique sous la condition de @ConditionOnMissingBean, et intègre le ruban par défaut.
Si vous en avez besoin d'une plus personnalisée, vous pouvez utiliser @Autowired pour injecter une instance NacosRegistration et appeler directement l'API Nacos via le contenu du champ NamingService qu'elle contient.
nacos-service-prestataire
Créez un projet springcloud de fournisseur de services et introduisez les dépendances suivantes :
<properties>
<spring-cloud.version>Greenwich.SR1</spring-cloud.version>
<spring-cloud.alibaba.version>0.2.1.RELEASE</spring-cloud.alibaba.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>${spring-cloud.alibaba.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
Configurez les informations de configuration liées à nacos dans le fichier application.yml du projet comme suit :
Si vous ne souhaitez pas utiliser Nacos comme enregistrement et découverte de service, vous pouvez définir spring.cloud.nacos.discovery sur false.
spring:
application:
name: nacos-service-provider
cloud:
nacos:
discovery:
register-enabled: true
server-addr: 127.0.0.1:8848
weight: 1
namespace: dev
management:
endpoints:
web:
exposure:
include: "*"
server:
port: 8080
L'étape suivante consiste à créer un service à utiliser par l'appelant. N'oubliez pas d'introduire l'annotation @EnableDiscoveryClient dans la fonction principale.
package com.lazycece.scac.nacos.discovery.provider.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author lazycece
* @date 2019/03/19
*/
@RestController
@RequestMapping("/nacos")
public class NacosProviderController {
@GetMapping("/provider/{name}")
public String provider(@PathVariable String name) {
return "hello," + name;
}
}
nacos-service-consommateur
Créez un projet springcloud pour les consommateurs de services et introduisez les dépendances suivantes. Ici, les dépendances d'open-feign et de ruban sont introduites pour démontrer la consommation de ces deux méthodes en même temps.
<properties>
<spring-cloud.version>Greenwich.SR1</spring-cloud.version>
<spring-cloud.alibaba.version>0.2.1.RELEASE</spring-cloud.alibaba.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>${spring-cloud.alibaba.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
</dependencies>
Configurez les informations de configuration liées à nacos dans le fichier application.yml du projet comme suit :
Si vous ne souhaitez pas utiliser Nacos pour l'enregistrement et la découverte de votre service, vous pouvez définir spring.cloud.nacos.discovery sur false.
spring:
application:
name: nacos-service-consumer
cloud:
nacos:
discovery:
register-enabled: true
server-addr: 127.0.0.1:8848
weight: 1
namespace: dev
management:
endpoints:
web:
exposure:
include: "*"
server:
port: 8081
Le code pour créer le consommateur de service est le suivant, n'oubliez pas d'introduire l'annotation @EnableDiscoveryClient dans la fonction main.
package com.lazycece.scac.nacos.discovery.consumer.controller;
import com.lazycece.scac.nacos.discovery.consumer.api.FeignConsumerApi;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
/**
* @author lazycece
* @date 2019/03/19
*/
@RestController
@RequestMapping("/nacos/consumer")
public class NacosConsumerController {
private LoadBalancerClient loadBalancerClient;
private RestTemplate restTemplate;
private FeignConsumerApi feignConsumerApi;
@Autowired
public NacosConsumerController(LoadBalancerClient loadBalancerClient, RestTemplate restTemplate,
FeignConsumerApi feignConsumerApi) {
this.loadBalancerClient = loadBalancerClient;
this.restTemplate = restTemplate;
this.feignConsumerApi = feignConsumerApi;
}
@GetMapping("/rest/{name}")
public String rest(@PathVariable String name) {
ServiceInstance serviceInstance = loadBalancerClient.choose("nacos-service-provider");
String url = String.format("http://%s:%s/nacos/provider/%s",
serviceInstance.getHost(), serviceInstance.getPort(), name);
System.out.println("url -> " + url);
return restTemplate.getForObject(url, String.class);
}
@GetMapping("/feign/{name}")
public String feign(@PathVariable String name) {
return feignConsumerApi.provider(name);
}
@GetMapping("/ribbon/{name}")
public String ribbon(@PathVariable String name) {
return restTemplate.getForObject("http://nacos-service-provider/nacos/provider/" +
name, String.class);
}
}
Pour consommer en mode repos, vous devez injecter RestTemplate. Si vous devez utiliser le ruban pour l'équilibrage de charge, vous pouvez l'annoter avec @LoadBalanced, sinon vous ne pouvez pas l'ajouter.
package com.lazycece.scac.nacos.discovery.consumer.config;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
/**
* @author lazycece
* @date 2019/03/19
*/
@Configuration
public class RestTemplateConfig {
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}
}
Pour consommer en mode factice, vous avez besoin d'un client factice, comme suit, et la fonction principale du projet doit également introduire l'
annotation @EnableFeignClients.
package com.lazycece.scac.nacos.discovery.consumer.api;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* @author lazycece
* @date 2019/03/19
*/
@FeignClient("nacos-service-provider")
@RequestMapping("/nacos")
public interface FeignConsumerApi {
@GetMapping("/provider/{name}")
String provider(@PathVariable String name);
}
Enregistrement du service et vérification des cas de découverte
Vous devez d'abord démarrer le service nacos-server. Pour l'installation et le déploiement, voir installation et déploiement de nacos .
Point de terminaison de service
spring-cloud-starter-alibaba-nacos-discovery fournit un EndPoint lorsqu'il est implémenté, et l'adresse d'accès de EndPoint est http://ip:port/actuator/nacos-discovery. Comme nous avons ajouté la dépendance spring-boot-starter-actuator, nous pouvons afficher les informations sur le point de terminaison. Il existe deux principaux types d'informations EndPoint :
- subscribe : affiche les abonnés au service actuellement
- NacosDiscoveryProperties : affiche la configuration de base de l'instance de service actuelle à propos de Nacos
Les informations pour l'une des instances de service accédant au EndPoint sont les suivantes :
{
"subscribe":[
],
"NacosDiscoveryProperties":{
"serverAddr":"127.0.0.1:8848",
"endpoint":"",
"namespace":"dev",
"logName":"",
"service":"nacos-service-provider",
"weight":1,
"clusterName":"DEFAULT",
"namingLoadCacheAtStart":"false",
"metadata":{
},
"registerEnabled":true,
"ip":"192.168.3.8",
"networkInterface":"",
"port":8080,
"secure":false,
"accessKey":"",
"secretKey":""
}
}
interface de tubes nacos
Visitez http://localhost:8848/nacos/ pour entrer dans l'interface de gestion de nacos, vérifiez le module Service Management->Service List, vous pouvez voir que nos consommateurs et fournisseurs de services ont été enregistrés auprès de nacos, comme indiqué dans la figure suivante :
consommation de services
Ici, vous devez d'abord démarrer le service nacos, puis démarrer les deux services ci-dessus et visiter l'adresse suivante :
http://localhost:8081/nacos/consumer/rest/lazycece
http://localhost:8081/nacos/consumer/ ruban/lazycece
http: //localhost:8081/nacos/consumer/feign/lazycece
Informations de sortie : bonjour, lazycece
Plus d'informations sur les nacos de springcloud
D'autres informations de configuration sur spring-cloud-starter-alibaba-nacos-discovery sont présentées dans la figure suivante :
Code source du cas
Adresse source du cas :
https://github.com/lazycece/springcloud-actual-combat/tree/master/springcloud-ac-alibaba/springcloud-ac-alibaba-nacos-discovery