反向代理支持WebSocket

最新推荐文章于 2024-06-18 22:12:25 发布
最新推荐文章于 2024-06-18 22:12:25 发布
阅读量1.6k 收藏 3
点赞数 1
分类专栏： Java 文章标签： WebSocket 反向代理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SonOfWind0311/article/details/95629854
版权

已经利用Jetty的ProxyServlet实现了反向代理的功能，但是无法支持WebSocket。

  • 利用Jetty的ProxyServlet实现反向代理：关键点在于rewriteTarget，在这个方法中改写目标URL，从而实现把HTTP请求“转发”给对应的目标
    一开始对WebSocket有误解，以为WebSocket也是基于HTTP协议，只是报文头有些特殊，想通过ProxyServlet进行特殊处理，结果自然行不通。回过头来仔细分析发现WebSocket实际上是另外的协议，只是握手借用了HTTP协议，端口借用了HTTP，因此只能采取“隧道”的方案：
    在这里插入图片描述
    WebSocketServerServlet：
public class WebSocketServerServlet extends WebSocketServlet {
    private static final Logger log = LoggerFactory.getLogger (WebSocketServerServlet.class);
    private static final long WEBSOCKET_DEFAULT_MAX_IDLE      = 60000;            // 1 minute
    private static final int  WEBSOCKET_DEFAULT_MAX_BUFF      = 1024 * 1024;      // 1 mb
    ......

    @Override
    public void configure(WebSocketServletFactory factory) {
        log.info ("Configuring the web socket adapter");
        factory.getPolicy ().setIdleTimeout (WEBSOCKET_DEFAULT_MAX_IDLE);
        factory.getPolicy ().setMaxBinaryMessageSize (WEBSOCKET_DEFAULT_MAX_BUFF);
        factory.getPolicy ().setMaxTextMessageBufferSize (WEBSOCKET_DEFAULT_MAX_BUFF);

        factory.setCreator(new WebSocketServerCreator());
    }
}

WebSocketServerCreator：

public class WebSocketServerCreator implements WebSocketCreator {

    private WebSocketServerAdapter websocket = new WebSocketServerAdapter();

    @Override
    public Object createWebSocket(ServletUpgradeRequest servletUpgradeRequest, ServletUpgradeResponse servletUpgradeResponse) {
        for (String subprotocol : servletUpgradeRequest.getSubProtocols())
        {
            if ("binary".equals(subprotocol)) {
                servletUpgradeResponse.setAcceptedSubProtocol(subprotocol);
                return websocket;
            }
        }

        // No valid subprotocol in request, ignore the request
        return null;
    }
}

WebSocketServerAdapter ：

public class WebSocketServerAdapter extends WebSocketAdapter {
   private static final Logger log = LoggerFactory.getLogger (WebSocketServerAdapter.class);
    private SslContextFactory sslContextFactory;
    private WebSocketClient webSocketClient;
    private Session proxyingSession;

    private static final String WEBSOCKET_URL_FORMAT = "wss://%s%s";

    public WebSocketServerAdapter() {
        initSslContextFactory();
        this.webSocketClient = new WebSocketClient(this.sslContextFactory);
    }

    private void initSslContextFactory() {
        // initialize SslContextFactory
        this.sslContextFactory = new SslContextFactory();
        SSLContext sslContext = ....
        this.sslContextFactory.setSslContext(sslContext);

        ArrayList<String> ciphersToEnable = new ArrayList<> (sslContext.getDefaultSSLParameters ().getCipherSuites ().length + 1);
        ciphersToEnable.add (".*_GCM_.*");  // GCM first in case ordering is honored
        ciphersToEnable.addAll (Arrays.asList (sslContext.getDefaultSSLParameters ().getCipherSuites ()));
        this.sslContextFactory.setIncludeCipherSuites (ciphersToEnable.toArray (new String[ciphersToEnable.size ()]));
        this.sslContextFactory.setExcludeCipherSuites (".*[Aa][Nn][Oo][Nn].*", ".*[Nn][Uu][Ll][Ll].*");
    }

