Der Unterschied zwischen POST/GET-Anforderungen und der Java-Implementierung von HTTP-Anforderungen (post/get).

Der Unterschied zwischen POST/GET-Anforderungen und der Java-Implementierung von HTTP-Anforderungen (post/get).

Der Unterschied zwischen POST- und GET-Anforderungen

1. Definition von get und post

HTTP-Anfragen sind paarweise, und wenn es eine Anfrage gibt, gibt es eine Antwort. Nennen Sie sie „Upstream-Anfrage“ und „Downstream-Antwort“. Egal um welche Art von Anfrage es sich handelt, die Daten werden in Form von „header“ + „message“ übermittelt;

Get- und Post-Requests sind zwei Request-Methoden im http-Protokoll;

Get wird im Allgemeinen verwendet, um Serverinformationen zu erhalten, und post wird im Allgemeinen verwendet, um Informationen zu aktualisieren.

2. Unterschied

• GET-Parameter werden über die URL übergeben, und POST wird in den Anforderungstext eingefügt.

  • Die Daten der Get-Anforderung werden an die URL angehängt (d. h. die Daten werden in den HTTP-Protokoll-Header gestellt), um die URL und die Übertragungsdaten zu trennen, und die Parameter werden durch & verbunden
  • Wenn es sich bei den Daten um einen englischen Buchstaben/eine englische Zahl handelt, senden Sie sie unverändert, wenn es sich um ein Leerzeichen handelt, konvertieren Sie es in +, wenn es sich um ein chinesisches/anderes Zeichen handelt, verschlüsseln Sie die Zeichenfolge direkt mit BASE64, z. B.: %E4%BD %A0%E5%A5% BD, wobei XX in %XX die ASCII-Darstellung des Symbols im Hexadezimalformat ist.

• GET ist harmlos, wenn der Browser zurückfällt, während POST die Anfrage erneut sendet.

• Die von GET generierte URL-Adresse kann mit einem Lesezeichen versehen werden, aber nicht mit POST.

• GET-Anforderungen werden vom Browser aktiv zwischengespeichert, POST jedoch nicht, es sei denn, dies wurde manuell festgelegt.

• GET-Anforderungen können nur URL-codiert sein (application/x-www-form-urlencoded), während POST mehrere Codierungsmethoden unterstützt (application/x-www-form-urlencoded oder multipart/form-data. Verwenden Sie mehrere Codierungen für binäre Daten).

• GET-Anforderungsparameter werden vollständig im Browserverlauf beibehalten, während Parameter in POST nicht beibehalten werden.

• Die in der URL der GET-Anforderung übertragenen Parameter haben eine Längenbegrenzung, der POST jedoch nicht.

  • Die Daten in der von der Get-Anfrage übermittelten URL dürfen nur bis zu 1024 Byte umfassen. Dieses Limit wird vom Browser oder Server hinzugefügt. Das HTTP-Protokoll begrenzt die Länge der URL nicht. Der Zweck besteht darin, sicherzustellen, dass der Server und Der Browser kann normal ausgeführt werden und verhindern, dass jemand die Anfrage böswillig gesendet hat.
    　　Es gibt keine Größenbeschränkung für Post-Anfragen.

• Für den Datentyp von Parametern akzeptiert GET nur ASCII-Zeichen, während POST keine Einschränkungen hat.

• GET ist weniger sicher als POST, da die Parameter direkt in der URL offengelegt werden und daher nicht zum Übergeben vertraulicher Informationen verwendet werden können.

• GET generiert ein TCP-Paket, POST generiert zwei TCP-Pakete.

• Die get-Methode muss Request.QueryString verwenden, um den Wert der Variablen abzurufen, und die post-Methode verwendet Request.Form, um den Wert der Variablen abzurufen.

• (Die meisten) Browser begrenzen die URL-Länge normalerweise auf 2 KB, während (die meisten) Server URLs mit einer Größe von bis zu 64 KB verarbeiten. GET und POST sind im Wesentlichen TCP-Verbindungen, es gibt keinen Unterschied. Aufgrund von HTTP-Vorschriften und Browser-/Serverbeschränkungen weisen sie jedoch einige Unterschiede im Bewerbungsprozess auf. Bei GET-Anfragen sendet der Browser den HTTP-Header und die Daten zusammen, und der Server antwortet mit 200 (Rückgabedaten); bei POST sendet der Browser zuerst den Header, der Server antwortet mit 100 Continue, der Browser sendet Daten, und der Server antwortet 200 ok (Rückgabedaten). Da POST zwei Schritte erfordert und etwas mehr Zeit in Anspruch nimmt, scheint GET effizienter zu sein als POST. Daher empfiehlt das Yahoo-Team, POST durch GET zu ersetzen, um die Leistung der Website zu optimieren, aber seien Sie vorsichtig.

  • Sowohl GET als auch POST haben ihre eigene Semantik und können nicht beliebig gemischt werden.
  • Untersuchungen zufolge kann der Unterschied zwischen der Zeit zum Senden eines Pakets und der Zeit zum Senden von zwei Paketen in einer guten Netzwerkumgebung im Wesentlichen ignoriert werden. Bei schlechter Netzwerkumgebung hat TCP mit zwei Paketen einen großen Vorteil bei der Überprüfung der Integrität des Datenpakets.
  • Nicht alle Browser senden das Paket zweimal im POST, Firefox sendet es nur einmal.

