Hier ist eine Zusammenfassung, wie HTTP POST und HTTP GET JSON in Java ausgeführt werden. Wie man JSON → Java und Java → JSON in Java macht, ist in ** Vorheriger Artikel ** zusammengefasst
[Dieser Artikel] Ich werde zusammenfassen, wie JSON durch HTTP-Kommunikation mit Java </ b> POST und GET wird
Ich werde zwei Möglichkeiten erklären, um eine HTTP-Kommunikation mit Java durchzuführen.
Wie man OkHttp3 benutzt
Verwendung des Java-Standardpakets ** HttpUrlConnection **
[Vorheriger Artikel] Fassen Sie zusammen, wie JSON in Java behandelt wird
Es gibt zwei Möglichkeiten, JSON in Java (deserialisieren) und Java in JSON (serialisieren) zu konvertieren.
So verwenden Sie GSON für die Bibliothek
Wie man Jackson für die Bibliothek benutzt
Vor der HTTP-Kommunikation müssen Java → JSON (Serialisierung) und JSON → Java (Deserialisierung) aktiviert sein. Der einfache Weg dazu ist in ** Dieser Artikel ** zusammengefasst. Ich werde ihn hier überspringen.
Betrachten Sie den Code als das folgende Format für JSON, das vom Server abgerufen oder an den Server gesendet wird.
Beispiel-JSON-Zeichenfolge: Beispiel.json
{
"person": {
"firstName": "John",
"lastName": "Doe",
"address": "NewYork",
"pets": [
{"type": "Dog", "name": "Jolly"},
{"type": "Cat", "name": "Grizabella"},
{"type": "Fish", "name": "Nimo"}
]
}
}
In diesem Artikel konzentrieren wir uns auf die HTTP-Kommunikation.
Erklären Sie zwei Ansätze
--Methode mit Bibliothek (OkHttp3) Es gibt viele Bibliotheken, die mit HTTP kommunizieren können, aber in diesem Artikel konzentrieren wir uns auf OkHttp3.
Die Bibliotheksspezifikationsmethode von OkHttp3 lautet wie folgt
■ Die neueste Bibliothek von OkHttp3 (Maven Repository) https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp
■ OkHttp3 ** Maven ** Einstellungsbeispiel
pom.xml
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>3.14.1</version>
</dependency>
■ Beispiel für die Einstellung von OkHttp3 ** gradle **
build.gradle
compile 'com.squareup.okhttp3:okhttp:3.14.1'
Unten finden Sie einen Beispiel-HTTP-Client, der eine JSON-Zeichenfolge POST und die resultierende Zeichenfolge empfängt:
OkHttpPostClient.java
/**
*Verwenden von "OkHttp3" für die HTTP-Bibliothek und "GSON" für die GSON-Operationsbibliothek,
*Beispiel für "POST" JSON an Server
*/
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;
}
}
Die folgenden Teile sind die Punkte des Codes zu ** GET **. Geben Sie im Folgenden URL und Header an und führen Sie ** GET ** aus. Verwenden Sie ** response.body (). String () **, um das Ergebnis als Text zu erhalten.
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;
}
Unten finden Sie den vollständigen Quellcode. Dies ist ein Beispiel für den Zugriff auf http: // localhost: 8080 / api. Der serverseitige Code wird auch unten zum Experimentieren angegeben.
OkHttpGetClient.java(Quellcode)
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;
}
}
Zeigt den Code für einen einfachen Web-API-Server an, der Jetty als Serverseite für das Experiment verwendet
/**
*-Wenn GET eine JSON-Zeichenfolge zurückgibt<br>
*-Wenn JSON POSTED ist, wird der JSON analysiert und das Ergebnis zurückgegeben.<br>
*HTTP-Server
*/
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 = "Machen";
model.person.address = "New York";
model.person.pets = new ArrayList<Pet>();
Pet pet1 = new Pet();
pet1.type = "Hund";
pet1.name = "Lustig";
model.person.pets.add(pet1);
Pet pet2 = new Pet();
pet2.type = "Katze";
pet2.name = "Grizabella";
model.person.pets.add(pet2);
Pet pet3 = new Pet();
pet3.type = "Fisch";
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();
}
}
}
Der Satz des Quellcodes lautet wie folgt https://github.com/riversun/java-json-gson-jackson-http
HttpUrlConnection ist ein Standard-Java-Paket, daher werden keine externen Bibliotheken benötigt **.
Bibliotheken sind häufig praktisch und anspruchsvoll, werden jedoch weiterhin verwendet, wenn Sie die Anzahl der abhängigen Bibliotheken und Gesamtmethoden aufgrund der Einführung multifunktionaler Bibliotheken, z. B. der Wand der DEX-Datei 64K in einer Android-Umgebung, nicht erhöhen möchten. Es ist Platz.
Wie oben erwähnt, ist die Notation ** Java 1.6-konform **, sodass sie in Java-basierten Umgebungen wie Android weit verbreitet sein kann.
UrlConnHttpPostClient.java
/**
*Verwenden Sie den Java-Standard "HttpUrlConnection" für die HTTP-Kommunikation und "GSON" für die GSON-Operationsbibliothek.
*Beispiel für "POST" JSON vom Server
*/
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 Millisekunde: 0 ist unendlich
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);//Zeit zum Verbinden
httpConn.setReadTimeout(TIMEOUT_MILLIS);//Zeit zum Lesen von Daten
httpConn.setRequestMethod("POST");//HTTP-Methode
httpConn.setUseCaches(false);//Verwendung des Cache
httpConn.setDoOutput(true);//Senden des Anforderungshauptteils zulassen(Falsch für GET,Für POST auf true setzen)
httpConn.setDoInput(true);//Ermöglichen Sie den Empfang des Antwortkörpers
if (headers != null) {
for (String key : headers.keySet()) {
httpConn.setRequestProperty(key, headers.get(key));//HTTP-Header festlegen
}
}
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 {
//Der Status ist HTTP_OK(200)Außer
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;
/**
*Verwenden Sie den Java-Standard "HttpUrlConnection" für die HTTP-Kommunikation und "GSON" für die GSON-Operationsbibliothek.
*Beispiel für "GET" JSON vom Server
*/
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 Millisekunde: 0 ist unendlich
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);//Zeit zum Verbinden
httpConn.setReadTimeout(TIMEOUT_MILLIS);//Zeit zum Lesen von Daten
httpConn.setRequestMethod("GET");//HTTP-Methode
httpConn.setUseCaches(false);//Verwendung des Cache
httpConn.setDoOutput(false);//Senden des Anforderungshauptteils zulassen(Falsch für GET,Für POST auf true setzen)
httpConn.setDoInput(true);//Ermöglichen Sie den Empfang des Antwortkörpers
if (headers != null) {
for (String key : headers.keySet()) {
httpConn.setRequestProperty(key, headers.get(key));//HTTP-Header festlegen
}
}
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 {
//Der Status ist HTTP_OK(200)Außer
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();
}
}
Ich habe auch zwei Möglichkeiten eingeführt, um eine HTTP-Kommunikation mit Java durchzuführen.
** Wie benutzt man OkHttp3 **
Verwendung des Java-Standardpakets ** HttpUrlConnection **
Der gesamte Quellcode finden Sie unter hier.
Recommended Posts