zoukankan      html  css  js  c++  java
  • 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()+"	base:"+base+"	host:"+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";
            }
        }
    }
  • 相关阅读:
    【我也不知道是从哪儿来的题】—树(矩阵树定理)
    【我也不知道是从哪儿来的题】—树(矩阵树定理)
    【BJOI2019 Day2】简要题解
    【BJOI2019 Day2】简要题解
    【BJOI2019 Day1】简要题解
    【BJOI2019 Day1】简要题解
    【BZOJ3935】—RBTree(树形dp)
    【BZOJ3935】—RBTree(树形dp)
    2016-8-12
    深入理解web项目的配置文件
  • 原文地址:https://www.cnblogs.com/lovetl/p/13294187.html
Copyright © 2011-2022 走看看