La pratique élégante des microservices de Spring Cloud

Avec le développement d'Internet, l'architecture des microservices devient de plus en plus populaire parmi les sociétés Internet. Spring Cloud fournit une solution complète de microservices basée sur Spring Boot. Cet article explique comment utiliser le framework Spring Cloud pour mettre en pratique les microservices.

1. Présentation de l'architecture des microservices

L'architecture dite des microservices consiste à diviser l'application en plusieurs unités de service plus petites et autonomes. Les services fonctionnent ensemble via des mécanismes de communication légers, et chaque service peut être indépendant. Construire, déployer, tester et mettre à l'échelle. . L’avantage de l’architecture microservice est qu’elle peut améliorer la productivité de l’équipe ainsi que l’élasticité et l’évolutivité du système.

2. Framework de microservices Spring Cloud

Spring Cloud est la solution de microservices de la famille Spring. Il fournit une boîte à outils complète et riche basée sur Spring Boot. Spring Cloud utilise plusieurs composants (tels que Eureka, Zuul, Hystrix, etc.) pour créer un environnement de microservices complet. Voici les principaux composants de Spring Cloud :

1 : implémente l'enregistrement et la découverte des services, fournissant un centre d'enregistrement des services ;
2 : implémente la communication entre les services, simplifiant les appels RESTful ;
3. , rétrogradation et autres fonctions, ce qui améliore la robustesse du système ;
4. Zuul : fournit des services de passerelle API pour obtenir une entrée d'accès unifiée et un équilibrage de charge ;
5. Config : implémente la gestion de la configuration et fournit un centre de configuration distribué.

3. Spring Cloud Microservice Practice

Ce qui suit est un exemple simple pour montrer comment utiliser le framework Spring Cloud pour créer des microservices. Cet exemple contient deux services : un service utilisateur et un service de commande. Le service utilisateur fournit des opérations CRUD pour les informations utilisateur et le service de commande doit appeler le service utilisateur pour obtenir des informations utilisateur.

1. Créer un centre d'enregistrement de services

Tout d'abord, nous créons un centre d'enregistrement de services pour enregistrer et découvrir les services. Créez un projet Spring Boot pour implémenter l'enregistrement et la découverte de services via le composant Eureka de Spring Cloud.

Ajouter des dépendances :

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>

Ajoutez l'annotation @EnableEurekaServer sur la classe de démarrage.

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

Dans le fichier de configuration application.properties, configurez les informations pertinentes d'Eureka Server.

2. Créer un service utilisateur

Créez un service utilisateur pour fournir des opérations CRUD pour les informations utilisateur. Créez un projet Spring Boot pour implémenter la communication entre les services via le composant Feign de Spring Cloud.

Ajouter des dépendances :

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Ajoutez l'annotation @EnableFeignClients sur la classe de démarrage.

@SpringBootApplication
@EnableFeignClients
public class UserServiceApplication {

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

Créez l'interface UserService et définissez les opérations CRUD pour les informations utilisateur. Utilisez l'annotation @FeignClient pour spécifier le service à appeler. Dans cette interface, un appel à OrderService est défini.

@FeignClient(name = "order-service", fallback = OrderServiceFallback.class)
public interface OrderService {
  
  @GetMapping("/user/{userId}")
  UserDTO getUserById(@PathVariable("userId") Long userId);
  
  @PostMapping("/user")
  UserDTO createUser(@RequestBody UserDTO user);
  
  @PutMapping("/user")
  UserDTO updateUser(@RequestBody UserDTO user);
  
  @DeleteMapping("/user/{userId}")
  void deleteUser(@PathVariable("userId") Long userId);
}

Dans le fichier de configuration application.properties, configurez les informations relatives à Eureka et le délai d'attente Feign.

3. Créer un service de commande

Créez un service de commande pour traiter les informations de commande. Créez un projet Spring Boot et utilisez les composants Ribbon et Feign de Spring Cloud pour appeler les services utilisateur et réaliser un équilibrage de charge entre les services.

Ajouter des dépendances :

  org.springframework.cloud
  spring-cloud-starter-ribbon


<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Ajoutez les annotations @EnableFeignClients et @EnableDiscoveryClient sur la classe de démarrage.

@SpringBootApplication
@EnableFeignClients
@EnableDiscoveryClient
public class OrderServiceApplication {

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

Créez l'interface OrderService et définissez les opérations CRUD pour les informations de commande. Dans cette interface, un appel à UserService est défini.

public interface OrderService {

  @GetMapping("/order/{orderId}")
  OrderDTO getOrderById(@PathVariable("orderId") Long orderId);

  @PostMapping("/order")
  OrderDTO createOrder(@RequestBody OrderDTO order);

  @PutMapping("/order")
  OrderDTO updateOrder(@RequestBody OrderDTO order);

  @DeleteMapping("/order/{orderId}")
  void deleteOrder(@PathVariable("orderId") Long orderId);
}

Dans la classe d'implémentation, utilisez @Autowired pour injecter l'interface UserService.

@Service
public class OrderServiceImpl implements OrderService {

  @Autowired
  private UserService userService;

  // ...
}

Dans le fichier de configuration application.properties, configurez les informations relatives à Eureka et la méthode d'équilibrage de charge de Ribbon.

IV. Résumé

Cet article présente comment créer un environnement basé sur une architecture de microservices via le framework Spring Cloud et utilise un exemple simple pour démontrer comment implémenter l'enregistrement et la découverte de services, la communication interservices, l'équilibrage de charge et d'autres fonctions. . Bien entendu, il ne s’agit là que d’un simple point de départ, et d’autres scénarios et problèmes doivent être pris en compte dans des applications pratiques. Ce n’est que grâce à un apprentissage et une pratique plus approfondis que la fiabilité et l’évolutivité du système pourront être mieux améliorées.

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!