Java >> Java Tutorial >  >> Tag >> Spring

Spring Cloud-Tutorial für Anfänger

Spring

Was ist SpringCloud? In diesem Beitrag werde ich das Spring Cloud Tutorial für Anfänger behandeln. Wenn Sie Spring Framework noch nicht kennen, empfehle ich Ihnen, mit Spring Boot und Microservices und Simplifying Spring Security zu beginnen.

Wie die offizielle Dokumentation auf der Spring-Website sagt:

„Spring Cloud bietet Entwicklern Tools zum schnellen Erstellen gemeinsamer Muster in verteilten Systemen – Konfigurationsmanagement, Diensterkennung, Schaltkreisunterbrecher, intelligentes Routing, Microproxy, Steuerbus, einmalige Token ”

  • Was ist Spring Cloud?
  • Spring Cloud-Funktionen
  • Spring Cloud-Beispiel in Aktion
  • Schlussfolgerung

Was ist Spring Cloud?

Spring Cloud bietet vorgefertigte Muster zur Entwicklung verteilter Systemanwendungen. Die meisten dieser Muster sind beim Erstellen solcher Anwendungen üblich.

Ein Beispiel ist, wenn mehrere Microservices vorhanden sind und diese miteinander interagieren. Sie müssen jeden Dienst sichern. Jeder Dienst kommuniziert sicher mit anderen Diensten. Wie können diese Dienste von nun an gesichert werden? Wie kommunizieren sie sicher? Und wie werden sie nahtlos bereitgestellt? Welche anderen Automatisierungsaufgaben werden für unterschiedliche Anforderungen verwendet?

Mit Spring Cloud kann ein Entwickler schnell eine Anwendung erstellen, die diese Entwurfsmuster implementiert, und die Anwendung auf Cloud-Plattformen (wie Heroku oder Cloud Foundry) bereitstellen.

Spring Cloud-Funktionen

Das Spring-Framework ist grundlegend für die Erstellung einer Spring Cloud-Anwendung. Was sind also die verschiedenen Funktionen, die Spring Cloud hinzugefügt hat?

Dienstregistrierung und -suche

Spring Boot wurde mit der Microservice-Architektur populär. Wenn Sie mehrere Dienste haben, die miteinander interagieren, benötigen Sie einen Dienst, um jeden Dienst zu registrieren, dies ist meistens der Konfigurationsdienst. Dann brauchen Sie einen Suchdienst, um andere Dienste zu finden.

Verteilen von Nachrichten

Grundsätzlich bietet Spring Cloud verschiedene Tools, um unsere Microservice-basierte Architektur erfolgreich zu machen. Spring Boot unterstützt die schnelle Entwicklung dieser Anwendungen. Spring Cloud hilft bei der Koordinierung und Bereitstellung dieser Anwendungen. Eine solche Funktion von Spring Cloud ist das verteilte Messaging.

Microservices kommunizieren synchron oder asynchron. Insgesamt bietet Spring Cloud Bus einen Message Broker, der Knoten eines verteilten Systems verbindet. Ebenso bietet Spring Cloud Stream ein Framework zum Erstellen ereignisgesteuerter Microservices. Dennoch funktioniert diese Funktion gut mit Messaging-Diensten wie Kafka oder ActiveMQ.

Service-to-Service-Kommunikation

Spring Cloud bietet eine Funktion für die Service-zu-Service-Kommunikation. Normalerweise läuft der Ablauf so ab

  • Dienst registrieren
  • Rufen Sie die Registrierung ab
  • Finden Sie den Ziel-Downstream-Dienst
  • Rufen Sie den REST-Endpunkt dieses Dienstes auf

Verteilte Konfiguration

Insbesondere der Spring Cloud-Konfigurationsserver ermöglicht eine externe Konfiguration auf der Client-Seite für die verteilten Systeme.

Abgesehen von diesen Funktionen bietet Spring Cloud Tools zum Erstellen belastbarer und robuster Dienste. Ein solches Werkzeug sind Trennschalter.

Zur Veranschaulichung erstellen wir zwei Microservices und ein Microservice ruft einen anderen auf. Wir werden die Funktion des Registrierungsdienstes (von Spring Cloud) verwenden, um diese Mikrodienste zu registrieren.

Spring Cloud-Beispiel in Aktion

Eureka-Server für Registrierungsdienst erstellen

Zunächst erstellen wir einen Dienst, der den Eureka-Dienst verwendet und als Registrierungsdienst fungiert. Fügen Sie als Ergebnis die folgende Abhängigkeit in einer neuen Spring Boot-Anwendung hinzu:

plugins {
	id 'org.springframework.boot' version '2.5.5'
	id 'io.spring.dependency-management' version '1.0.11.RELEASE'
	id 'java'
}

group = 'com.betterjavacode'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
	mavenCentral()
}

ext {
	set('springCloudVersion', "2020.0.4")
}

