Praxis zur Entwicklung von Microservice-Fähigkeiten basierend auf Spring Cloud

Mit der rasanten Entwicklung von Cloud Computing und Big-Data-Technologie ändern sich auch die Architekturdesign- und Entwicklungsmethoden von Unternehmenssystemen ständig. Die Microservice-Architektur ist eine der wichtigsten Änderungen. Dabei handelt es sich um ein Architekturmodell, das eine einzelne Anwendung in eine Reihe kleiner Dienste aufteilt, die auf einem einfachen Kommunikationsmechanismus basieren, wodurch ein flexibleres, skalierbareres und wartbareres System entsteht .

Als eines der derzeit beliebtesten Microservice-Frameworks bietet Spring Cloud einen vollständigen Satz an Microservice-Entwicklungslösungen, einschließlich Microservice-Erkennung, Konfiguration, Kommunikation, Lastausgleich, Leistungsschalter, API-Gateways usw. In diesem Artikel werden die auf Spring Cloud basierende Praxis zur Entwicklung von Microservice-Fähigkeiten sowie einige in der Praxis auftretende Probleme und Lösungen vorgestellt.

1. Grundprinzipien der Microservice-Architektur

Microservice-Architektur ist ein Architekturmuster, das eine einzelne Anwendung in eine Reihe kleiner Dienste aufteilt, die auf einem einfachen Kommunikationsmechanismus basieren, um eine flexiblere, skalierbarere und wartbarere Lösung zu erreichen System. Zu den Grundprinzipien der Microservice-Architektur gehören:

1. Service-Aufteilung: Teilen Sie eine einzelne Anwendung in eine Reihe kleiner Services nach Geschäftsbereichen oder Funktionsmodulen auf, und jeder Service wird unabhängig ausgeführt und aktualisiert.

2. Dienstkommunikation: Dienste arbeiten auf der Grundlage einfacher Kommunikationsmechanismen zusammen, darunter RESTful API, Nachrichtenwarteschlange, RPC usw.

3. Service-Erkennung und -Registrierung: Service-Lebenszyklus-Management, einschließlich Service-Registrierung im Service-Registrierungscenter, Service-Erkennung und Lastausgleich usw.

4. Datenpartitionierung: Teilen Sie Daten durch Datenpartitionierung in verschiedene Dienste auf, um die Datenisolation zwischen Diensten sicherzustellen.

5. Automatisierter Betrieb und Wartung: Realisieren Sie die automatische Bereitstellung, Überwachung und Wartung von Diensten durch automatisierte Tools und verbessern Sie so die Zuverlässigkeit und Wartbarkeit des Systems.

2. Spring Cloud Microservice Framework

Spring Cloud ist ein Microservice-Framework, das auf Spring Boot basiert und einen vollständigen Satz von Microservice-Entwicklungslösungen bietet. Spring Cloud umfasst die folgenden Kernkomponenten:

1. Diensterkennung und -registrierung: Eureka, Consul, Zookeeper usw.

2. Client-Lastausgleich: Multifunktionsleiste.

3. Leistungsschalter: Hystrix.

4. Service-Gateway: Zuul2.

5. Verteiltes Konfigurationscenter: Spring Cloud Config.

6. Nachrichtenbus: Spring Cloud Bus.

3. Spring Cloud-Microservice-Entwicklungspraxis

Im Folgenden wird eine einfache Microservice-Anwendung als Beispiel verwendet, um die auf Spring Cloud basierende Microservice-Entwicklungspraxis vorzustellen.

1. Erstellen Sie ein Eureka-Registrierungszentrum.

Erstellen Sie zunächst ein Eureka-Registrierungszentrum, um die Serviceerkennung und -registrierung über Eureka zu realisieren.

In das Spring Boot-Projekt integrieren Sie Eureka, indem Sie die folgenden Abhängigkeiten hinzufügen:

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

Fügen Sie die Annotation @EnableEurekaServer in der Startup-Klasse hinzu:

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

Nach dem Starten des Eureka-Registrierungscenters können Sie auf http://localhost:8761 zugreifen Im Browser können Sie die Verwaltungsoberfläche des Registrierungscenters sehen.

2. Erstellen Sie einen Dienstanbieter.

Erstellen Sie einen einfachen Dienstanbieter, der eine Hallo-Schnittstelle zur Rückgabe einer Zeichenfolge bereitstellt.

Integrieren Sie im Spring Boot-Projekt Eureka und Ribbon, indem Sie die folgenden Abhängigkeiten hinzufügen:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

Aktivieren Sie im Dienstanbieter den Eureka-Client, indem Sie die Annotation @EnableDiscoveryClient hinzufügen:

@SpringBootApplication
@EnableDiscoveryClient
public class ServiceProviderApplication {
   public static void main(String[] args) {
      SpringApplication.run(ServiceProviderApplication.class, args);
   }
}

Erstellen Sie einen RestController, um die Hallo-Schnittstelle bereitzustellen:

@RestController
public class HelloController {
   @RequestMapping("/hello")
   public String hello() {
      return "Hello World!";
   }
}

3. Erstellen Sie einen Service-Consumer

Erstellen Sie einen Service-Consumer, rufen Sie die vom Service-Provider bereitgestellte Schnittstelle auf und erreichen Sie den Lastausgleich über Ribbon.

Integrieren Sie im Spring Boot-Projekt Eureka und Ribbon, indem Sie die folgenden Abhängigkeiten hinzufügen:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

