Was ist eine Frühlingswolke? Einführung in die Verwendung von Spring Cloud-javaLernprogramm-php.cn

Der Inhalt dieses Artikels handelt davon, was Frühlingswolke ist? Die Einführung in die Verwendung von Spring Cloud hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen.

1. Was ist Spring Cloud?

Spring bietet eine Reihe von Tools, mit denen Entwickler schnell gemeinsame Komponenten in verteilten Systemen erstellen können (z. B. Konfigurationsmanagement, Diensterkennung, Leistungsschalter, intelligentes Routing, Mikroagenten, Steuerbus). , einmaliges Token, globale Sperre, Masterknotenwahl, verteilte Sitzung, Clusterstatus). Koordinieren Sie verschiedene Systeme in einer verteilten Umgebung und stellen Sie Vorlagenkonfigurationen für verschiedene Dienste bereit. Mit Spring Cloud können Entwickler Anwendungen erstellen, die diese Vorlagen implementieren und in jeder verteilten Umgebung gut funktionieren, von Laptops bis hin zu Rechenzentren und Cloud-Plattformen.

Spring Cloud basiert auf Spring Boot und eignet sich am besten für die Verwaltung verschiedener von Spring Boot erstellter Microservice-Anwendungen. Um jeden Spring Boot-Mikrodienst in einer verteilten Umgebung verwalten zu können, muss ein Problem bei der Dienstregistrierung vorliegen. Beginnen wir also mit der Registrierung des Dienstes. Da es sich um eine Registrierung handelt, muss es einen Server geben, der das Registrierungscenter verwaltet. Jede Spring Boot-Anwendung unter Spring Cloud-Verwaltung ist der Client, der registriert werden muss.

Spring Cloud verwendet den Erureka-Server, und dann werden alle Anwendungen, die auf die Konfigurationsdatei zugreifen müssen, als Erureka-Client registriert. Eureka ist eine hochverfügbare Komponente. Nachdem jede Instanz registriert wurde, muss sie einen Heartbeat an das Registrierungszentrum senden. Standardmäßig ist der Erureka-Server auch ein Server .

1. Erstellen Sie einen Eureka-Server

Erstellen Sie zunächst ein Spring-Boot-Projekt

POM-Datei

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>me.cn</groupId>
    <artifactId>test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>test</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>10</java.version>
        <spring-cloud.version>Finchley.SR1</spring-cloud.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-impl</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>

    <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>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Nach dem Login kopieren

erfordert eine Anmerkung @EnableEurekaServer Hinzufügen Zur Startklasse des Springboot-Projekts

@EnableEurekaServer
@SpringBootApplication
public class TestApplication {

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

Nach dem Login kopieren

Konfigurationsdatei des Eureka-Servers application.yml

server:
  port: 8761

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

Nach dem Login kopieren

Starten Sie den Eureka-Server und besuchen Sie dann http://localhost:8761. Die Schnittstelle lautet wie folgt , „Keine Instanzen verfügbar“ bedeutet keine Client-Registrierung

2. Erstellen Sie eine Eureka-Client

POM-Datei

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.chry</groupId>
    <artifactId>test1</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test1</name>
    <packaging>jar</packaging>
    <description>Demo Spring Boot Client</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</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-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.RC1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>


</project>

Nach dem Login kopieren

Verwenden Sie zur Angabe die Annotation @EnableEurekaClient dass es sich um einen Client handelt

@SpringBootApplication
@EnableEurekaClient
@RestController
public class Test1Application {

