(Histoire de Java après un long moment: détendu :)
Comment communiquez-vous avec un service composé de plusieurs serveurs?
Dans le projet dont je suis actuellement en charge, Spring Boot est utilisé pour préparer des API de type REST pour chaque serveur.
Je pense que RestTemplate est souvent utilisé lors de l'appel de l'API dans SpringBoot.
Du côté client, il y a beaucoup de choses à considérer, comme extraire la correspondance entre le chemin et le modèle de demande / réponse à partir des spécifications, ou juger à partir du «contrôleur» si le code source peut être vu. (Expérience
"Ce serait vraiment facile si je pouvais écrire aussi bien côté client que Controller ..."
"De plus, si la même interface que Controller peut être utilisée, la maintenance sera beaucoup plus facile ..."
Vous pouvez le faire avec Feign (OpenFeign): lunettes de soleil:
https://github.com/OpenFeign/feign
Feign makes writing java http clients easier
Feign est un framework pour les clients HTTP inspiré de Retrofit, JAXRS-2.0 et WebSocket. Comme mentionné ci-dessus, j'essaie d'écrire de manière plus concise.
Pour l'utiliser avec Spring Boot, utilisez Spring Cloud Open Feign dans Spring Cloud.
Feign, mais notez qu'un autre projet appelé ʻOpenFeign est utilisé depuis Finchley.M7` de Spring Cloud (l'utilisation est la même qu'avant).
Changements dans Spring Cloud Finchley.M7Essayez d'obtenir les informations météorologiques en utilisant Livedoor Weather Web Service: partial_sunny:
Il fonctionne sur Java9, Maven (3.5.2), Spring Boot (2.0.0.RELEASE).
pom.xml ressemble à ceci.
Spécifiez le dernier (en date du 03/02/2018) Finchley.M7 pour spring-cloud.version.
lombok est votre choix
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>
Pour plus de simplicité, nous ne traiterons que des titres et des descriptions.
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;
}
Tout ce que vous avez à faire est de déclarer l'interface avec des annotations, ce que l'on appelle l'implémentation.
@ FeignClient est associé à @ RestController côté serveur.
Passez le nom et le chemin de base ʻurlà@ FeignClient`.
Cette fois, c'est du code dur, mais dans le code réel, il vaut mieux aller dans le fichier de propriétés.
Ensuite, vous pouvez aller voir différents chemins pour chaque environnement.
La méthode est déclarée avec @ RequestMapping, @ RequestParam, etc. comme dans l'implémentation du contrôleur.
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);
}
Appelez l'API dans run by @ Autowired le client ci-dessus. (Cette fois, précisez Tokyo)
En dehors de cela, c'est une classe de démarrage normale.
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 {
//Tokyo: 130010
ResponseEntity<WeatherInfo> response = weatherClient.getWeatherInfo(130010L);
log.info(response.getBody().toString());
}
}
Une fois démarré, les informations météorologiques seront sorties dans le journal.
.
.
.
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=Tokyo Tokyo Météo, description=WeatherDescription(text=Répartition de la pression de type hivernal autour du Japon
Il est devenu.
[Région de Kanto Koshin]
La région de Kanto Koshin est généralement ensoleillée, mais le long des montagnes de la préfecture de Nagano et de la partie nord de la région de Kanto.
Ensuite, il y a des endroits où il fait nuageux et neigeux.
Le 2, la répartition de la pression de type hiver se desserre progressivement et est recouverte de haute pression, de sorte qu'elle est généralement
Ce sera bien, mais dans la partie nord de la région de Kanto et le long des montagnes de la préfecture de Nagano, en raison de l'influence de l'air froid au début
Il y aura des endroits où le temps sera nuageux et neigeux.
Il devrait être principalement ensoleillé le 3 en raison de la haute pression.
Dans la mer près de Kanto, il y a des endroits où des houles peuvent se produire le 2, et où les vagues sont hautes le 3.
Il y aura. Méfiez-vous des hautes vagues sur les navires.
[Région de Tokyo]
Ce sera bien de 2 à 3 jours., publicTime=2018-03-02T10:40:00+0900))
.
.
.
Je pourrais le faire presque sans implémentation! : Miam:
L'exemple précédent était une API externe, mais je pense qu'il y a plus de communication API interne. Comme je l'ai écrit au début, il serait plus facile si la même interface pouvait être utilisée pour FeignClient côté client et RestController côté serveur.
Dans ce cas, vous pouvez créer un FeignClient qui hérite de l'interface sur le client et un RestController qui implémente l'interface sur le serveur.
Ensuite, seul l'interface (et le modèle) doit être publié, et si vous écrivez des informations telles que le code d'état à l'aide d'annotations telles que @ ApiResponse, vous n'aurez pas besoin des spécifications. (Si vous voulez une spécification, Swagger la créera automatiquement)
Prenez les informations météorologiques ci-dessus à titre d'exemple. (Importation, etc. omis)
public interface WeatherApi {
@RequestMapping(method = RequestMethod.GET, value = "/forecast/webservice/json/v1")
ResponseEntity<WeatherInfo> getWeatherInfo(@RequestParam("city") Long city);
}
//La direction de l'url est appropriée
@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) {
//Création d'informations météorologiques...
return responseEntity;
}
}
Comme c'est facile! : dizzy_face:
Je vous ai montré comment créer un client Api à l'aide de Spring Cloud Open Feign. Compte tenu de la quantité de mise en œuvre et de la disponibilité, je voudrais l'utiliser activement.
Cliquez ici pour cet exemple https://github.com/totto357/open-feign-client-example
Recommended Posts