dependencies {
	implementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-server'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

dependencyManagement {
	imports {
		mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
	}
}

test {
	useJUnitPlatform()
}

Sobald wir diese Abhängigkeit haben, können wir den Eureka-Server in unserer Hauptklasse aktivieren.

package com.betterjavacode.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaserverApplication {

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

}

Fügen Sie application.yml die folgenden Eigenschaften hinzu 

server:
  port: 7000

# Discovery Server Access
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
  serviceUrl:
    defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

Die Eigenschaften eureka.instance.client.register-with-eureka=false und eureka.instance.client.fetch-registry=false gibt an, dass dies ein Registrierungsserver ist und sich nicht selbst zur Registrierung verwendet.

Ein Microservice zur Rücksendung von Produkten

Um zu zeigen, wie wir den Registrierungsdienst als Teil der gesamten Spring Cloud-Integration verwenden werden, werden wir einen neuen Microservice erstellen. Dieser REST-basierte Microservice gibt eine Liste von Produkten zurück.

plugins {
	id 'org.springframework.boot' version '2.5.5'
	id 'io.spring.dependency-management' version '1.0.11.RELEASE'
	id 'java'
}

group = 'com.betterjavacode'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
	mavenCentral()
}

ext {
	set('springCloudVersion', "2020.0.4")
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-web'
	implementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

dependencyManagement {
	imports {
		mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
	}
}

test {
	useJUnitPlatform()
}

Vor diesem Hintergrund sieht RESTController für diesen Dienst wie folgt aus:

package com.betterjavacode.productservice.controllers;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

@RestController
public class ProductController
{
    @GetMapping("/products")
    public List getAllProducts ()
    {
        List products = new ArrayList<>();
        products.add("Shampoo");
        products.add("Soap");
        products.add("Cleaning Supplies");
        products.add("Dishes");

        return products;
    }
}

Und die application.yml-Datei für diese Anwendung sieht so aus

spring:
  application:
    name: product-service

server:
  port: 8083

eureka:
  client:
    registerWithEureka: true
    fetchRegistry: true
    serviceUrl:
      defaultZone: http://localhost:7000/eureka/
  instance:
    hostname: localhost

Hier haben wir eureka.client.registerWithEureka=true und eureka.client.fetchRegistry=true da wir möchten, dass unser Dienst bei unserem Eureka-Server registriert wird, auf dem der Registrierungsdienst ausgeführt wird. Anschließend wird unsere Hauptklasse für diesen Dienst eine Anmerkung @EnableDiscoveryClient haben Dadurch kann dieser Dienst von Eureka Server erkannt werden.

Kundendienst zum Anrufen des Produktdienstes

Lassen Sie uns nun einen weiteren Service erstellen, der ein Client-Service für den Produktservice sein wird. Es wird Product Service sehr ähnlich sein, außer dass es auf MVC basiert, also verwenden wir eine Thymeleaf-Vorlage, um diesen Service aufzurufen.

package com.betterjavacode.productserviceclient.controllers;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@Controller
public class ProductController
{
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("/")
    public String home(Model model)
    {
        List serviceInstances = discoveryClient.getInstances("product" +
                "-service");

        if(serviceInstances != null && !serviceInstances.isEmpty())
        {
            ServiceInstance serviceInstance = serviceInstances.get(0);
            String url = serviceInstance.getUri().toString();
            url = url + "/products";
            RestTemplate restTemplate = new RestTemplate();
            List products = restTemplate.getForObject(url, List.class);
            model.addAttribute("products", products);
        }

        return "home";
    }
}

application.yml für diesen Dienst sieht wie folgt aus:


spring:
  application:
    name: product-service-client

server:
  port: 8084


eureka:
  client:
    registerWithEureka: true
    fetchRegistry: true
    serviceUrl:
      defaultZone: http://localhost:7000/eureka/
  instance:
    hostname: localhost

Die Thymeleaf-Vorlage für Zuhause listet die Produkte grundsätzlich in Tabellenform auf.

Führen Sie die Dienste aus

Führen Sie in Kürze alle Dienste aus – beginnend mit Eureka-Server, Produktservice und Produkt-Service-Client. Wenn wir nun auf den Eureka-Server zugreifen, sehen wir die Liste der bei ihm registrierten Dienste wie folgt:

Sie können sehen, dass beide Dienste registriert sind. Und wenn wir unter http://localhost:8084/ auf unsere Produkt-Service-Client-Anwendung zugreifen , sehen wir die Liste der Produkte

Endlich haben wir eine einfache Demo zur Verwendung des Eureka-Servers als Registrierungsdienst mit Spring Cloud gesehen. Wenn Sie mehr über Spring Cloud Config erfahren möchten, empfehle ich Ihnen auf jeden Fall diesen Kurs Verteilte Konfiguration mit Spring Cloud Config von udemy.

Schlussfolgerung

In diesem Beitrag haben wir Spring Cloud kennengelernt. Es gibt eine Reihe von Funktionen, die in Spring Cloud evaluiert werden müssen. Ich habe nur eine Funktion behandelt, die die meisten Entwickler bei der Verwendung von Spring Cloud verwenden müssen. Ein Entwickler kann Spring Cloud Function auch mit AWS Lambda kombinieren, um mehr über Spring Cloud zu erfahren.

Wenn Sie immer noch etwas über Spring Security erfahren möchten, können Sie hier mein Buch buchen.

Hinweis – Links zu Udemy- oder Bildungskursen sind Affiliate-Links. Wenn Sie diese Kurse am Ende kaufen, erhalte ich einen Prozentsatz des Gesamtpreises. Ich empfehle auch nur solche Kurse, die ich selbst zu diesem Thema besucht oder gelernt habe.


Java-Tag