    public static void main(String[] args) {
        SpringApplication.run(Test1Application.class, args);
    }
    @Value("${server.port}")
     String port;
     @RequestMapping("/")
     public String home() {
                 return "hello world from port " + port;    }

}

Nach dem Login kopieren

Konfiguration der yml-Datei

eureka:
     client:
         serviceUrl:
             defaultZone: http://localhost:8761/eureka/
server:
     port: 8762
spring:
     application:
         name: service-helloworld

Nach dem Login kopieren

Zuletzt den Client starten, dann können Sie die erfolgreiche Registrierung des Clients am Server-Port sehen

2. Konfigurationsverwaltung

Die Lösung von Spring Cloud besteht darin, diese Konfigurationsdateien auf dem Versionsverwaltungsserver abzulegen. Die Standardkonfiguration von Spring Cloud verwendet GIT. Alle Webdienste beziehen diese Konfigurationsdateien von GIT. Da kein gemeinsamer Speicher zwischen dem GIT-Server und dem jeweiligen Webserver erforderlich ist, kann der Webdienst vom Speicherort der Konfigurationsinformationen entkoppelt werden, solange das Netzwerk erreichbar ist.

2.1 Konfigurationsserver erstellen

Die POM-Datei hat eine neue Abhängigkeit

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

Nach dem Login kopieren

Die Annotation @EnableConfigServer beschreibt einen Konfigurationsserver. Ebenso verwenden wir @EnableEurekaClient, um es beim Servicecenter zu registrieren.

Config-Server-Konfigurationsdatei application.yml. Die URL der Konfigurationsdatei ist die Warehouse-Adresse des GIT-Servers. Es besteht keine Notwendigkeit Geben Sie den spezifischen Konfigurationsdateinamen auf der Serverseite an, da die spezifische Konfigurationsdatei von der Anwendung (d. h. dem Client) bestimmt wird.

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
server:
  port: 8888

spring:
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/ning9/CRUD.git
          searchPaths: spring-cloud/helloworldConfig
  application:
    name: config-server

Nach dem Login kopieren

Starten Sie den Konfigurationsserver und besuchen Sie http://localhost:8888/config-client-dev.properties, um den Inhalt der Konfigurationsdatei anzuzeigen

2.2 Erstellen Sie Konfigurationsclient

Startdatei

 @SpringBootApplication
 @RestController
 public class ConfigClientApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(ConfigClientApplication.class, args);
     }
 
     @Value("${hello}")
     String hello;
     @RequestMapping(value = "/hello")
     public String hello(){
         return hello;
     }
 }

Nach dem Login kopieren

yml-Datei

spring:
    application:
      name: config-client
    cloud:
      config:
        label: master
        profile: dev
        uri: http://localhost:8888/
  server:
   port: 8881

Nach dem Login kopieren

Nachdem Sie die Config-Client-Anwendung gestartet haben, können Sie auf http://locahost/8881/hello zugreifen Die Anwendung selbst konfiguriert den spezifischen Inhalt von Hallo nicht direkt und gibt keine spezifische Konfigurationsdatei an. Alle diese werden vom Spring Cloud Framework an den Konfigurationsserver übermittelt.

3. Konfigurieren Sie die automatische Aktualisierung

Fügen Sie zunächst die folgenden Abhängigkeiten in pom.xml hinzu. spring-boot-starter-actuator ist eine Reihe von Überwachungsfunktionen, die den laufenden Status des Programms überwachen können, einschließlich der Funktion von /refresh.

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Nach dem Login kopieren

Zweitens müssen Sie den Aktualisierungsmechanismus aktivieren. Sie müssen @RefreshScope注解 in die Klasse laden, die Variablen lädt. Wenn der Client dann /refresh ausführt, werden dies der Fall sein Werte, einschließlich der von GIT über den Konfigurationsclient erhaltenen Konfiguration.

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

    @Value("${hello}")
    String hello;
    @RequestMapping(value = "/hello")
    public String hello(){
        return hello;
    }
}

Nach dem Login kopieren

Aber diese Methode erfordert, dass Sie die Methode manuell erneut ausführen, um die aktualisierten Daten anzuzeigen

Konfigurationsdienste in einer verteilten Umgebung automatisch erkennen

Konfigurationsserver beim Servicecenter registrieren

Registrieren Sie die Hallo-Welt-Anwendung beim Eureka-Servicecenter. Die Konfigurationsmethode ist die gleiche wie zuvor

