(Java-Geschichte nach langer Zeit: entspannt :)
Wie kommunizieren Sie mit einem Dienst, der aus mehreren Servern besteht?
In dem Projekt, für das ich gerade verantwortlich bin, wird Spring Boot verwendet, um REST-ähnliche APIs für jeden Server vorzubereiten. Ich denke, dass "RestTemplate" oft verwendet wird, wenn API in SpringBoot aufgerufen wird. Auf der Clientseite sind viele Dinge zu beachten, z. B. das Abrufen der Korrespondenz zwischen dem Pfad und dem Anforderungs- / Antwortmodell aus den Spezifikationen oder das Beurteilen anhand des "Controllers", ob der Quellcode sichtbar ist. (Erfahrung
"Es wäre wirklich einfach, wenn ich sowohl auf der Client-Seite als auch auf" Controller "schreiben könnte ..." "Wenn dieselbe Schnittstelle wie" Controller "verwendet werden kann, ist die Wartung viel einfacher ..."
Sie können das mit Feign (OpenFeign) machen: Sonnenbrille:
https://github.com/OpenFeign/feign
Feign makes writing java http clients easier
Feign ist ein Framework für HTTP-Clients, das von "Retrofit", "JAXRS-2.0" und "WebSocket" inspiriert ist. Wie oben erwähnt, versuche ich, präziser zu schreiben.
Verwenden Sie zur Verwendung mit Spring Boot Spring Cloud Open Feign in Spring Cloud.
Versuchen Sie, die Wetterinformationen mit Livedoor Weather Web Service abzurufen: teilweise_sunny:
Es läuft auf Java9, Maven (3.5.2), Spring Boot (2.0.0.RELEASE).
pom.xml sieht so aus.
Geben Sie die neueste (Stand 03/02/2018) Finchley.M7 für spring-cloud.version an.
Lombok ist Ihre Wahl
pom.xml
<?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.example.ofc</groupId>
<artifactId>open-feign-client</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>open-feign-client</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.0.RELEASE</version>
<relativePath />
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>9</java.version>
<spring-cloud.version>Finchley.M7</spring-cloud.version>
</properties>
<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>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
</project>
Der Einfachheit halber werden nur Titel und Beschreibungen behandelt.
WeatherInfo.java
package com.example.ofc.model;
import lombok.Data;
@Data
public class WeatherInfo {
private String title;
private WeatherDescription description;
}
WeatherDescription.java
package com.example.ofc.model;
import lombok.Data;
@Data
public class WeatherDescription {
private String text;
private String publicTime;
}
Sie müssen lediglich die Schnittstelle mit Anmerkungen deklarieren, was als Implementierung bezeichnet wird.
@ FeignClient wird auf der Serverseite mit @ RestController gepaart.
Übergeben Sie den Namen und den Basispfad "url" an "@ FeignClient".
Diesmal ist es harter Code, aber im eigentlichen Code ist es besser, in die Eigenschaftendatei zu gehen.
Dann können Sie verschiedene Pfade für jede Umgebung anzeigen.
Die Methode wird wie die Controller-Implementierung mit "@ RequestMapping", "@ RequestParam" usw. deklariert.
WeatherClient.java
package com.example.ofc.api;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import com.example.ofc.model.WeatherInfo;
@FeignClient(name = "weather", url = "weather.livedoor.com")
public interface WeatherClient {
@RequestMapping(method = RequestMethod.GET, value = "/forecast/webservice/json/v1")
ResponseEntity<WeatherInfo> getWeatherInfo(@RequestParam("city") Long city);
}
Rufen Sie die API in run by @ Autowired dem oben genannten Client auf. (Geben Sie diesmal Tokio an.)
Davon abgesehen ist es eine normale Startklasse.
Application.java
package com.example.ofc;
import com.example.ofc.model.WeatherInfo;
import com.example.ofc.api.WeatherClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.http.ResponseEntity;
@SpringBootApplication
@EnableFeignClients
@EnableAutoConfiguration
@Slf4j
public class Application implements CommandLineRunner {
@Autowired
private WeatherClient weatherClient;
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
@Override
public void run(String... strings) throws Exception {
//Tokio: 130010
ResponseEntity<WeatherInfo> response = weatherClient.getWeatherInfo(130010L);
log.info(response.getBody().toString());
}
}
Beim Start werden die Wetterinformationen in das Protokoll ausgegeben.
.
.
.
2018-03-02 16:00:22.536 INFO 8604 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Located managed bean 'refreshScope': registering with JMX server as MBean [org.springframework.cloud.context.scope.refresh:name=refreshScope,type=RefreshScope]
2018-03-02 16:00:22.550 INFO 8604 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Located managed bean 'configurationPropertiesRebinder': registering with JMX server as MBean [org.springframework.cloud.context.properties:name=configurationPropertiesRebinder,context=2098d877,type=ConfigurationPropertiesRebinder]
2018-03-02 16:00:22.582 INFO 8604 --- [ main] com.example.ofc.Application : Started Application in 2.997 seconds (JVM running for 6.875)
2018-03-02 16:00:22.753 INFO 8604 --- [ main] com.example.ofc.Application : WeatherInfo(title=Tokio Tokio Wetter, description=WeatherDescription(text=Druckverteilung im Winter um Japan
Es ist geworden.
[Kanto Koshin Region]
Die Kanto Koshin Region ist im Allgemeinen sonnig, aber entlang der Berge in der Präfektur Nagano und im nördlichen Teil der Kanto Region.
Dann gibt es Orte, an denen es bewölkt und schneebedeckt ist.
Am 2. lockert sich die Druckverteilung vom Wintertyp allmählich und ist mit hohem Druck bedeckt, so dass dies im Allgemeinen der Fall ist
Es wird gut, aber im nördlichen Teil der Kanto-Region und entlang der Berge in der Präfektur Nagano, zunächst aufgrund des Einflusses der kalten Luft
Es wird Orte geben, an denen es bewölkt und schneebedeckt sein wird.
Aufgrund des hohen Drucks wird es am 3. voraussichtlich meist sonnig sein.
Im Meer bei Kanto gibt es Orte, an denen am 2. Wellen auftreten können und am 3. die Wellen hoch sind.
Es wird____geben. Vorsicht vor hohen Wellen auf Schiffen.
[Region Tokio]
Es wird 2 bis 3 Tage dauern., publicTime=2018-03-02T10:40:00+0900))
.
.
.
Ich könnte es mit fast keiner Implementierung tun! : yum:
Das vorherige Beispiel war eine externe API, aber ich denke, es gibt mehr interne API-Kommunikation. Wie ich am Anfang schrieb, wäre es einfacher, wenn dieselbe Schnittstelle für FeignClient auf der Clientseite und RestController auf der Serverseite verwendet werden könnte.
Erstellen Sie in einem solchen Fall einen FeignClient, der die Schnittstelle auf dem Client erbt, und einen RestController, der die Schnittstelle auf dem Server implementiert. Dann muss nur die Schnittstelle (und das Modell) veröffentlicht werden. Wenn Sie Informationen wie den Statuscode mit Anmerkungen wie "@ ApiResponse" schreiben, benötigen Sie die Spezifikationen nicht. (Wenn Sie eine Spezifikation wünschen, erstellt Swagger diese automatisch.)
Nehmen Sie die obigen Wetterinformationen als Beispiel. (Import etc. weggelassen)
public interface WeatherApi {
@RequestMapping(method = RequestMethod.GET, value = "/forecast/webservice/json/v1")
ResponseEntity<WeatherInfo> getWeatherInfo(@RequestParam("city") Long city);
}
//Die Richtung der URL ist angemessen
@FeignClient(name = "weather", url="localhost:8888")
public interface WeatherApiClient extends WeatherApi {
}
@RestController
public class WeatherController implements WeatherApi {
@Override
ResponseEntity<WeatherInfo> getWeatherInfo(@RequestParam("city") Long city) {
//Erstellung von Wetterinformationen...
return responseEntity;
}
}
Wie einfach es ist! : dizzy_face:
Ich habe Ihnen gezeigt, wie Sie mit Spring Cloud Open Feign einen API-Client erstellen. In Anbetracht des Umfangs der Implementierung und Verfügbarkeit möchte ich sie aktiv nutzen.
Klicken Sie hier für dieses Beispiel https://github.com/totto357/open-feign-client-example
Recommended Posts