    @Override
    public void onWebSocketConnect (Session sess) {
        super.onWebSocketConnect (sess);

        String ip="1.2.3.4";          // target ip
        String path="/test";      // url path
        String dest= String.format(WEBSOCKET_URL_FORMAT, ip, path);
        try {
            URI destUri = new URI(dest);

            webSocketClient.start();
            Future<Session> future = webSocketClient.connect(new WebSocketClientAdapter(sess), destUri, getClientUpgradeRequest(sess));

            proxyingSession = future.get();
            if(proxyingSession != null && proxyingSession.isOpen()) {
                log.debug("websocket connected to {}", dest);
            }
        } catch (URISyntaxException e) {
            log.error("invalid url: {}", dest);
        } catch (IOException |  ExecutionException | InterruptedException e) {
            log.error("exception while connecting to {}", dest, e);
        } catch (Exception e) {
            log.error("exception while starting websocket client", e);
        }
    }

    @Override
    public void onWebSocketText (String message) {
        super.onWebSocketText (message);
        log.debug("websocket message received {}", message);
        // forwarding ...
        if(proxyingSession != null && proxyingSession.isOpen()) {
            try {
                proxyingSession.getRemote().sendString(message);
            } catch (IOException e) {
                log.error("exception while forwarding text message to client", e);
            }
        } else {
            log.error("proxying session is null or closed.");
        }
    }

    @Override
    public void onWebSocketBinary(byte[] payload, int offset, int len) {
        super.onWebSocketBinary(payload, offset, len);
        log.debug("websocket binary received, offset:{}, len: {}", offset, len);
        // forwarding ...
        if(proxyingSession != null && proxyingSession.isOpen()) {
            ByteBuffer byteBuffer = ByteBuffer.wrap(payload, offset, len);
            try {
                this.proxyingSession.getRemote().sendBytes(byteBuffer);
            } catch (IOException e) {
                log.error("exception while forwarding text message to client", e);
            }
        } else {
            log.error("proxying session is null or closed.");
        }
    }

    @Override
    public void onWebSocketClose (int statusCode, String reason) {
        super.onWebSocketClose (statusCode, reason);
        log.debug ("Socket Closed: status code: [ {} ]", statusCode);
        disconnect ();
    }

    private ClientUpgradeRequest getClientUpgradeRequest(Session sess) {
        ClientUpgradeRequest request = new ClientUpgradeRequest();

        UpgradeRequest upgradeRequest = sess.getUpgradeRequest();

        request.setCookies(upgradeRequest.getCookies());
        request.setSubProtocols(upgradeRequest.getSubProtocols());

        Map<String, List<String>> headers = upgradeRequest.getHeaders();
        headers.forEach((k,v) -> {
            if(!k.equalsIgnoreCase(HttpHeader.HOST.asString())) {
                request.setHeader(k, v);
            }
        });

        return request;
    }

    /**
     * This method unregisters the subscriber and closes the connection
     *
     * @return
     */
    private boolean disconnect () {

        if (this.getSession () == null || !this.getSession ().isOpen ()) {
            return true;
        }

        try {
            this.getSession ().disconnect ();

            if (isConnected ()) {
                log.debug ("Could not disconnect the websocket client");
                return false;
            }
        }
        catch (Exception e) {
            log.error ("Exception on disconnecting the websocket client");
        } finally {
            if(this.webSocketClient != null) {
                try {
                    this.webSocketClient.stop();
                } catch (Exception e) {
                    log.error ("Exception while stopping websocket client", e);
                }
            }
        }

        return true;
    }
}

WebSocketClientAdapter：

public class WebSocketClientAdapter extends WebSocketAdapter {
    private static final Logger log = LoggerFactory.getLogger (WebSocketClientAdapter.class);

    private Session proxyingSess;

    WebSocketClientAdapter(Session sess) {
        this.proxyingSess = sess;
    }

    @Override
    public void onWebSocketConnect (Session sess) {
        super.onWebSocketConnect (sess);

        log.debug("websocket client connected ...");
    }

    @Override
    public void onWebSocketText (String message) {
        super.onWebSocketText (message);
        log.debug("websocket message received {}", message);
        // forwarding
        if(this.proxyingSess != null && this.proxyingSess.isOpen()) {
            try {
                this.proxyingSess.getRemote().sendString(message);
            } catch (IOException e) {
                log.error("exception while forwarding text message to client", e);
            }
        } else {
            log.error("proxying session is null or closed.");
        }
    }