Realisieren Sie HTTP-Anforderungen basierend auf dem SpringBoot-Framework

1. SpringBoot-Abhängigkeit einführen

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.2.13.RELEASE</version>
        </dependency>

2. HttpRestUtils-Anforderungstoolklasse

package com.javanoteany.httprest.util;

import org.springframework.http.*;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;


public class HttpRestUtils {
    
    

    /**
     * post
     * @param url 访问路径
     * @param params 参数
     * @return 返回响应体
     * @throws IOException
     */

    public static String post(String url, MultiValueMap<String, String> params) throws IOException {
    
    
        return  httpRestClient(url, HttpMethod.POST, params);
    }

    /**
     * get
     * @param url 访问路径
     * @param params 参数
     * @return 返回响应体
     * @throws IOException
     */
    public static String get(String url, MultiValueMap<String, String> params) throws IOException {
    
    
        return  httpRestClient(url, HttpMethod.GET, params);
    }

    /**
     * HttpMethod  post/get
     * */
    private static String httpRestClient(String url, HttpMethod method, MultiValueMap<String, String> params) throws IOException {
    
    
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setConnectTimeout(10*1000); //设置连接超时时间
        requestFactory.setReadTimeout(10*1000); //设置读取超时时间
        RestTemplate client = new RestTemplate(requestFactory);
        HttpHeaders headers = new HttpHeaders();
//        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        /**
         * public static final MediaType APPLICATION_ATOM_XML = new MediaType("application", "atom+xml");
         * public static final MediaType APPLICATION_CBOR = new MediaType("application", "cbor");
         * public static final MediaType APPLICATION_FORM_URLENCODED = new MediaType("application", "x-www-form-urlencoded");
         * public static final MediaType APPLICATION_JSON = new MediaType("application", "json");
         */
        headers.setContentType(MediaType.APPLICATION_JSON); //json格式，可以切换成其他数据传输格式
        HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<MultiValueMap<String, String>>(params, headers);
        //  执行HTTP请求
        ResponseEntity<String> response = null;
        try{
    
    
            response = client.exchange(url, method, requestEntity, String.class);
            return response.getBody();
        }
        catch (HttpClientErrorException e){
    
    
            System.out.println("HttpClientErrorException" + e.getMessage());
            System.out.println(e.getStatusText());
            System.out.println(e.getResponseBodyAsString());
            e.printStackTrace();
            return "";
        }
        catch (Exception e) {
    
    
            System.out.println("Exception" + e.getMessage());
            e.printStackTrace();
            return "";
        }
    }
}

3. Verwendung von Werkzeugen

package com.javanoteany.httprest;

import com.javanoteany.httprest.util.HttpRestUtils;
import org.springframework.http.HttpMethod;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;

public class HttpRestMain {
    
    

    public static String httpPost() {
    
    
        try {
    
    
            //api url地址
            String url = "http://127.0.0.1:8200/commit/getCommitList";
            // 封装参数,使用多值Map(一个key允许对应多个value)
            MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
            params.add("projectName", "117");
            params.add("number", "1");
            System.out.print("发送数据：" + params.toString());
            //发送http请求并返回结果
            String result = HttpRestUtils.post(url, params);
            System.out.print("接收反馈：" + result);
            return result;
        } catch (Exception e) {
    
    
            System.out.println("httpPost发生异常" + e.getMessage());
            return "";
        }
    }

    public static String httpGet() {
    
    
        try {
    
    
            //api url地址
            String url = "http://127.0.0.1:8200/commit/getCommitList";
            // 封装参数,使用多值Map(一个key允许对应多个value)
            MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
            params.add("projectName", "117");
            params.add("number", "1");
            System.out.print("发送数据：" + params.toString());
            //发送http请求并返回结果
            String result = HttpRestUtils.get(url, params);
            System.out.print("接收反馈：" + result);
            return result;
        } catch (Exception e) {
    
    
            System.out.println("httpGet发生异常" + e.getMessage());
            return "";
        }
    }

    public static void main(String[] args) {
    
    
        String s = httpPost();
        String s1 = httpGet();
        System.out.println(s);
        System.out.println(s1);
    }
}