Java自定义开发义反向代理

最新推荐文章于 2024-07-24 09:30:09 发布
最新推荐文章于 2024-07-24 09:30:09 发布
阅读量612 收藏 1
点赞数 2
文章标签： java spring http proxy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RenZhXu/article/details/113642327
版权

功能描述

需要代理superMap iServer服务及各个系统公布接口，需要做访问限制，申请然后生成key,进行验证才可以正常使用接口,代理的服务需要提前在数据库注册，并生成代理地址，给使用者代理地址，在后台根据代理地址携带信息查询到原地址进行请求，建议使用Redis缓存数据库保存地址数据及访问量，提高代理速度

1.包引入

<dependency>
	<groupId>org.apache.httpcomponents</groupId>
	<artifactId>httpclient</artifactId>
</dependency>

2.二三维原地址及代理地址生成格式

二维：
原地址：http://199.215.110.119:8090/iserver/services/map-JN/rest/maps/综合交通规划
代理地址：http://127.0.0.1:8010/map/37
三维：
原地址：http://199.215.110.119:8040/iserver/services/3D/rest/realspace/datas/绿化
代理地址：http://127.0.0.1:8010/scene/38/rest/realspace/config
注意
二维可以在代理地址后面拼接参数，但是三维不可以，需要使用以下代码调用

viewer.scene.addS3MTilesLayerByScp(
 	  "http://127.0.0.1:8010/scene/38/rest/realspace/config", {
      name: '绿化',
      customRequestHeaders:{
          key:'您的应用key',
          // 参数......
      }
  })

3.代理服务代码

/**
 * 需要在安全框架下允许访问此接口
 */
import com.tydt.common.utils.ProxyServiceUtils;
import com.tydt.common.utils.StringUtils;
import com.tydt.project.web.service.domain.ProxyService;
import com.tydt.project.web.service.service.IProxyServiceService;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URLEncoder;
import java.util.Enumeration;
import java.util.Map;
import java.util.Set;

@Controller
@RequestMapping
@CrossOrigin
public class SuperMapProxyController {

    @Autowired
    private IProxyServiceService proxyService;

    /**
     * 代理三维服务
     * @param request
     * @param response
     */
    @RequestMapping(value = "/scene/**",method = {RequestMethod.OPTIONS,RequestMethod.POST,RequestMethod.GET})
    public void sceneProxy(HttpServletRequest request, HttpServletResponse response){
        String method = request.getMethod();
        String key = request.getHeader("key");
        try {
            if("GET".equals(method)){
                this.doSceneGet(request,response,key);
            }else {
                this.doScenePost(request,response,key);
            }
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }
    }