Aktivieren Sie im Service-Consumer den Eureka-Client, indem Sie die Annotation @EnableDiscoveryClient hinzufügen, und aktivieren Sie den Lastausgleich des Ribbon-Clients, indem Sie die Annotation @LoadBalanced hinzufügen :

@SpringBootApplication
@EnableDiscoveryClient
public class ServiceConsumerApplication {
   public static void main(String[] args) {
      SpringApplication.run(ServiceConsumerApplication.class, args);
   }
 
   @Bean
   @LoadBalanced
   public RestTemplate restTemplate() {
      return new RestTemplate();
   }
}

Erstellen Sie einen RestController, um die Hallo-Schnittstelle des Dienstanbieters aufzurufen:

@RestController
public class HelloController {
   @Autowired
   private RestTemplate restTemplate;
 
   @RequestMapping("/hello")
   public String hello() {
      String url = "http://service-provider/hello";
      return restTemplate.getForObject(url, String.class);
   }
}

4. Erstellen Sie ein Service-Gateway.

Erstellen Sie ein Service-Gateway, um alle Microservice-Schnittstellen nach außen zugänglich zu machen und die Routenweiterleitung und -filterung über Zuul zu implementieren.

Integrieren Sie im Spring Boot-Projekt Eureka und Zuul, indem Sie die folgenden Abhängigkeiten hinzufügen:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

Aktivieren Sie Zuul im Service-Gateway, indem Sie die Annotation @EnableZuulProxy hinzufügen:

@SpringBootApplication
@EnableZuulProxy
public class ApiGatewayApplication {
   public static void main(String[] args) {
      SpringApplication.run(ApiGatewayApplication.class, args);
   }
}

Konfigurieren Sie die Gateway-Routing-Informationen und fügen Sie Folgendes in application.yml hinzu Konfiguration:

zuul:
  routes:
    service-provider:
      path: /api/**
      serviceId: service-provider

5. Erstellen Sie ein Konfigurationscenter

Erstellen Sie ein Konfigurationscenter, um die Konfiguration über das Git-Warehouse zu verwalten und eine zentrale Verwaltung und dynamische Aktualisierung der Konfiguration zu erreichen.

In das Spring Boot-Projekt integrieren Sie den Konfigurationsserver, indem Sie die folgenden Abhängigkeiten hinzufügen:

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

Aktivieren Sie im Konfigurationscenter das Konfigurationscenter, indem Sie die Annotation @EnableConfigServer hinzufügen:

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConfigServerApplication.class, args);
   }
}

Konfigurieren Sie Git-Warehouse-Informationen und lesen Sie application.yml ein Regeln:

spring:
  cloud:
    config:
      server:
        git:
          uri: git://http://gitlab.example.com/abc/config-repo.git
          search-paths: '{application}'
  profiles:
    active: native
  paths:
    config.path: /usr/local/config-repo

6. Implementieren Sie einen Leistungsschalter für den Dienst. Erstellen Sie einen Leistungsschalter, um Verschlechterungsvorgänge zu bewältigen, wenn der Dienst abnormal oder fehlerhaft ist.

Integieren Sie Hystrix im Spring Boot-Projekt, indem Sie die folgenden Abhängigkeiten hinzufügen:

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

Im Dienstanbieter implementieren Sie den Leistungsschalter, indem Sie die Annotation @HystrixCommand hinzufügen:

@RestController
public class HelloController {
   @RequestMapping("/hello")
   @HystrixCommand(fallbackMethod = "fallback")
   public String hello() {
      ...
   }
 
   public String fallback() {
      return "Fallback";
   }
}

7. Implementieren Sie die Dienstüberwachung

Erstellen Sie ein Überwachungszentrum. Wird zur Überwachung und Datenanalyse der von Microservices bereitgestellten Schnittstellen verwendet, um eine Echtzeitüberwachung des Servicestatus zu erreichen.

Integieren Sie im Spring Boot-Projekt Hystrix Dashboard und Turbine, indem Sie die folgenden Abhängigkeiten hinzufügen:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-turbine</artifactId>
</dependency>

在监控中心中，通过添加@EnableHystrixDashboard注解来启用Hystrix Dashboard：

@SpringBootApplication
@EnableHystrixDashboard
public class MonitorCenterApplication {
   public static void main(String[] args) {
      SpringApplication.run(MonitorCenterApplication.class, args);
   }
}

在turbine服务提供者中，通过添加@EnableTurbine注解来启用Turbine：

@SpringBootApplication
@EnableTurbine
public class TurbineServerApplication {
   public static void main(String[] args) {
      SpringApplication.run(TurbineServerApplication.class, args);
   }
}

在application.yml中配置Turbine的信息：

turbine:
  aggregator:
    clusterConfig: service-consumer
  appConfig: service-consumer,service-provider
  clusterNameExpression: new String("default")

四、总结

Spring Cloud是一套完备的微服务开发解决方案，通过其提供的一系列组件和架构设计原则，开发者可以轻松构建出高可用、高扩展和易维护的微服务应用。在实践中，我们发现Spring Cloud不但提供了完备的技术支持，同时还提供了很好的学习资源和社区支持，为微服务的发展贡献了不少力量。但是，在实践中也会遇到不少问题和挑战，包括配置管理、调用链跟踪、数据一致性等方面，需要我们不断地进行探索和实践，以解决这些难题。

Das obige ist der detaillierte Inhalt vonPraxis zur Entwicklung von Microservice-Fähigkeiten basierend auf Spring Cloud. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!