La diferencia entre las solicitudes POST/GET y la implementación de solicitudes HTTP (post/get) de Java

La diferencia entre las solicitudes POST/GET y la implementación de solicitudes HTTP (post/get) de Java

La diferencia entre las solicitudes POST y GET

1. Definición de obtener y publicar

Las solicitudes HTTP están en pares, y si hay una solicitud, habrá una respuesta. Llámelos "solicitud ascendente" y "respuesta descendente". No importa qué tipo de solicitud, los datos se transmitirán en forma de "encabezado" + "mensaje";

Las solicitudes get y post son dos métodos de solicitud en el protocolo http;

Obtener se usa generalmente para obtener información del servidor y publicar se usa generalmente para actualizar la información.

2. Diferencia

• Los parámetros GET se pasan a través de la URL y POST se coloca en el cuerpo de la solicitud.

  • Los datos de la solicitud de obtención se agregarán a la URL (es decir, los datos se colocan en el encabezado del protocolo HTTP) para separar la URL y los datos de transmisión, y los parámetros están conectados por &
  • Si los datos son una letra/número en inglés, envíelos tal cual, si es un espacio, conviértalos a +, si es un carácter chino/otro, cifre directamente la cadena con BASE64, como: %E4%BD %A0%E5%A5% BD, donde XX en %XX es la representación ASCII del símbolo en hexadecimal.

• GET es inofensivo cuando el navegador retrocede, mientras que POST envía la solicitud nuevamente.

• La dirección URL generada por GET se puede marcar, pero no POST.

• El navegador almacenará activamente en caché las solicitudes GET, pero POST no, a menos que se configure manualmente.

• Las solicitudes GET solo se pueden codificar en URL (application/x-www-form-urlencoded), mientras que POST admite varios métodos de codificación (application/x-www-form-urlencoded o multipart/form-data. Use varias codificaciones para datos binarios).

• Los parámetros de solicitud GET se conservarán por completo en el historial del navegador, mientras que los parámetros en POST no se conservarán.

• Los parámetros transmitidos en la URL de la solicitud GET tienen un límite de longitud, pero la POST no.

  • Los datos en la URL enviada por la solicitud de obtención solo pueden ser de hasta 1024 bytes. Este límite lo agrega el navegador o el servidor. El protocolo http no limita la longitud de la URL. El propósito es garantizar que el servidor y el navegador puede funcionar normalmente y evitar que alguien envíe la solicitud de forma malintencionada.
    　　No hay límite de tamaño para las solicitudes de publicación.

• Para el tipo de datos de los parámetros, GET solo acepta caracteres ASCII, mientras que POST no tiene restricciones.

• GET es menos seguro que POST porque los parámetros se exponen directamente en la URL, por lo que no se pueden usar para pasar información confidencial.

• GET genera un paquete TCP; POST genera dos paquetes TCP.

• El método get necesita usar Request.QueryString para obtener el valor de la variable, y el método post usa Request.Form para obtener el valor de la variable.

• (La mayoría) de los navegadores suelen limitar la longitud de la URL a 2K bytes, mientras que (la mayoría) de los servidores manejan URL de hasta 64K de tamaño. GET y POST son esencialmente conexiones TCP, no hay diferencia. Sin embargo, debido a las regulaciones de HTTP y las limitaciones del navegador/servidor, muestran algunas diferencias en el proceso de solicitud. Para las solicitudes GET, el navegador enviará el encabezado http y los datos juntos, y el servidor responderá con 200 (datos de retorno); para POST, el navegador enviará primero el encabezado, el servidor responderá con 100 continuar, el navegador enviará data, y el servidor responderá 200 ok (return data). Debido a que POST requiere dos pasos y consume un poco más de tiempo, parece que GET es más eficiente que POST. Por lo tanto, el equipo de Yahoo recomienda reemplazar POST con GET para optimizar el rendimiento del sitio web, pero tenga cuidado.

  • Tanto GET como POST tienen su propia semántica y no se pueden mezclar de forma casual.
  • Según la investigación, cuando el entorno de la red es bueno, la diferencia entre el tiempo para enviar un paquete y el tiempo para enviar dos paquetes básicamente puede ignorarse. En el caso de un entorno de red deficiente, TCP con dos paquetes tiene una gran ventaja para verificar la integridad del paquete de datos.
  • No todos los navegadores envían el paquete dos veces en el POST, Firefox solo lo envía una vez.

Realice una solicitud HTTP basada en el marco SpringBoot

1. Introducir la dependencia de SpringBoot

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

2. Clase de herramienta de solicitud HttpRestUtils

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. Uso de herramientas

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);
    }
}