SpringBoot 透传转发

1、接口

/**
 * 转发
 */
@Api(tags = "转发接口")
@RestController
@RequestMapping("/qgg")
@Slf4j
public class QggProxyController {

    @Value("${qgg-url-address}")
    private String qggUrlAddress;

    @Value("${qgg-proxy-ip}")
    private String qggProxyIp;

    @Value("${qgg-proxy-port}")
    private Integer qggProxyPort;

    @ApiOperation(value = "接口转发")
    @RequestMapping(value = "/**",method = {RequestMethod.GET, RequestMethod.POST})
    public ResponseEntity<String> handleRequest(HttpServletRequest request) {
        try {
            String method = request.getMethod();
            String path = getPath(request);
            // 去掉url中的/qgg
            path = path.substring(request.getContextPath().length() + "/qgg".length());
            URI targetUri = new URI(qggUrlAddress + path);
            HttpHeaders headers = getHeaders(request);
            log.info("请求地址：" + targetUri);

            RestTemplate restTemplate = new RestTemplate();
            restTemplate.setRequestFactory(generateHttpsRequestFactory(qggProxyIp,qggProxyPort));

            if (method.equalsIgnoreCase(HttpMethod.GET.name())) {
                //入参处理
                Map<String, String[]> map = request.getParameterMap();
                String params = getParameters(map);
                //请求头
                HttpEntity<?> getEntity = new HttpEntity<>(headers);
                return restTemplate.exchange(targetUri + params, HttpMethod.GET, getEntity, String.class, map);
            } else if (method.equalsIgnoreCase(HttpMethod.POST.name())) {
                //获取入参
                RequestWrapper requestWrapper = new RequestWrapper(request);
                String requestBody = requestWrapper.getBody();
                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);
            }
        }catch (Exception e) {
            log.error(e.getMessage(), e);
            return ResponseEntity.badRequest().body("qgg转发出错");
        }

    }

    public static HttpComponentsClientHttpRequestFactory generateHttpsRequestFactory(String pubProxyIp, Integer pubProxyPort) {
        try {
            TrustStrategy acceptingTrustStrategy = (x509Certificates, authType) -> true;
            SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
            SSLConnectionSocketFactory connectionSocketFactory = new SSLConnectionSocketFactory(sslContext, new NoopHostnameVerifier());

            HttpClientBuilder httpClientBuilder = HttpClients.custom();
            httpClientBuilder.setSSLSocketFactory(connectionSocketFactory);
            // 代理url, port
            httpClientBuilder.setProxy(new HttpHost(pubProxyIp, pubProxyPort, "http"));
            CloseableHttpClient httpClient = httpClientBuilder.build();
            HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
            factory.setHttpClient(httpClient);
            factory.setConnectTimeout(10 * 1000);
            factory.setReadTimeout(30 * 1000);
            return factory;
        } catch (Exception e) {
            throw new RuntimeException("创建HttpsRestTemplate失败", e);
        }
    }

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

    /**
     * header 处理
     */
    private HttpHeaders getHeaders(HttpServletRequest request) {
        HttpHeaders headers = new HttpHeaders();
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            String headerValue = request.getHeader(headerName);
            headers.add(headerName, headerValue);
        }
        return headers;
    }

    /**
     * get 请求拼接入参
     * 格式：?name={name}&name1={name1}&name2={name2}
     */
    private String getParameters(Map<String, String[]> map) {
        StringBuilder builder = new StringBuilder();
        for (String key : map.keySet()) {
            builder.append(key).append("={").append(key).append("}&");
        }
        if (StringUtils.isNotBlank(builder.toString())){
            return "?" + builder.substring(0, builder.length() - 1);
        }else{
            return "";
        }
    }

}

2、RequestWrapper

public class RequestWrapper extends HttpServletRequestWrapper {

    private String body;

    public RequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null;
        try {
            InputStream inputStream = request.getInputStream();
            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
                char[] charBuffer = new char[128];
                int bytesRead = -1;
                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    stringBuilder.append(charBuffer, 0, bytesRead);
                }
            }
        } catch (IOException ex) {
            throw ex;
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException ex) {
                    throw ex;
                }
            }
        }
        body = stringBuilder.toString();
    }

    /**
     * 重写getInputStream， 从body中获取请求参数
     * @return
     * @throws IOException
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8));
        ServletInputStream servletInputStream = new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {

            }

            @Override
            public int read() {
                return byteArrayInputStream.read();
            }
        };
        return servletInputStream;
    }

    /**
     * 重写获取 字符流的方式
     * @return
     * @throws IOException
     */
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream(), Charsets.UTF_8));
    }

    /**
     * 直接返回获取 body
     * @return
     */
    public String getBody() {
        return this.body;
    }
}