    @Override
    public void onWebSocketBinary(byte[] payload, int offset, int len) {
        super.onWebSocketBinary(payload, offset, len);
        log.debug("websocket binary received, offset:{}, len: {}", offset, len);
        // forwarding ...
        ByteBuffer byteBuffer = ByteBuffer.wrap(payload, offset, len);
        if(this.proxyingSess != null && this.proxyingSess.isOpen()) {
            try {
                this.proxyingSess.getRemote().sendBytes(byteBuffer);
            } catch (IOException e) {
                log.error("exception while forwarding binary to client", e);
            }
        } else {
            log.error("proxying session is null or closed.");
        }
    }

    @Override
    public void onWebSocketClose (int statusCode, String reason) {
        super.onWebSocketClose (statusCode, reason);
        log.debug ("Socket Closed: status code: [ {} ]", statusCode);
        disconnect ();
    }

    /**
     * This method unregisters the subscriber and closes the connection
     *
     * @return
     */
    private boolean disconnect () {

        if (this.getSession () == null || !this.getSession ().isOpen ()) {
            return true;
        }

        try {
            this.getSession ().disconnect ();

            if (isConnected ()) {
                log.debug ("Could not disconnect the websocket client");
                return false;
            }
        }
        catch (Exception e) {
            log.error ("Exception on disconnecting the websocket client");
        }

        return true;
    }
}

问题

  • WebSocketClient connect 抛出异常：java.lang.IllegalStateException: WebSocketClient@470192252 is not started
    原因：在connect前需要先调用start方法
  • WebSocketClient connect 抛出异常：java.util.concurrent.ExecutionException: java.io.IOException: Cannot init SSL
    原因：wss连接，WebSocketClient初始化时需要传入SslContextFactory实例
  • WebSocketClient connect 抛出异常：java.util.concurrent.ExecutionException: javax.net.ssl.SSLHandshakeException: General SSLEngine problem…
    Caused by: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
    原因：SslContextFactory没有正确的初始化，没有指定证书路径

参考