Ändern Sie die Konfigurationsdatei und ändern Sie den URL-Hardcodierungsmechanismus des Konfigurationsservers in einen automatischen Erkennungsmechanismus basierend auf dem Namen über das Servicecenter

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/spring:
  application:
    name: config-client
  cloud:
    config:
      label: master
      profile: dev
      discovery:
        enabled: true
        service-id: config-server
management:
  security:
    enabled: falseserver:
   port: 8881

Nach dem Login kopieren

我们注释掉了硬编码的config-server的URL配置，取而代之的是服务注册中心的地址http://localhost:8761/eureka/以及配置服务的名字“config-server”, 同时打开自动发现机制discovery.enable = true. 我们在运行一下hello world应用，可以发现， GIT里面的内容依然可以访问。此时我们的hello world应用已经完全不知道配置服务的地址，也不知道配置的内容，所有这些都通过服务注册中心自动发现。

五、客户端的负载均衡

Spring Cloud用Ribbon来实现两个Hello World服务的负载均衡

5.1创建ribbon服务

添加pom依赖

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

Nach dem Login kopieren

创建启动类ServiceRibbonApplication

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

Nach dem Login kopieren

@EnableDiscoveryClient向服务中心注册，并且注册了一个叫restTemplate的bean。

@ LoadBalanced注册表明，这个restRemplate是需要做负载均衡的。

创建获取一个获取Hello内容的service类

 @Service
 public class HelloService {
     @Autowired RestTemplate restTemplate;
 
     public String getHelloContent() {
         return restTemplate.getForObject("http://SERVICE-HELLOWORLD/",String.class);
     }
 }

Nach dem Login kopieren

这里关键代码就是, restTemplate.getForObject方法会通过ribbon负载均衡机制，自动选择一个Hello word服务，

这里的URL是“http://SERVICE-HELLOWORLD/"，其中的SERVICE-HELLOWORLD是Hello world服务的名字，而注册到服务中心的有两个SERVICE-HELLOWORLD。所以，这个调用本质是ribbon-service作为客户端根据负载均衡算法自主选择了一个作为服务端的SERVICE-HELLOWORLD服务。然后再访问选中的SERVICE-HELLOWORLD来执行真正的Hello world调用。

六、用声明式REST客户端Feign调用远端http服务

添加新的依赖

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

Nach dem Login kopieren

创建启动类，需要加上@EnableFeignClients注解以使用Feign，使用@EnableDiscoveryClient开启服务自动发现

添加配置文件application.yml, 使用端口8902, 名字定义为service-feign, 并注册到eureka服务中心

定义Feign：一个用@FeignClient注解的接口类

@FeignClient用于通知Feign组件对该接口进行代理(不需要编写接口实现)，使用者可直接通过@Autowired注入; 该接口通过value定义了需要调用的SERVICE-HELLOWORLD服务（通过服务中心自动发现机制会定位具体URL）; @RequestMapping定义了Feign需要访问的SERVICE-HELLOWORLD服务的URL（本例中为根“/”）

@FeignClient(value = "SERVICE-HELLOWORLD")  
public interface HelloWorldService {
      @RequestMapping(value = "/",method = RequestMethod.GET)
     String sayHello();
 }

Nach dem Login kopieren

Spring Cloud应用在启动时，Feign会扫描标有@FeignClient注解的接口，生成代理，并注册到Spring容器中。生成代理时Feign会为每个接口方法创建一个RequetTemplate对象，该对象封装了HTTP请求需要的全部信息，请求参数名、请求方法等信息都是在这个过程中确定的，Feign的模板化就体现在这里

编写一个Controller。

注入之前通过@FeignClient定义生成的bean,

sayHello()映射到http://localhost:8902/hello, 在这里，我修改了Hello World服务的映射，将根“/”，修改成了“/hello”。

