spring-boot réalise le service de transfert d'interface et prend en charge diverses requêtes telles que get et post en même temps

spring-boot réalise le service de transfert d'interface et prend en charge diverses requêtes telles que get et post en même temps

(1) Nouvelle classe : ProxyController.java

package com.taobao.product.controller;

import com.taobao.framework.HttpResult;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

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

import javax.servlet.http.HttpServletRequest;
import java.net.URISyntaxException;
import java.util.Enumeration;

import org.springframework.http.MediaType;
import java.io.IOException;
import java.net.URI;
import java.util.Collections;
import java.util.List;

import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.HttpClients;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;

/**
 * @Author: sunkaiyuan
 * @Date: 2023-05-23 9:02
 * @Desperation: TODO
 */
@Api(tags = "代理服务")
@RestController
@RequestMapping("/proxy")
@Slf4j
public class ProxyController {
    
    

    @ApiOperation(value = "接口转发")
    @RequestMapping("/dahua/**")
    public ResponseEntity<String> handleRequest(HttpServletRequest request) throws IOException, URISyntaxException, NoSuchAlgorithmException, KeyStoreException, KeyManagementException {
    
    
        String method = request.getMethod();
        String path = getPath(request);
        // 去掉url中的/proxy/dahua
        path = path.substring(request.getContextPath().length() + "/proxy/dahua".length());
        URI targetUri = new URI("https://121.26.142.174:8443" + path);
        System.out.println(targetUri);
        HttpHeaders headers = getRequestHeaders(request);
        HttpEntity<?> entity = new HttpEntity<>(headers);

        RestTemplate restTemplate = new RestTemplate(getSecureHttpRequestFactory());
        if (method.equalsIgnoreCase(HttpMethod.GET.name())) {
    
    
            return restTemplate.exchange(targetUri, HttpMethod.GET, entity, String.class);
        } else if (method.equalsIgnoreCase(HttpMethod.POST.name())) {
    
    
            String requestBody = getRequestBody(request);
            headers.setContentType(MediaType.APPLICATION_JSON);
            HttpEntity<String> postEntity = new HttpEntity<>(requestBody, headers);
            return restTemplate.exchange(targetUri, HttpMethod.POST, postEntity, String.class);
        } else {
    
    
            return ResponseEntity.badRequest().body("Unsupported request method: " + method);
        }
    }

    private String getPath(HttpServletRequest request) {
    
    
        String contextPath = request.getContextPath();
        String servletPath = request.getServletPath();
        String pathInfo = request.getPathInfo() != null ? request.getPathInfo() : "";
        return contextPath + servletPath + pathInfo;
    }

    private HttpHeaders getRequestHeaders(HttpServletRequest request) {
    
    
        HttpHeaders headers = new HttpHeaders();
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
    
    
            String headerName = headerNames.nextElement();
            List<String> headerValues = Collections.list(request.getHeaders(headerName));
            headers.put(headerName, headerValues);
        }
        return headers;
    }

    private String getRequestBody(HttpServletRequest request) throws IOException {
    
    
        return request.getReader().lines().reduce("", (accumulator, actual) -> accumulator + actual);
    }

    private HttpComponentsClientHttpRequestFactory getSecureHttpRequestFactory() throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException {
    
    
        TrustManager[] trustAllCerts = new TrustManager[] {
    
     new X509TrustManager() {
    
    
            public X509Certificate[] getAcceptedIssuers() {
    
    
                return null;
            }

            public void checkClientTrusted(X509Certificate[] certs, String authType) {
    
    
            }

            public void checkServerTrusted(X509Certificate[] certs, String authType) throws CertificateException {
    
    
            }
        } };

        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, trustAllCerts, null);

        SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);

        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(HttpClients.custom().setSSLSocketFactory(csf).build());

        return requestFactory;
    }
}

(2) Description du code :

Il s'agit d'une classe Java nommée ProxyController. Le code contient les méthodes suivantes :

handleRequest(HttpServletRequest request)

Il s'agit d'une méthode publique avec un type de retour ResponseEntity<String>, qui lève quelques exceptions possibles. Le but de cette méthode est de traiter la requête HTTP et de renvoyer la réponse correspondante en fonction de l'objet de requête entrant. Cette méthode est @RequestMapping("/dahua/**")marquée par l'annotation , ce qui signifie que /proxy/dahuacette méthode ne sera appelée que lorsque l'URL contient . Cette méthode implémente la fonctionnalité de transfert d'une demande entrante vers une autre URL et de renvoi d'une réponse. Si la demande n'est pas un GET ou un POST, une réponse d'erreur est renvoyée.

getPath(HttpServletRequest request)

Il s'agit d'une méthode privée avec un type de retour de String. Cette méthode reçoit un objet de requête, obtient le chemin de contexte, le chemin de servlet et les informations de chemin à partir de celui-ci, et les combine dans un chemin d'URL complet et le renvoie.

getRequestHeaders(HttpServletRequest request)

Il s'agit d'une méthode privée avec un type de retour de HttpHeaders. Cette méthode prend un objet de requête, en extrait tous les en-têtes de requête, les place dans un nouvel HttpHeadersobjet et renvoie cet objet.

getRequestBody(HttpServletRequest request)

Il s'agit d'une méthode privée avec un type de retour String, qui peut lever une exception IO. Cette méthode prend un objet de requête, en extrait le corps de la requête (le cas échéant), le convertit en une chaîne et renvoie cette chaîne.

getSecureHttpRequestFactory()

Il s'agit d'une méthode privée avec un type de retour HttpComponentsClientHttpRequestFactory, qui peut lever des exceptions. Le but de cette méthode est de créer une fabrique de requêtes HTTP sécurisée qui nous permet de nous connecter à une autre URL via HTTPS. Cette méthode utilise TrustManageret SSLContextpour implémenter l'approbation de tous les certificats, la définit comme fabrique de sockets SSL dans la fabrique de requêtes et renvoie cette fabrique de requêtes.

En plus de cela, le code contient également des annotations et des déclarations de variables. Parmi eux, @ApiOperationl'annotation indique que la méthode contient des informations d'instruction d'opération ; @RequestMapping("/dahua/**")il indique que la méthode ne sera appelée que lorsque l'URL contient /proxy/dahua. Les variables method, path, targetUri, headers, entity, restTemplate, postEntity, requestFactoryetc. ont des utilisations correspondantes dans le code.