SonOfWind0311
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-websocket-reverse-proxy:Websocket反向代理的Java实现
05-13
Websocket反向代理的Java实现。 与描述的方法类似，但使用Java实现。 这在Java应用程序服务器（例如Spring Boot）中可能很有用。 在根级别有一些nodejs脚本，可用于模仿验证代理服务器所需的功能。 常见的是脚本，...
JAVA HTTP反向代理实现过程详解
08-18
反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个...
WebSocket简介 并 搭建服务端
weixin_39527642的博客
02-14 701
Java搭建 webSocket服务
简易服务端之Servlet实现Websocket消息通信
qq_40785165的博客
01-11 2581
坚持就是胜利 大家好，我是小黑，一个还没秃头的程序员~~~ 本期写点服务端的内容，介绍一下大学时期经常用到的Servlet是如何实现WebSocket连接与通信的，编写Servlet不需要搭建复杂的框架，沿用大学期间学习的Web项目经验即可，适用于大学生开发毕业设计或者课程作业等场景。
vue部署宝塔nginx配置（获取用户ip地址、反代理访问api接口、websocket转发）
最新发布
weixin_42966151的博客
06-18 545
【代码】vue部署宝塔nginx配置（获取用户ip地址、反代理访问api接口、websocket转发）
httpServer来代理WebSocket通信
fzlhz的博客
07-29 980
单工：数据只支持在一个方向传输，即单向，在同一时间内只有一方能够接受&发送信息； 半双工：允许数据能够双向传输，但是，在某一时刻只允许数据在一个方向传输。类似切换方向的单工通信。http就是半双工通信，先有请求，再有响应； 全双工：允许数据同时都能双向传输，类似两个单工通信的结合，要求client & server都有独立接收和发送的能力，在任意时刻都能接收&发送信息，socket就是全双工通信；...
Netty(十四) Netty实现HTTP与WebSocket代理服务器
文若书生的专栏
07-18 4928
目前想实现一个HTTP代理服务，能够支持HTTP和Websocket的代理。最开始的实现思路是使用Jetty服务+Http-proxy框架实现的，后来发现支持Websocket比较困难。换了另一种思路，使用Netty来实现。 github源码： https://github.com/zhuquanwen/netty-http-websocket-proxy 1、引入依赖 dependencie...
正向代理与反向代理
lanseali的博客
03-11 1100
函数是一等公民 // 新建函数类型 type HandlerFunc func(http.ResponseWriter, *http.Request) // 新建函数方法 func (f HandlerFunc) ServeHTTP(w http.ResponseWriter, r *http.Request) { f(w, r) } // 主函数 func main() { // 实例化函数 hf := HandlerFunc(HelloHandler) // 创建response对象 .
Nginx实战之反向代理WebSocket的配置实例
01-20
大部分现在的浏览器都支持WebSocket，比如Firefox，IE，Chrome，Safari，Opera，并且越来越多的服务器框架现在也同样支持WebSocket。 WebSocket集群 在实际的生产环境中，要求多个WebSocket服务器必须具有高性能和...
freeswitch ngnix wss反向代理，jssip配置
07-02
freeswitch支持UDP、TCP、WS(websocket)、WSS方式进行注册，而...2. jssip工具对反向代理支持的配置； 3. 注意事项，不按步骤2修改会发生的错误。 详细参见：https://blog.csdn.net/xxm524/article/details/125573738
fasthttp-reverse-proxy:基于fasthttp的反向http websocket代理
05-10
快速http反向代理 基于fasthttp的反向http代理处理程序。 特征 代理客户端支持的pool 。 比golang标准的httputil.ReverseProxy更快 fasthttp.HostClient的简单fasthttp.HostClient 网络套接字代理 支持基于...
spring-cloud-netflix-zuul-websocket, Zuul反向代理网络套接字支持.zip
10-09
spring-cloud-netflix-zuul-websocket, Zuul反向代理网络套接字支持 spring-cloud-netflix-zuul-websocketspring 应用程序中支持Zuul反向代理web套接字支持的简单库。用法spring-cloud-netflix-zuul-websocket可以从 Maven
websocket+servlet简单案例代码
04-13
websocket+servlet简单案例代码
servlet中加入socket
Sunshine的专栏
12-05 7236
对于web是一个白痴级的人，现在用到了前端的知识，只能边学边用，做做笔记。 现在需要在servlet中写一个socket与其他程序通信。一个非常简单的demo：控制台输出客户端发来的信息，这个servlet还每秒刷新一次网页，输出时间。 如下是servlet的源码HelloWorld.java： import java.io.*; import javax.servlet.*; im
在vue中使用SockJS和stomp让websocket更加简单
写点什么好
12-23 2115
// websocket initWebSocket () { this.connect() const self = this // 断开重连机制,尝试发送消息,捕获异常发生时重连 this.timer = setInterval(() => { try { console.log('成功') } catch (err) { console.log('断线了: '...
Java实现Http反向代理功能
文若书生的专栏
06-10 8358
最近项目中要实现一个HTTP请求反向代理功能，类似Ngix,但还要在代理中做一些自己的处理，所以自己用Java实现了一个反向代理功能 采用Jetty作为服务器，采用反向代理库smiley-http-proxy-servlet 废话不多说，很简单，看一下源码就可以了 https://git.dev.tencent.com/zhuquanwen/http-proxy.git ...
Websocket代理
CMX100的专栏
07-31 3059
最近接手一个网狐项目，使用的是比较老的框架 ，不支持Websocket。现在需要修改为支持Websocket,同时老的Socket也能使用，这样方便多端同时推广。本来想修改框架，多种连接方式共存。看过Websocket++ 等开源项目后，发现修改比较麻烦。后来搜索发现高手转换思路，通过代理中转方式解决了这个问题并且代码量修改很小，值得借鉴。 https://blog.csdn.net/zdl10...
html5利用websocket完成的推送功能（tomcat）
weixin_30883311的博客
03-21 381
利用websocket和java完成的消息推送功能，服务器用的是tomcat7.0.42，一些东西是自己琢磨的，也不知道恰不恰当，不恰当处，还请各位见谅，并指出。 程序简单来说，就是客户A可以发送消息给客户B，但有很多可以扩展的地方， 比如 1.如果加入数据库后，A发消息时客户B未上线，服务端将会把消息存在数据库中，等客户B上线后，在将消息取出发送给客户B 2.服务...
IIS实现反向代理
weixin_34405557的博客
05-31 644
反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。反向代理可以启用高级URL策略和管理技术，从而使处于不同web服务器系统的web页面同时存在于同一个URL空间下。通过IIS安装反向代理，可以使得IIS和Ap...
spring boot反向代理websocket
04-13
Spring Boot提供了对WebSocket的支持，可以通过反向代理来实现WebSocket的连接。 反向代理是一种服务器架构模式，它将客户端的请求转发到后端服务器，并将后端服务器的响应返回给客户端。在WebSocket中，反向代理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值