HttpClient实现前端请求转发到另一个服务，解决部署到tomcat中多后端跨域问题

本篇博客是复制粘贴的公司项目的代码，网上搜了不少请求转发的但是没有符合我想要的，
本篇请求转发试用于 A->B->C  A发请求到B B转发到C服务器，
写这个的原因是公司vue项目对应多个后台，
打包到tomcat中只有一个地址能访问其他的后台地址显示跨域，所以在一个后台做请求转发来解决这个问题

 

import lombok.extern.slf4j.Slf4j;
import org.apache.http.*;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.util.WebUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;


@Slf4j
public class HttpUtil {
    public static void httpGet(String url, HttpServletRequest request, HttpServletResponse response,
                                   List<NameValuePair> additionalMap) {
        CloseableHttpClient httpClient = SSLUtils.createSSLClientDefault();
        HttpGet httpGet = new HttpGet(RedirectUtil.getHost(url));

        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            httpGet.addHeader(headerName, request.getHeader(headerName));
        }
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        Enumeration<String> parameterNames = request.getParameterNames();
        while (parameterNames.hasMoreElements()) {
            String parameterName = parameterNames.nextElement();
            for (String value : request.getParameterValues(parameterName)) {
                if (value!=null&&!value.equals("null")) params.add(new BasicNameValuePair(parameterName, value));
            }
        }
        params.addAll(additionalMap);
        for (NameValuePair map : additionalMap) {
            log.info(map.getName() + ":" + map.getValue());
        }
        HttpResponse httpResponse = null;
        try {
//            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, RedirectUtil.SERVER_CHARSET);
//            httpGet.setEntity(entity);
            httpResponse = httpClient.execute(httpGet);
            if (httpResponse != null) {
                HttpEntity responseEntity = httpResponse.getEntity();
                if (responseEntity != null) {
                    log.info(responseEntity.toString());
                    responseEntity.writeTo(response.getOutputStream());
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (httpResponse != null) {
            response.setStatus(httpResponse.getStatusLine().getStatusCode());
            //logger.info(httpResponse.toString());
            HeaderIterator headerIterator = httpResponse.headerIterator();
            while (headerIterator.hasNext()) {
                Header header = headerIterator.nextHeader();
                if (header.getName().equals("Content-Type")) {
                    //response.addHeader(header.getName(), header.getValue());
                    response.setHeader(header.getName(), header.getValue());//或许可以解决重定向乱码(好像没影响)
                }
            }
            response.setHeader("Server", "nginx");
        }
    }
    public static void httpPost(String url, HttpServletRequest request, HttpServletResponse response,
                                List<NameValuePair> additionalMap) {
        CloseableHttpClient httpClient = SSLUtils.createSSLClientDefault();
        HttpPost httpPost = new HttpPost(RedirectUtil.getHost(url));

        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            httpPost.addHeader(headerName, request.getHeader(headerName));
        }
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        Enumeration<String> parameterNames = request.getParameterNames();
        while (parameterNames.hasMoreElements()) {
            String parameterName = parameterNames.nextElement();
            for (String value : request.getParameterValues(parameterName)) {
                if (value!=null&&!value.equals("null")) params.add(new BasicNameValuePair(parameterName, value));
            }
        }
        params.addAll(additionalMap);
        
        
        for (NameValuePair map : additionalMap) {
            log.info(map.getName() + ":" + map.getValue());
        }
        HttpResponse httpResponse = null;
        try {
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, RedirectUtil.SERVER_CHARSET);
            httpPost.setEntity(entity);
            httpResponse = httpClient.execute(httpPost);
            if (httpResponse != null) {
                HttpEntity responseEntity = httpResponse.getEntity();
                if (responseEntity != null) {
                    log.info(responseEntity.toString());
                    responseEntity.writeTo(response.getOutputStream());
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (httpResponse != null) {
            response.setStatus(httpResponse.getStatusLine().getStatusCode());
            //logger.info(httpResponse.toString());
            HeaderIterator headerIterator = httpResponse.headerIterator();
            while (headerIterator.hasNext()) {
                Header header = headerIterator.nextHeader();
                if (header.getName().equals("Content-Type")) {
                    //response.addHeader(header.getName(), header.getValue());
                    response.setHeader(header.getName(), header.getValue());//或许可以解决重定向乱码(好像没影响)
                }
            }
            response.setHeader("Server", "nginx");
        }
    }
    public static void httpPut(String url, HttpServletRequest request, HttpServletResponse response,
                               List<NameValuePair> additionalMap) {
        CloseableHttpClient httpClient = SSLUtils.createSSLClientDefault();

        HttpPut httpPut = new HttpPut(RedirectUtil.getHost(url));

        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            httpPut.addHeader(headerName, request.getHeader(headerName));
        }
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        Enumeration<String> parameterNames = request.getParameterNames();
        while (parameterNames.hasMoreElements()) {
            String parameterName = parameterNames.nextElement();
            for (String value : request.getParameterValues(parameterName)) {
                if (value!=null&&!value.equals("null")) params.add(new BasicNameValuePair(parameterName, value));
            }
        }
        params.addAll(additionalMap);
        for (NameValuePair map : additionalMap) {
            log.info(map.getName() + ":" + map.getValue());
        }
        HttpResponse httpResponse = null;
        try {
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, RedirectUtil.SERVER_CHARSET);
            httpPut.setEntity(entity);
            httpResponse = httpClient.execute(httpPut);
            if (httpResponse != null) {
                HttpEntity responseEntity = httpResponse.getEntity();
                if (responseEntity != null) {
                    log.info(responseEntity.toString());
                    responseEntity.writeTo(response.getOutputStream());
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (httpResponse != null) {
            response.setStatus(httpResponse.getStatusLine().getStatusCode());
            //logger.info(httpResponse.toString());
            HeaderIterator headerIterator = httpResponse.headerIterator();
            while (headerIterator.hasNext()) {
                Header header = headerIterator.nextHeader();
                if (header.getName().equals("Content-Type")) {
                    //response.addHeader(header.getName(), header.getValue());
                    response.setHeader(header.getName(), header.getValue());//或许可以解决重定向乱码(好像没影响)
                }
            }
            response.setHeader("Server", "nginx");
        }
    }

    public static void httpDelete(String url, HttpServletRequest request, HttpServletResponse response,
                               List<NameValuePair> additionalMap) {
        String method = request.getMethod();
        CloseableHttpClient httpClient = SSLUtils.createSSLClientDefault();

        HttpDelete httpDelete = new HttpDelete(RedirectUtil.getHost(url));

        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            httpDelete.addHeader(headerName, request.getHeader(headerName));
        }
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        Enumeration<String> parameterNames = request.getParameterNames();
        while (parameterNames.hasMoreElements()) {
            String parameterName = parameterNames.nextElement();
            for (String value : request.getParameterValues(parameterName)) {
                if (value!=null&&!value.equals("null")) params.add(new BasicNameValuePair(parameterName, value));
            }
        }
        params.addAll(additionalMap);
        for (NameValuePair map : additionalMap) {
            log.info(map.getName() + ":" + map.getValue());
        }
        HttpResponse httpResponse = null;
        try {
//            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, RedirectUtil.SERVER_CHARSET);
//            httpDelete.setEntity(entity);
            httpResponse = httpClient.execute(httpDelete);
            if (httpResponse != null) {
                HttpEntity responseEntity = httpResponse.getEntity();
                if (responseEntity != null) {
                    log.info(responseEntity.toString());
                    responseEntity.writeTo(response.getOutputStream());
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (httpResponse != null) {
            response.setStatus(httpResponse.getStatusLine().getStatusCode());
            //logger.info(httpResponse.toString());
            HeaderIterator headerIterator = httpResponse.headerIterator();
            while (headerIterator.hasNext()) {
                Header header = headerIterator.nextHeader();
                if (header.getName().equals("Content-Type")) {
                    //response.addHeader(header.getName(), header.getValue());
                    response.setHeader(header.getName(), header.getValue());//或许可以解决重定向乱码(好像没影响)
                }
            }
            response.setHeader("Server", "nginx");
        }
    }

    public static String httpRequest(String hostPrefix, String url, List<NameValuePair> params) {
        CloseableHttpClient httpClient = SSLUtils.createSSLClientDefault();
        log.info(url);
        HttpPost httpPost = new HttpPost(RedirectUtil.getHost(hostPrefix, url));
        try {
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, RedirectUtil.SERVER_CHARSET);
            httpPost.setEntity(entity);
            HttpResponse httpResponse = httpClient.execute(httpPost);
            if (httpResponse != null) {
                HttpEntity responseEntity = httpResponse.getEntity();
                if (responseEntity != null) {
                    String result = EntityUtils.toString(responseEntity, RedirectUtil.SERVER_CHARSET);
                    log.info(result);
                    return result;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 使用httpclint 发送文件
     * @author: qingfeng
     * @date: 2019-05-27
     * @param file
     *            上传的文件
     * @return 响应结果
     */
    public static void uploadFile(String url , MultipartFile file, String fileParamName,HttpServletRequest request) {
        try {
            RestTemplateUtils restTemplateUtils = new RestTemplateUtils();
            ByteArrayResource resource = new MultipartFileResource(file);
            MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
            param.add(fileParamName, resource);
            log.info("请求采集服务url:{}",url);
           restTemplateUtils.sendPostFile(RedirectUtil.getHost(url),param,request);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

 

import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import me.zhengjie.modules.utils.HttpUtil;
import org.apache.http.NameValuePair;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.util.WebUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;

@Slf4j
@Controller
@RequestMapping(value = "/admin")
public class RedirectController {

    //在user项目中关于其它子项目比如trade项目的jsp页面
    //ajax请求需要加上前缀/user/redirect
    private static int offset = "/admin/".length();

    @ApiOperation(value = "重定向", hidden = true)
    @RequestMapping(value = "/**", method = {RequestMethod.POST, RequestMethod.GET})
    public void redirect(HttpServletRequest request, HttpServletResponse response) throws Exception {
        String method = request.getMethod();
        String url = request.getRequestURI();
        String contentType = request.getContentType();
        int base = request.getContextPath().length();
        String host = url.substring(base + offset, url.length());//例如: trade
        log.info("request.getRequestURI():"+request.getRequestURI()+"\tbase:"+base+"\thost:"+host);
        if("GET".equals(method)){
            HttpUtil.httpGet(url,request, response, new ArrayList<NameValuePair>());
        }else if("POST".equals(method)){
            if (contentType != null && contentType.toLowerCase().startsWith("multipart/")) {
                MultipartHttpServletRequest multipartRequest =
                        WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class);
                MultipartFile file = multipartRequest.getFile("file");
                HttpUtil.uploadFile(url,file,"file",request);
            }else{
                HttpUtil.httpPost(url,request, response, new ArrayList<NameValuePair>());
            }
        }else if("PUT".equals(method)){
            HttpUtil.httpPut(url,request, response, new ArrayList<NameValuePair>());
        }else if("DELETE".equals(method)) {
            HttpUtil.httpDelete(url,request, response, new ArrayList<NameValuePair>());
        }
        response.getOutputStream().flush();
        response.getOutputStream().close();

    }

}

import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;

public class RedirectUtil {

    public static boolean DEBUG;

    public static String getServerHost() {
        return SERVER_HOST;
    }

    static String SERVER_HOST;
    static int SERVER_PORT;
    static String SERVER_PROTOCOL;
    static String SERVER_CHARSET;
    static Map<String, String> hostPrefixMap;

    static {
//        ResourceBundle bundle = ResourceBundle.getBundle("server");
//        SERVER_HOST = bundle.getString("host");
//        SERVER_PORT = Integer.parseInt(bundle.getString("port"));
//        SERVER_PROTOCOL = bundle.getString("protocol");
//        SERVER_CHARSET = bundle.getString("charset");
//        DEBUG = SERVER_HOST.equals("localhost");
//        hostPrefixMap = new HashMap<String, String>();
//        hostPrefixMap.put("user", bundle.getString("user"));
//        hostPrefixMap.put("algorithm", bundle.getString("algorithm"));
//        hostPrefixMap.put("image", bundle.getString("image"));
//
        SERVER_HOST = "127.0.0.1";
        SERVER_PORT = 8088;
        SERVER_PROTOCOL = "http";
//        SERVER_CHARSET = bundle.getString("charset");
        DEBUG = SERVER_HOST.equals("localhost");
        hostPrefixMap = new HashMap<String, String>();
        hostPrefixMap.put("relay", "relay");
    }

    //获取是否为本地调试
    public static Boolean getDebug(){
        return DEBUG;
    }

    public static String getHost(String hostPrefix) {
        return getHost(hostPrefix, "");
    }

    public static String getHost(String hostPrefix, String url) {
//        hostPrefix = hostPrefixMap.get(hostPrefix);//例如: trade
        String host = SERVER_HOST;
        if (hostPrefix != null && !hostPrefix.isEmpty()) {
            url = "/" + hostPrefix;//例如: / + image + /image/report/getReportList
        }
        try {
            return new URL(SERVER_PROTOCOL, host, SERVER_PORT, url).toString();
        } catch (MalformedURLException e) {
            e.printStackTrace();
            return SERVER_PROTOCOL + "://" + host + ":" + SERVER_PORT + "url";
        }
    }
}