@RestController
  public class WebController {
     @Autowired HelloWorldService helloWorldFeignService;
     @RequestMapping(value = "/hello",method = RequestMethod.GET)
     public String sayHello(){
         return helloWorldFeignService.sayHello();
     }
 }

Nach dem Login kopieren

七、断路器

7.1在Ribbon应用中使用断路器

先添加依赖

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

Nach dem Login kopieren

在Spring Boot启动类上添加@EnableCircuitBreaker注解

用@HystrixCommand注解标注访问服务的方法

@Service
  public class HelloService {
      @Autowired RestTemplate restTemplate;
  
      @HystrixCommand(fallbackMethod = "serviceFailure")
      public String getHelloContent() {
          return restTemplate.getForObject("http://SERVICE-HELLOWORLD/",String.class);
      }
  
     public String serviceFailure() {
         return "hello world service is not available !";
     }
 }

Nach dem Login kopieren

@HystrixCommand注解定义了一个断路器，它封装了getHelloContant()方法，当它访问的SERVICE-HELLOWORLD失败达到阀值后，将不会再调用SERVICE-HELLOWORLD，取而代之的是返回由fallbackMethod定义的方法serviceFailure（）。@HystrixCommand注解定义的fallbackMethod方法，需要特别注意的有两点：

第一， fallbackMethod的返回值和参数类型需要和被@HystrixCommand注解的方法完全一致。否则会在运行时抛出异常。比如本例中，serviceFailure（）的返回值和getHelloContant()方法的返回值都是String。

第二，当底层服务失败后，fallbackMethod替换的不是整个被@HystrixCommand注解的方法（本例中的getHelloContant), 替换的只是通过restTemplate去访问的具体服务。可以从中的system输出看到，即使失败，控制台输出里面依然会有“call SERVICE-HELLOWORLD”。

7.2在Feign应用中使用断路器

用@FeignClient注解添加fallback类，该类必须实现@FeignClient修饰的接口。

@FeignClient(name = "SERVICE-HELLOWORLD", fallback = HelloWorldServiceFailure.class) 
public interface HelloWorldService {
     @RequestMapping(value = "/", method = RequestMethod.GET)    
      public String sayHello();
 }

Nach dem Login kopieren

创建HelloWorldServiceFailure类，必须实现被@FeignClient修饰的HelloWorldService接口。注意添加@Component或者@Service注解，在Spring容器中生成一个Bean

@Component
 public class HelloWorldServiceFailure implements HelloWorldService {
     @Override
     public String sayHello() {
         System.out.println("hello world service is not available !");
         return "hello world service is not available !";
     }
 }

Nach dem Login kopieren

在application.yml中添加如下配置：

feign:
   hystrix:
     enabled: true

Nach dem Login kopieren

八、路由网管zuul

创建新的工程添加新的依赖

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

Nach dem Login kopieren

创建启动类: 使用@EnableZuulProxy注解

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

Nach dem Login kopieren

编写zuul服务配置：

简单配置两个路由，一个路由到ribbon，一个路由到feign；由于都注册到eureka服务中心，所以都用通过serviceId来发现服务具体地址， path是路由的地址映射关系

eureka:
      client:
          serviceUrl:
              defaultZone: http://localhost:8761/eureka/
  server:
      port: 8904
  spring:
      application:
          name: service-zuul
 zuul:
   routes:
     ribbo:
       path: /api-ribbon/**
       serviceId: service-ribbon
     feign:
       path: /api-feign/**
       serviceId: service-feign

Nach dem Login kopieren

这时启动zuul服务，然后访问http://localhost:8904/api-ribbon可直接路由到http://localhost:8901/.

http://localhost:8904/api-feign/hello可路由到http://localhost:8902/hello

zuul还提供了过滤功能，只要实现接口ZuulFilter即可对请求先进行筛选和过滤之后再路由到具体服务。

Das obige ist der detaillierte Inhalt vonWas ist eine Frühlingswolke? Einführung in die Verwendung von Spring Cloud. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!