Voici un résumé de la procédure de HTTP POST et HTTP GET JSON en Java. Comment faire JSON → Java et Java → JSON en Java est résumé dans ** Article précédent **
[Cet article] Je vais résumer comment POST et GET JSON par communication HTTP avec Java </ b>
Je vais expliquer deux façons d'effectuer une communication HTTP avec Java.
Comment utiliser OkHttp3
Comment utiliser le package standard Java ** HttpUrlConnection **
Il existe deux façons de convertir JSON en Java (désérialiser) et Java en JSON (sérialiser).
Comment utiliser GSON pour la bibliothèque
Comment utiliser Jackson pour la bibliothèque
Il est nécessaire d'activer Java → JSON (sérialisation) et JSON → Java (désérialisation) avant la communication HTTP. Le moyen le plus simple de le faire est résumé dans ** Cet article **, je vais donc l'ignorer ici.
Considérez le code comme le format suivant pour JSON qui est GET du serveur ou POSTed sur le serveur.
Exemple de chaîne JSON: exemple.json
{
"person": {
"firstName": "John",
"lastName": "Doe",
"address": "NewYork",
"pets": [
{"type": "Dog", "name": "Jolly"},
{"type": "Cat", "name": "Grizabella"},
{"type": "Fish", "name": "Nimo"}
]
}
}
Dans cet article, nous nous concentrerons sur la communication HTTP.
Expliquez deux approches
--Méthode utilisant la bibliothèque (OkHttp3) Il existe de nombreuses bibliothèques qui peuvent communiquer avec HTTP, mais dans cet article, nous nous concentrerons sur OkHttp3.
--Méthode sans bibliothèque Voyons comment utiliser le package standard Java HttpUrlConnection sans utiliser de bibliothèque externe.
La méthode de spécification de bibliothèque d'OkHttp3 est la suivante
■ La dernière bibliothèque d'OkHttp3 (référentiel maven) https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp
■ Exemple de réglage OkHttp3 ** maven **
pom.xml
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>3.14.1</version>
</dependency>
■ Exemple de réglage OkHttp3 ** gradle **
build.gradle
compile 'com.squareup.okhttp3:okhttp:3.14.1'
Voici un exemple de client HTTP qui POST une chaîne JSON et reçoit la chaîne résultante:
OkHttpPostClient.java
/**
*En utilisant "OkHttp3" pour la bibliothèque HTTP et "GSON" pour la bibliothèque d'opérations GSON,
*Exemple de JSON "POST" sur le serveur
*/
public class OkHttpPostClient {
public static void main(String[] args) throws IOException {
OkHttpPostClient client = new OkHttpPostClient();
String result = client.callWebAPI();
System.out.println(result);
}
private static final String WEB_API_ENDPOINT = "http://localhost:8080/api";
public String callWebAPI() throws IOException {
final String postJson = "{" +
" \"person\": {" +
" \"firstName\": \"John\"," +
" \"lastName\": \"Doe\"," +
" \"address\": \"NewYork\"," +
" \"pets\": [" +
" {\"type\": \"Dog\", \"name\": \"Jolly\"}," +
" {\"type\": \"Cat\", \"name\": \"Grizabella\"}," +
" {\"type\": \"Fish\", \"name\": \"Nimo\"}" +
" ]" +
" }" +
"}";
final Map<String, String> httpHeaders = new LinkedHashMap<String, String>();
final String resultStr = doPost(WEB_API_ENDPOINT, "UTF-8", httpHeaders, postJson);
return resultStr;
}
public String doPost(String url, String encoding, Map<String, String> headers, String jsonString) throws IOException {
final okhttp3.MediaType mediaTypeJson = okhttp3.MediaType.parse("application/json; charset=" + encoding);
final RequestBody requestBody = RequestBody.create(mediaTypeJson, jsonString);
final Request request = new Request.Builder()
.url(url)
.headers(Headers.of(headers))
.post(requestBody)
.build();
final OkHttpClient client = new OkHttpClient.Builder()
.build();
final Response response = client.newCall(request).execute();
final String resultStr = response.body().string();
return resultStr;
}
}
Les parties suivantes sont les points du code pour ** GET **. Dans ce qui suit, spécifiez l'url et l'en-tête et exécutez ** GET **. Pour obtenir le résultat sous forme de texte, utilisez ** response.body (). String () **.
public String doGet(String url, Map<String, String> headers) throws IOException {
final Request request = new Request.Builder()
.url(url)
.headers(Headers.of(headers))
.build();
final OkHttpClient client = new OkHttpClient.Builder().build();
final Response response = client.newCall(request).execute();
final String resultStr = response.body().string();
return resultStr;
}
Vous trouverez ci-dessous le code source complet. Voici un exemple d'accès à http: // localhost: 8080 / api. Le code côté serveur est également publié ci-dessous à des fins d'expérimentation.
OkHttpGetClient.java(Code source)
public class OkHttpGetClient {
public static void main(String[] args) throws IOException {
OkHttpGetClient client = new OkHttpGetClient();
Model result = client.callWebAPI();
System.out.println("Firstname is " + result.person.firstName);
}
private static final String WEB_API_ENDPOINT = "http://localhost:8080/api";
private final Gson mGson = new Gson();
public Model callWebAPI() throws IOException {
final Map<String, String> httpHeaders = new LinkedHashMap<String, String>();
final String resultStr = doGet(WEB_API_ENDPOINT, httpHeaders);
final Model model = mGson.fromJson(resultStr, Model.class);
return model;
}
public String doGet(String url, Map<String, String> headers) throws IOException {
final Request request = new Request.Builder()
.url(url)
.headers(Headers.of(headers))
.build();
final OkHttpClient client = new OkHttpClient.Builder().build();
final Response response = client.newCall(request).execute();
final String resultStr = response.body().string();
return resultStr;
}
}
Affiche le code d'un serveur d'API Web simple utilisant Jetty comme côté serveur pour l'expérience
/**
*-Lorsque GET, renvoie une chaîne de caractères JSON<br>
*-Lorsque JSON est POSTÉ, le JSON est analysé et le résultat est renvoyé.<br>
*Serveur HTTP
*/
public class JsonApiServer {
public static void main(String[] args) {
final int PORT = 8080;
final Class<? extends Servlet> servlet = ExampleServlet.class;
ServletContextHandler servletHandler = new ServletContextHandler(ServletContextHandler.SESSIONS);
servletHandler.addServlet(new ServletHolder(servlet), "/api");
final Server jettyServer = new Server(PORT);
jettyServer.setHandler(servletHandler);
try {
jettyServer.start();
jettyServer.join();
} catch (Exception e) {
e.printStackTrace();
}
}
@SuppressWarnings("serial")
public static class ExampleServlet extends HttpServlet {
private final Gson mGson = new Gson();
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
Model model = new Model();
model.person = new Person();
model.person.firstName = "John";
model.person.lastName = "Faire";
model.person.address = "New York";
model.person.pets = new ArrayList<Pet>();
Pet pet1 = new Pet();
pet1.type = "chien";
pet1.name = "Gai";
model.person.pets.add(pet1);
Pet pet2 = new Pet();
pet2.type = "Chat";
pet2.name = "Grizabella";
model.person.pets.add(pet2);
Pet pet3 = new Pet();
pet3.type = "poisson";
pet3.name = "Nimo";
model.person.pets.add(pet3);
String json = mGson.toJson(model);
resp.setContentType("text/html; charset=UTF-8");
resp.setCharacterEncoding("UTF-8");
final PrintWriter out = resp.getWriter();
out.println(json);
out.close();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
final StringBuilder sb = new StringBuilder();
String line = null;
try {
BufferedReader reader = req.getReader();
while ((line = reader.readLine()) != null) {
sb.append(line);
}
} catch (Exception e) {
}
final String body = sb.toString();
final Model model = mGson.fromJson(body, Model.class);
resp.setContentType("text/html; charset=UTF-8");
resp.setCharacterEncoding("UTF-8");
final PrintWriter out = resp.getWriter();
out.println("Server Generated Message");
out.println("Firstname is " + model.person.firstName);
out.close();
}
}
}
L'ensemble du code source est le suivant https://github.com/riversun/java-json-gson-jackson-http
HttpUrlConnection est un package Java standard, donc aucune bibliothèque externe n'est nécessaire **.
Les bibliothèques sont souvent pratiques et sophistiquées, mais elles sont toujours utilisées lorsque vous souhaitez éviter d'augmenter le nombre de bibliothèques dépendantes et de méthodes totales en raison de l'introduction de bibliothèques multifonctionnelles, telles que le mur du fichier DEX 64K dans l'environnement Android. Il y a de la place.
Comme mentionné ci-dessus, la notation est ** Java 1.6 Compliant ** afin qu'elle puisse être largement utilisée dans les environnements basés sur Java tels qu'Android.
UrlConnHttpPostClient.java
/**
*Utilisez la norme Java "HttpUrlConnection" pour la communication HTTP et "GSON" pour la bibliothèque d'opérations GSON.
*Exemple de JSON "POST" à partir du serveur
*/
public class UrlConnHttpPostClient {
public static void main(String[] args) throws IOException {
UrlConnHttpPostClientclient = new UrlConnHttpPostClient();
String result = client.callWebAPI();
System.out.println(result);
}
private static final String WEB_API_ENDPOINT = "http://localhost:8080/api";
public String callWebAPI() throws IOException {
final String postJson = "{" +
" \"person\": {" +
" \"firstName\": \"John\"," +
" \"lastName\": \"Doe\"," +
" \"address\": \"NewYork\"," +
" \"pets\": [" +
" {\"type\": \"Dog\", \"name\": \"Jolly\"}," +
" {\"type\": \"Cat\", \"name\": \"Grizabella\"}," +
" {\"type\": \"Fish\", \"name\": \"Nimo\"}" +
" ]" +
" }" +
"}";
final Map<String, String> httpHeaders = new LinkedHashMap<String, String>();
final String resultStr = doPost(WEB_API_ENDPOINT, "UTF-8", httpHeaders, postJson);
return resultStr;
}
private String doPost(String url, String encoding, Map<String, String> headers, String jsonString) throws IOException {
final int TIMEOUT_MILLIS = 0;//Timeout milliseconde: 0 est infini
final StringBuffer sb = new StringBuffer("");
HttpURLConnection httpConn = null;
BufferedReader br = null;
InputStream is = null;
InputStreamReader isr = null;
try {
URL urlObj = new URL(url);
httpConn = (HttpURLConnection) urlObj.openConnection();
httpConn.setConnectTimeout(TIMEOUT_MILLIS);//Il est temps de se connecter
httpConn.setReadTimeout(TIMEOUT_MILLIS);//Temps de lecture des données
httpConn.setRequestMethod("POST");//Méthode HTTP
httpConn.setUseCaches(false);//Utilisation du cache
httpConn.setDoOutput(true);//Autoriser l'envoi du corps de la demande(Faux pour GET,Défini sur true pour POST)
httpConn.setDoInput(true);//Autoriser la réception du corps de la réponse
if (headers != null) {
for (String key : headers.keySet()) {
httpConn.setRequestProperty(key, headers.get(key));//Définir l'en-tête HTTP
}
}
final OutputStream os = httpConn.getOutputStream();
final boolean autoFlash = true;
final PrintStream ps = new PrintStream(os, autoFlash, encoding);
ps.print(jsonString);
ps.close();
final int responseCode = httpConn.getResponseCode();
String _responseEncoding = httpConn.getContentEncoding();
if (_responseEncoding == null) {
_responseEncoding = "UTF-8";
}
if (responseCode == HttpURLConnection.HTTP_OK) {
is = httpConn.getInputStream();
isr = new InputStreamReader(is, _responseEncoding);
br = new BufferedReader(isr);
String line = null;
while ((line = br.readLine()) != null) {
sb.append(line);
}
} else {
//Le statut est HTTP_OK(200)Autre que
throw new IOException("responseCode is " + responseCode);
}
} catch (IOException e) {
throw e;
} finally {
// Java1.6 Compliant
if (br != null) {
try {
br.close();
} catch (IOException e) {
}
}
if (isr != null) {
try {
isr.close();
} catch (IOException e) {
}
}
if (is != null) {
try {
is.close();
} catch (IOException e) {
}
}
if (httpConn != null) {
httpConn.disconnect();
}
}
return sb.toString();
}
}
UrlConnHttpGetClient.java
package com.example.http_client.urlconnection;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.LinkedHashMap;
import java.util.Map;
import com.example.jackson.Model;
import com.google.gson.Gson;
/**
*Utilisez la norme Java "HttpUrlConnection" pour la communication HTTP et "GSON" pour la bibliothèque d'opérations GSON.
*Échantillon pour "GET" JSON à partir du serveur
*/
public class UrlConnHttpGetClient {
public static void main(String[] args) throws IOException {
UrlConnHttpGetClient client = new UrlConnHttpGetClient();
Model result = client.callWebAPI();
System.out.println("Firstname is " + result.person.firstName);
}
private static final String WEB_API_ENDPOINT = "http://localhost:8080/api";
private final Gson mGson = new Gson();
public Model callWebAPI() throws IOException {
final Map<String, String> httpHeaders = new LinkedHashMap<String, String>();
final String resultStr = doGet(WEB_API_ENDPOINT, httpHeaders);
final Model model = mGson.fromJson(resultStr, Model.class);
return model;
}
public String doGet(String url, Map<String, String> headers) throws IOException {
final int TIMEOUT_MILLIS = 0;//Timeout milliseconde: 0 est infini
final StringBuffer sb = new StringBuffer("");
HttpURLConnection httpConn = null;
BufferedReader br = null;
InputStream is = null;
InputStreamReader isr = null;
try {
URL urlObj = new URL(url);
httpConn = (HttpURLConnection) urlObj.openConnection();
httpConn.setConnectTimeout(TIMEOUT_MILLIS);//Il est temps de se connecter
httpConn.setReadTimeout(TIMEOUT_MILLIS);//Temps de lecture des données
httpConn.setRequestMethod("GET");//Méthode HTTP
httpConn.setUseCaches(false);//Utilisation du cache
httpConn.setDoOutput(false);//Autoriser l'envoi du corps de la demande(Faux pour GET,Défini sur true pour POST)
httpConn.setDoInput(true);//Autoriser la réception du corps de la réponse
if (headers != null) {
for (String key : headers.keySet()) {
httpConn.setRequestProperty(key, headers.get(key));//Définir l'en-tête HTTP
}
}
final int responseCode = httpConn.getResponseCode();
String encoding = httpConn.getContentEncoding();
if (encoding == null) {
encoding = "UTF-8";
}
if (responseCode == HttpURLConnection.HTTP_OK) {
is = httpConn.getInputStream();
isr = new InputStreamReader(is, encoding);
br = new BufferedReader(isr);
String line = null;
while ((line = br.readLine()) != null) {
sb.append(line);
}
} else {
//Le statut est HTTP_OK(200)Autre que
throw new IOException("responseCode is " + responseCode);
}
} catch (IOException e) {
throw e;
} finally {
// Java1.6 Compliant
if (br != null) {
try {
br.close();
} catch (IOException e) {
}
}
if (isr != null) {
try {
isr.close();
} catch (IOException e) {
}
}
if (is != null) {
try {
is.close();
} catch (IOException e) {
}
}
if (httpConn != null) {
httpConn.disconnect();
}
}
return sb.toString();
}
}
--Tout le code source peut être trouvé à ici
Recommended Posts