[JAVA] J'ai créé un serveur et un client Restful au printemps.

J'ai essayé d'étudier un peu quelque chose appelé API.

Cela semble être une méthode de communication majeure récemment pour la communication entre les serveurs. Eh bien, récemment, chaque service majeur distribue des API, alors j'ai étudié un peu.

Je n'ai pas étudié depuis une heure, j'accepte donc l'édition!

À propos de la chose appelée API

L'API peut adresser les requêtes suivantes au serveur.

Personnellement, la seule chose que j'utilise ici est GET POST. Si vous voulez en savoir plus sur les affaires, veuillez en savoir plus.

Fournissez l'API.

Cette fois, nous allons créer l'API la plus simple, l'API pour obtenir JSON avec la méthode GET.

Tout d'abord, du service qui délivre JSON.

(Je n'expliquerai plus le contrôleur de Spring MVC ヾ (.> ﹏ <.) ﾉ)

APIServiceController.java

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

import com.TsugaruInfo.formmodel.RegisterForm;

@RequestMapping(value = "/APITransport")
@RestController
public class APIServiceController {
	
	@RequestMapping(value="APIAccessParametors",produces="application/json;charset=UTF-8")
	public String APIAccessParametors() {
		String APIResponseJson = 
			"{\"user\": [\"AtsuAtsuUdon\", \"user\", true],"
			+ " \"toot\": [\"C'est un udon chaud!\"]"
			+ "CWInfo: {CWSituationIs:[true, \"Quelque chose que je veux cacher\"], \"publicToot\", \"something\"]}";
		
		return APIResponseJson;
	}
}

Comme vous pouvez le voir, il ne fait que renvoyer la chaîne. Si vous forcez à augmenter les points ** @RestController et indiquez clairement qu'il s'agit d'un service reposant. ** ** Puisque les chaînes de caractères japonais sont livrées, @RequestMapping produces="application/json;charset=UTF-8" Il est spécifié comme.

Créez RestClient.

Maintenant, récupérons le client qui reçoit cela en utilisant la communication HTTP. Apparemment, Java a un service de repos standard ** API JAX-RS ** et des spécifications client. En tant qu'implémentation, il existe une bibliothèque pratique appelée ** jersey **.

Bien sûr, cette bibliothèque est également gérée par la ** Spring IO Platform **, donc (si vous ne savez pas, ggt (ry) Installons cette bibliothèque à la fois. ** [20190115] Addendum Spring IO Platform a terminé le développement (T_T) Veuillez utiliser Spring Boot pour résoudre la bibliothèque Spring **

pom.xml

		<!-- jersey -->
		<dependency>
			<groupId>org.glassfish.jersey.core</groupId>
			<artifactId>jersey-client</artifactId>
		</dependency>
		<dependency>
			<groupId>org.glassfish.jersey.ext</groupId>
			<artifactId>jersey-spring3</artifactId>
		</dependency>
		
		<!-- Jackson -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
		</dependency>

La bibliothèque ci-dessous est une bibliothèque d'analyseurs json et xml appelée Jackson. Il convertit la chaîne json reçue en un objet.

Créons maintenant le côté client.

APIRecieverController.java

@RequestMapping(value = "/APITransport")
@Controller
public class APIRecieverController {

	@RequestMapping(value="recieverClient")
	public ModelAndView recieverClient(Model model) {
		ModelAndView mv = new ModelAndView("APIRecieverView");
		
//Spécifiez les paramètres de communication HTTP et l'URL
//S'il s'agit d'une méthode de publication, placez le corps de la requête ici
//Les en-têtes HTTP peuvent également être inclus
		Client client = ClientBuilder.newClient();
		WebTarget target = client.target("http://localhost:8080")
			    .path("/WebAquarium3.1/APITransport/APIAccessParametors");
			 
		String result = "";
//Tentative de communication HTTP
			try {
			    result = target.request().get(String.class);
			} catch (BadRequestException e) {
			    System.out.println("La réception a échoué ＞ ＜");
			    throw e;
			}
//Envoyez le json reçu à la vue tel quel.
//Je n'emballerai pas avec Jackson cette fois
		mv.addObject("APIMessage", result);
		return mv;
	}
}

Fondamentalement, c'est comme écrit dans le commentaire. ** 1. Spécifiez l'URL de l'API ** ** 2. Lancer une demande **

Utilisez l'API dans la procédure. Enfin, créez une vue qui affiche ceci. Il dit html, mais bien sûr, c'est .jsp

APIRecieverView.html

<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<head>
<meta content="ja" http-equiv="Content-Language" />
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<title>HTTPReciever</title>

<body>

<p>Le message reçu de l'API est</p>
<p>${APIMessage}</p>
<p>est.</p>

</body>

</html>

Recevez simplement la valeur avec **% APIMessage% **. C'est facile. Lançons-le.

J'ai pu utiliser correctement l'API en utilisant la communication HTTP.

Résumé

Pour être honnête, cela seul ne peut pas être aussi flashy. En ce qui concerne l'acquisition d'informations d'authentification en combinaison avec OAuth2 et Spring Security, je pense que cela deviendra une fonction assez puissante. (Il semble qu'étudier dans cette mesure sera le premier)

Pour le moment, la communication HTTP s'effectue en Java. C'était une étude qui donnait l'impression de maintenir les bases.

URL de référence Jersey Client API: Comment créer un client API Web en Java http://www.techscore.com/blog/2016/09/20/jersey-client-api/ POST dans Jersey Client https://qiita.com/noobar/items/a96e07e441241b1e0215