Die elegante Microservice-Praxis von Spring Cloud

Mit der Entwicklung des Internets wird die Microservice-Architektur bei Internetunternehmen immer beliebter. Spring Cloud bietet eine vollständige Microservice-Lösung basierend auf Spring Boot. In diesem Artikel wird erläutert, wie Sie das Spring Cloud-Framework zum Üben von Microservices verwenden.

1. Überblick über die Microservice-Architektur

Die sogenannte Microservice-Architektur besteht darin, die Anwendung in einige kleinere, autonome Serviceeinheiten aufzuteilen, die über einfache Kommunikationsmechanismen zusammenarbeiten, und jeder Service kann unabhängig erstellt, bereitgestellt, getestet und skaliert werden . Der Vorteil der Microservice-Architektur besteht darin, dass sie die Produktivität des Teams sowie die Elastizität und Skalierbarkeit des Systems verbessern kann.

2. Spring Cloud Microservice-Framework

Spring Cloud ist die Microservice-Lösung der Spring-Familie. Es bietet ein vollständiges und umfangreiches Toolkit basierend auf Spring Boot. Spring Cloud verwendet mehrere Komponenten (wie Eureka, Zuul, Hystrix usw.), um eine vollständige Microservice-Umgebung aufzubauen. Im Folgenden sind die Hauptkomponenten von Spring Cloud aufgeführt:

1. Implementiert die Serviceregistrierung und -erkennung und stellt ein Serviceregistrierungscenter bereit.
2. Implementiert die Kommunikation zwischen Diensten und vereinfacht RESTful-Aufrufe , Downgrade und andere Funktionen, die die Robustheit des Systems verbessern;
4: Bietet API-Gateway-Dienste, um einen einheitlichen Zugriffseingang und Lastausgleich zu erreichen;
5.

3. Spring Cloud Microservice-Praxis

Das Folgende ist ein einfaches Beispiel, um zu demonstrieren, wie das Spring Cloud-Framework zum Erstellen von Microservices verwendet wird. Dieses Beispiel enthält zwei Dienste: einen Benutzerdienst und einen Bestelldienst. Der Benutzerdienst stellt CRUD-Operationen für Benutzerinformationen bereit, und der Bestelldienst muss den Benutzerdienst aufrufen, um Benutzerinformationen zu erhalten.

1. Erstellen Sie ein Service-Registrierungscenter

Zuerst erstellen wir ein Service-Registrierungscenter zum Registrieren und Entdecken von Diensten. Erstellen Sie ein Spring Boot-Projekt, um die Serviceregistrierung und -erkennung über die Eureka-Komponente von Spring Cloud zu implementieren.

Abhängigkeiten hinzufügen:

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

Fügen Sie die Annotation @EnableEurekaServer zur Startup-Klasse hinzu.

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

Konfigurieren Sie in der Konfigurationsdatei application.properties die relevanten Informationen von Eureka Server.

2. Erstellen Sie einen Benutzerdienst

Erstellen Sie einen Benutzerdienst, um CRUD-Operationen für Benutzerinformationen bereitzustellen. Erstellen Sie ein Spring Boot-Projekt, um die Kommunikation zwischen Diensten über die Feign-Komponente von Spring Cloud zu implementieren.

Abhängigkeiten hinzufügen:

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

Fügen Sie die Annotation @EnableFeignClients zur Startup-Klasse hinzu.

@SpringBootApplication
@EnableFeignClients
public class UserServiceApplication {

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

Erstellen Sie die UserService-Schnittstelle und definieren Sie CRUD-Operationen für Benutzerinformationen. Verwenden Sie die Annotation @FeignClient, um den aufzurufenden Dienst anzugeben. In dieser Schnittstelle wird ein Aufruf von OrderService definiert.

@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);
}

Konfigurieren Sie in der Konfigurationsdatei application.properties die Eureka-bezogenen Informationen und das Feign-Timeout.

3. Erstellen Sie einen Bestellservice

Erstellen Sie einen Bestellservice, um Bestellinformationen zu verarbeiten. Erstellen Sie ein Spring Boot-Projekt und verwenden Sie die Ribbon- und Feign-Komponenten von Spring Cloud, um Benutzerdienste aufzurufen und einen Lastausgleich zwischen Diensten zu erreichen.

Abhängigkeiten hinzufügen:

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


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

Fügen Sie @EnableFeignClients- und @EnableDiscoveryClient-Annotationen zur Startup-Klasse hinzu.

@SpringBootApplication
@EnableFeignClients
@EnableDiscoveryClient
public class OrderServiceApplication {

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

Erstellen Sie die OrderService-Schnittstelle und definieren Sie CRUD-Operationen für Bestellinformationen. In dieser Schnittstelle wird ein Aufruf von UserService definiert.

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);
}

In der Implementierungsklasse verwenden Sie @Autowired, um die UserService-Schnittstelle einzufügen.

@Service
public class OrderServiceImpl implements OrderService {

  @Autowired
  private UserService userService;

  // ...
}

Konfigurieren Sie in der Konfigurationsdatei application.properties Eureka-bezogene Informationen und die Lastausgleichsmethode von Ribbon.

IV. Zusammenfassung

Dieser Artikel stellt vor, wie man eine Umgebung basierend auf der Microservice-Architektur mithilfe des Spring Cloud-Frameworks erstellt, und zeigt anhand eines einfachen Beispiels, wie Dienstregistrierung und -erkennung, Kommunikation zwischen Diensten, Lastausgleich und andere Funktionen implementiert werden . Dies ist natürlich nur ein einfacher Ausgangspunkt, und in der praktischen Anwendung müssen weitere Szenarien und Probleme berücksichtigt werden. Nur durch tieferes Lernen und Üben kann die Zuverlässigkeit und Skalierbarkeit des Systems besser verbessert werden.

Das obige ist der detaillierte Inhalt vonDie elegante Microservice-Praxis von Spring Cloud. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!