    /**
     * 二维地图代理接口
     * @param request
     * @param response
     * @throws Exception
     */
    @GetMapping("/map/**")
    public void mapProxy(HttpServletRequest request, HttpServletResponse response){
        String key = request.getParameter("key");
        try {
            doMapGet(request,response,key);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 维地图代理
     * @param request
     * @param response
     * @param key
     * @throws IOException
     */
    private void doMapGet(HttpServletRequest request, HttpServletResponse response, String key) throws Exception {
        if(StringUtils.isEmpty(key)){
            response.setHeader("content-type", "text/html;charset=utf-8");
            response.getWriter().write("{code:403,msg:'缺少key值'}");
        }else{
            response.setContentType("image/png");
            // 获取前端openLayer请求参数集合
            Map<String, String[]> parameterMap = request.getParameterMap();
            // 获取服务ID编号
            Long serviceId = Long.valueOf(request.getRequestURL().toString().split("/")[5]);
            // 判断服务是否通过申请
            Integer res = proxyService.selectMyService(serviceId, key);
            if(res != null && res > 0){
                // 获取原地址
                ProxyService ps = proxyService.selectProxyServiceById(serviceId);
                // 被代理url
                String proxyUrl = ps.getServiceUrl();
                Set<String> keySet = parameterMap.keySet();
                String params = "";
                for (String k : keySet) {
                    if("key".equals(k)){
                        continue;
                    }
                    // 该参数是对象，不单独解析iserver不识别
                    if("origin".equals(k)){
                        params += (k + "=" + encoding(parameterMap.get(k)[0]) + "&");
                        continue;
                    }
                    // 代理时，=、&符号不必转码，否则iserver不识别
                    params += (k + "=" + parameterMap.get(k)[0] + "&");
                }
                int index = params.lastIndexOf("&");
                // 原地址
                String sourceUrl = proxyUrl + "/tileImage.png?" + params.substring(0,index);
                // 中文正则表达式
                String reg = "[^\u4e00-\u9fa5]";
                // 判断地址中是否存在中文
                if(!sourceUrl.matches(reg)){
                    String hzUrl = sourceUrl.replaceAll(reg,"");
                    proxyUrl = sourceUrl.replaceAll(hzUrl,encoding(hzUrl));
                }
                // 访问量自增1
                proxyService.webUsedCountIncreasing(serviceId);
                CloseableHttpClient httpclient = HttpClients.createDefault();
                CloseableHttpResponse closeableHttpResponse;
                //创建get请求
                HttpGet httpGet = new HttpGet(proxyUrl);
                Enumeration<String> headerNames = request.getHeaderNames();
                // 设置请求头
                while (headerNames.hasMoreElements()) {
                    String element = headerNames.nextElement();
                    httpGet.addHeader(element,request.getHeader(element));
                }
                // 提交参数发送请求
                closeableHttpResponse = httpclient.execute(httpGet);
                // 得到响应状态码
                int statusCode = closeableHttpResponse.getStatusLine().getStatusCode();
                // 判断响应信息是否正确
                if (statusCode != HttpStatus.SC_OK&&statusCode != HttpStatus.SC_NOT_MODIFIED) {
                    // 终止并抛出异常
                    httpGet.abort();
                    response.getWriter().write("HttpClient,error status code :" + statusCode);
                }
                HttpEntity entity = closeableHttpResponse.getEntity();
                if(StringUtils.isNotNull(entity)){
                    entity.writeTo(response.getOutputStream());
                }
            }else {
                // 审核未通过或者未申请该服务
                response.getOutputStream().write("{code:401,msg:'审核未通过或者未申请该服务'}".getBytes());
                return;
            }
        }
    }

    /**
     * 三维场景登录
     * @param request
     * @param response
     * @param key
     * @throws IOException
     */
    private void doScenePost(HttpServletRequest request, HttpServletResponse response,String key)throws IOException {
        response.setHeader("content-type", "text/html;charset=utf-8");
        if(StringUtils.isEmpty(key)){
            response.getOutputStream().write("{code:403,msg:'缺少key值'}".getBytes());
        }else {
            String requestUrl = request.getRequestURL().toString();
            String serviceId = requestUrl.split("/")[4];
            Integer res = ProxyServiceUtils.queryMyService(serviceId,key);
            // 审核已通过
            if(res != null&&res > 0){
                // 被代理url
                String proxyUrl = ProxyServiceUtils.queryServiceUrl(serviceId);
                if(StringUtils.isNotEmpty(proxyUrl)){
                    // 登录
                    if(requestUrl.indexOf("/login.json") > 0){
                        // 组装登录地址
                        if(proxyUrl.indexOf("/datas/") > 0){
                            proxyUrl = proxyUrl.split("/datas/")[0] + "/login.json";
                        }else {
                            response.getOutputStream().write("{code:404,msg:'地址格式不正确'}".getBytes());
                        }
                    }
                    // 访问量自增1
                    proxyService.webUsedCountIncreasing(Long.valueOf(serviceId));
                    CloseableHttpClient httpclient = HttpClients.createDefault();
                    CloseableHttpResponse closeableHttpResponse;
                    HttpPost httpPost = new HttpPost(proxyUrl);
                    // 读取post请求参数
                    BufferedReader reader = new BufferedReader(new InputStreamReader(request.getInputStream()));
                    String line;
                    StringBuilder sb = new StringBuilder();
                    while ((line = reader.readLine()) != null) {
                        sb.append(line);
                    }
                    StringEntity stringEntity = new StringEntity(sb.toString());
                    httpPost.setEntity(stringEntity);
                    // 请求
                    closeableHttpResponse = httpclient.execute(httpPost);
                    // 得到响应信息
                    int statusCode = closeableHttpResponse.getStatusLine().getStatusCode();
                    if (statusCode != HttpStatus.SC_CREATED) {
                        // 终止并抛出异常
                        httpPost.abort();
                        response.getOutputStream().write(("HttpClient,error status code :" + statusCode).getBytes());
                    }
                    HttpEntity entity = closeableHttpResponse.getEntity();
                    entity.writeTo(response.getOutputStream());
                }else {
                    response.getOutputStream().write("{code:403,msg:'请检查地址是否正确'}".getBytes());
                }
            }else {
                // 审核未通过或者未申请该服务
                response.getOutputStream().write("{code:401,msg:'审核未通过或者未申请该服务'}".getBytes());
                return;
            }
        }
    }

    /**
     * 三维请求数据
     * @param request
     * @param response
     * @param key
     * @throws IOException
     */
    private void doSceneGet(HttpServletRequest request, HttpServletResponse response,String key) throws IOException{
        response.setHeader("content-type", "text/html;charset=utf-8");
        // 判断是否存在key
        if(StringUtils.isEmpty(key)){
            response.getOutputStream().write("{code:403,msg:'缺少key值'}".getBytes());
        }else{
            String requestUrl = request.getRequestURL().toString();
            String serviceId = request.getRequestURL().toString().split("/")[4];
            Integer res = ProxyServiceUtils.queryMyService(serviceId,key);;
            if(res != null&&res > 0){
                // 被代理url
                String proxyUrl = ProxyServiceUtils.queryServiceUrl(serviceId);
                // 登录
                if(requestUrl.indexOf("/login.json") > 0){
                    // 组装登录地址
                    if(proxyUrl.indexOf("/datas/") > 0){
                        proxyUrl = proxyUrl.split("/datas/")[0] + "/login.json";
                    }else {
                        response.getOutputStream().write("{code:404,msg:'地址格式不正确'}".getBytes());
                    }
                }
                // 请求图层配置文件
                if(requestUrl.endsWith("/config")){
                    proxyUrl = proxyUrl + "/config";
                }
                // .s3m文件
                if(requestUrl.indexOf(".s3m") > 0){
                    proxyUrl = proxyUrl + "/" + requestUrl.split("/realspace/")[1];
                }
                // 水面请求
                if(proxyUrl.indexOf(".water") > 0){
                    // 访问量自增1
                    proxyService.webUsedCountIncreasing(Long.valueOf(serviceId));
                }
                CloseableHttpClient httpclient = HttpClients.createDefault();
                CloseableHttpResponse closeableHttpResponse;
                //创建get请求
                HttpGet httpGet = new HttpGet(proxyUrl);
                // 设置请求和传输超时时间
                RequestConfig requestConfig = RequestConfig.custom()
                        .setSocketTimeout(4000).setConnectTimeout(4000).build();
                httpGet.setConfig(requestConfig);
                // 提交参数发送请求
                closeableHttpResponse = httpclient.execute(httpGet);
                // 得到响应状态码
                int statusCode = closeableHttpResponse.getStatusLine().getStatusCode();
                // 判断响应信息是否正确
                if (statusCode != HttpStatus.SC_OK&&statusCode != HttpStatus.SC_NOT_MODIFIED) {
                    // 终止并抛出异常
                    httpGet.abort();
                    response.getOutputStream().write(("HttpClient,error status code :" + statusCode).getBytes());
                }
                HttpEntity entity = closeableHttpResponse.getEntity();
                entity.writeTo(response.getOutputStream());
            }else {
                // 审核未通过或者未申请该服务
                response.getOutputStream().write("{code:401,msg:'审核未通过或者未申请该服务'}".getBytes());
                return;
            }
        }
    }

    /**
     * 转义字符串
     * @param str
     * @return
     * @throws Exception
     */
    private String encoding(String str) throws Exception{
        return URLEncoder.encode(str,"UTF-8");
    }

}

4.注意事项

代理时切忌不要自建类HttpServlet来实现，虽然代理效果可以实现，但项目如果使用了安全框架如spring-security,即使加入可以匿名访问，前端调用时会出现跨域问题，即使在doGet或doPost设置允许跨域访问也会被拦截，大概是因为自建Servlet不受spring管理。

RenZhXu
关注
利用Java实现反向代理
taokeng的博客
11-17 5710
利用Java实现反向代理 最近有个需求要做一个反向代理，在GitHub上找到了一个已实现好了的项目，记录一下，传送门：https://github.com/mitre/HTTP-Proxy-Servlet 引入依赖 <dependency> <groupId>org.mitre.dsmiley.httpproxy</groupId> <artifactId>smiley-http-proxy-servlet</artifactId>
如何在JAVA项目中实现反向代理功能？
永远不会懂
02-21 7741
前言（什么是反向代理） 反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。 举个例子，比如我访问百度（www.baidu.com）,但是我们其实并不知道百度内部到底有多少台服务器、百度是怎么处理这次请求的以及我们应该访问那台服务器。我们只是知道我访问了百度（www.baidu.com）的域名或者公网IP，然后就返回
Java实现的反向代理程序（源码版）
11-22
使用Java编写的反向代理程序（源代码），通过简单的参数配置即可实现某些特定站点的反向代理，并在此过程中改变一些站点的特定行为。例如：允许特点站点跨域访问被代理的站点，或者屏蔽被代理站点识别请求访问客户端的类型（判断是否移动端等）。如果有更复杂的需求，可以基于此源码进行修改，以满足自己的需求。 使用说明及演示视频：https://download.csdn.net/download/Jollow/13137820 一些JAR包下载地址：https://download.csdn.net/download/Jollow/13137781
Java中的反向代理实现：揭秘高效与安全的后端架构
weixin_46372265的博客
07-16 986
反向代理是一种服务器，它位于客户端和实际服务器之间，接收来自客户端的请求并将其转发给实际服务器处理，然后将服务器的响应返回给客户端。反向代理的主要功能包括负载均衡、缓存、SSL终止、身份验证和授权、请求重写等。反向代理是现代网络架构中不可或缺的一部分。通过在Java中实现反向代理，我们可以充分利用其高扩展性和灵活性，构建高效、安全、可靠的系统。希望通过这篇文章，大家能够更深入地理解反向代理的原理和实现，提升自身的技术水平。生活就像编程，总是充满挑战和未知，但正是这些挑战，让我们不断成长与进步。
用Java实现一个简单的反向代理服务器
weixin_64400442的博客
05-29 1809
服务器接受http请求并解析为java对象,如果是静态资源请求则进行处理,是其他请求转发到指定的服务器。
JAVA HTTP反向代理实现过程详解
08-18
主要介绍了JAVA HTTP反向代理实现过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
反向代理--解决跨域问题
YY的博客
11-29 2606
解决单文件组件里的跨域请求数据问题
java后端开发面试题总结
07-13
- **Nginx**：反向代理、负载均衡、动静分离。 8. **分布式** - **分布式缓存Redis**：数据类型、持久化策略、主从复制。 - **分布式锁Zookeeper**：节点类型、选举机制、分布式协调。 - **消息队列RabbitMQ/...
express反向代理
hunter_97的博客
05-29 591
一、正向代理与反向代理 正向代理 正向代理，意思是一个位于客户端和原始服务器 (origin server) 之间的服务器，为了从原始服务器取得内容，客户端向代理发送一个请求并指定目标 (原始服务器)，然后代理向原始服务器转交请求并将获得的内容返回给客户端。客户端才能使用正向代理。 --摘自百度百科 反向代理 反向代理(Reverse Proxy)方式是指以代理服务器来接受 internet 上...
拼多多java开发面试题
07-25
- 主要用于负载均衡、反向代理、URL重写等功能。 - 通过配置文件可以灵活地管理服务器行为，支持高并发连接。 2. **HTTPS流程** - HTTPS使用SSL/TLS协议来加密HTTP通信，确保数据的安全传输。 - 浏览器与服务器...
Nginx是一个高性能的开源Web服务器和反向代理服务器.docx
最新发布
08-16
Nginx支持众多的第三方模块，可以根据需要进行自定义开发，实现更多的功能。 高度模块化的设计使得Nginx易于扩展和定制。 高可靠性： Nginx基于稳定的、成熟的事件驱动架构开发，能够有效避免由于代码错误或第三方库...
Java实现的反向代理程序（编译版）
11-22
使用Java编写的反向代理程序，通过简单的参数配置即可实现某些特定站点的反向代理，并在此过程中改变一些站点的特定行为。例如：允许特点站点跨域访问被代理的站点，或者屏蔽被代理站点识别请求访问客户端的类型（判断是否移动端等）。 使用说明及演示视频：https://download.csdn.net/download/Jollow/13137820 一些JAR包下载地址：https://download.csdn.net/download/Jollow/13137781
java-websocket-reverse-proxy:Websocket反向代理的Java实现
05-13
java-websocket-reverse-proxy 我发现的大多数Java websocket示例都是基于或包含诸如STOMP之类的消息传递协议的。 该示例是研究如何代理任何消息内容而无需担心消息传递协议的结果。 Websocket反向代理的Java实现。 与描述的方法类似，但使用Java实现。 这在Java应用程序服务器（例如Spring Boot）中可能很有用。 在根级别有一些nodejs脚本，可用于模仿验证代理服务器所需的功能。 常见的是脚本，该脚本侦听端口9999并在大写之后回显任何输入。 要通过建立与服务器的直接连接来测试回显行为，请运行 （需要安装 ） 还有一个非常简单的脚本，它将代理websocketserver。 它侦听端口8888 ，并将所有请求中继到端口9999 。 可以通过运行进行测试 文件夹中定义的类中包含一个与该代理行为匹配的简单Java实现。
Java实现的反向代理程序（使用到的JAR包）
11-22
该资源是“Java实现的反向代理程序（编译版）”使用到的一些公共JAR包，主要包含“commons-text-1.4.jar”和“javax.servlet_1.0.0.0_2-5.jar”这两个JAR包，共有兴趣的同道人下载。
Java实现的反向代理程序说明文档
11-22
该资源主要包含“Java编写的反向代理程序”相关的使用说明文档和演示文档【通过简单的参数配置即可实现某些特定站点的反向代理，并在此过程中改变一些站点的特定行为。】 编译版资源下载地址：https://download.csdn.net/download/Jollow/13137759 源码版资源下载地址：https://download.csdn.net/download/Jollow/13137795 一些JAR包下载地址：https://download.csdn.net/download/Jollow/13137781
tamacat-httpd:Java HTTP 服务器/反向代理-开源
05-31
[已移动] https://github.com/tamacat-1-4 tamacat-httpd是一种开源Java Web Server软件，由Apache HttpComponents提供支持。 这是一个可定制的 HTTP/HTTPS 服务器框架和反向代理。
Java中的反向代理实现
weixin_46372265的博客
07-24 404
大家好，我是城南。在今天的信息时代，反向代理已经成为许多应用程序架构中不可或缺的一部分。无论是为了提高安全性，提升性能，还是为了实现负载均衡，反向代理都扮演着至关重要的角色。今天，我们将深入探讨如何在Java中实现反向代理，并揭示其中的技术细节和设计哲学。
Java 反向代理J2EP
aosica321的专栏
10-23 5258
http://datalab.int-yt.com/archives/27 在使用多种服务器程序部署不同的应用的时候可能会遇到多个服务都想使用默认的80端口的情况。但是多个服务器不可能同时占用同一个端口。一般解决这种问题的方法就是使用反向代理。 反向代理有，加密和SSL加速，负载均衡，缓存静态内容，压缩，减速上传，安全，外网发布等功能。 我们使用反向代理只用到了外网发布的
java 正向代理+反向代理
weixin_43543654的博客
01-08 821
【代码】java 正向代理+反向代理。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值