精华内容
下载资源
问答
  • nginx代理ip,将客户端ip配置进websocket请求头

    nginx代理ip,将客户端ip配置进websocket请求头

    展开全文
  • 一:本文使用范围 此文不仅仅局限于spring boot,普通的spring工程,甚至是servlet工程,都是一样的,只不过配置一些监听器的方法不同而已。...二:Spring boot使用websocket 2.1:依赖包 webso...

    文章转自:http://www.cnblogs.com/zhuxiaojie/p/6238826.html

    一:本文使用范围

    此文不仅仅局限于spring boot,普通的spring工程,甚至是servlet工程,都是一样的,只不过配置一些监听器的方法不同而已。

     

    本文经过作者实践,确认完美运行。

     

    二:Spring boot使用websocket

    2.1:依赖包

    websocket本身是servlet容器所提供的服务,所以需要在web容器中运行,像我们所使用的tomcat,当然,spring boot中已经内嵌了tomcat。

    websocket遵循了javaee规范,所以需要引入javaee的包 

    复制代码

    <dependency>
          <groupId>javax</groupId>
          <artifactId>javaee-api</artifactId>
          <version>7.0</version>
          <scope>provided</scope>
        </dependency>

    复制代码

    当然,其实tomcat中已经自带了这个包。

    如果是在spring boot中,还需要加入websocket的starter

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-websocket</artifactId>
                <version>1.4.0.RELEASE</version>
            </dependency>

     

     

     

    2.2:配置websocket

    如果不是spring boot项目,那就不需要进行这样的配置,因为如果在tomcat中运行的话,tomcat会扫描带有@ServerEndpoint的注解成为websocket,而spring boot项目中需要由这个bean来提供注册管理。

    复制代码

    @Configuration
    public class WebSocketConfig {
        @Bean
        public ServerEndpointExporter serverEndpointExporter() {
            return new ServerEndpointExporter();
        }
    
    }

    复制代码

     

     

     

     

    2.3:websocket的java代码

    使用websocket的核心,就是一系列的websocket注解,@ServerEndpoint是注册在类上面开启。

     

    复制代码

    @ServerEndpoint(value = "/websocket")
    @Component
    public class MyWebSocket {
    
    
        //与某个客户端的连接会话,需要通过它来给客户端发送数据
        private Session session;
    
        /**
         * 连接成功*/
        @OnOpen
        public void onOpen(Session session) {
            this.session = session;
    
        }
    
        /**
         * 连接关闭调用的方法
         */
        @OnClose
        public void onClose() {
    
        }
    
        /**
         * 收到消息
         *
         * @param message 
        */
        @OnMessage
        public void onMessage(String message, Session session) {
            System.out.println("来自浏览器的消息:" + message);
    
            //群发消息
            for (MyWebSocket item : webSocketSet) {
                try {
                    item.sendMessage(message);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 发生错误时调用
         */
        @OnError
        public void onError(Session session, Throwable error) {
            System.out.println("发生错误");
            error.printStackTrace();
        }
    
        public void sendMessage(String message) throws IOException {
            this.session.getBasicRemote().sendText(message);//同步
            //this.session.getAsyncRemote().sendText(message);//异步
        }
    
     
    
    
    }

    复制代码

     

    其实我也感觉很奇怪,为什么不使用接口来规范。即使是因为@ServerEndpoint注解中其它属性中可以定义出一些额外的参数,但相信也是可以抽象出来的,不过想必javaee这样做,应该是有它的用意吧。

     

     

     

     

    2.4:浏览器端的代码

    浏览器端的代码需要浏览器支持websocket,当然,也有socket.js可以支持到ie7,但是这个我没用过。毕竟ie基本上没人用的,市面上的浏览器基本上全部都支持websocket。

    复制代码

    <!DOCTYPE HTML>
    <html>
    <head>
    
    </head>
    
    <body>
    
    </body>
    
    <script type="text/javascript">
        var websocket = null;
    
        //判断当前浏览器是否支持WebSocket
        if('WebSocket' in window){
            websocket = new WebSocket("ws://localhost:9999/websocket");
        }
        else{
            alert('不支持websocket')
        }
    
        //连接发生错误
        websocket.onerror = function(){
            
        };
    
        //连接成功
        websocket.onopen = function(event){
            
        }
    
        //接收到消息
        websocket.onmessage = function(event){
            var msg = event.data;
            alert("收到消息:" + msg);
        }
    
        //连接关闭
        websocket.onclose = function(){
            
        }
    
        //监听窗口关闭事件,当窗口关闭时,主动去关闭websocket连接,防止连接还没断开就关闭窗口,server端会抛异常。
        window.onbeforeunload = function(){
            websocket.close();
        }
    
       
    
      
    
        //发送消息
        function send(message){
            websocket.send(message);
        }
    </script>
    </html>

    复制代码

     

    如此就连接成功了。

     

     

     

     

     

    三:获取HttpSession,源码分析

    获取HttpSession是一个很有必要讨论的问题,因为java后台需要知道当前是哪个用户,用以处理该用户的业务逻辑,或者是对该用户进行授权之类的,但是由于websocket的协议与Http协议是不同的,所以造成了无法直接拿到session。但是问题总是要解决的,不然这个websocket协议所用的场景也就没了。

     

    3.1:获取HttpSession的工具类,源码详细分析

    我们先来看一下@ServerEndpoint注解的源码

    复制代码

    package javax.websocket.server;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    import javax.websocket.Decoder;
    import javax.websocket.Encoder;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface ServerEndpoint {
    
        /**
         * URI or URI-template that the annotated class should be mapped to.
         * @return The URI or URI-template that the annotated class should be mapped
         *         to.
         */
        String value();
    
        String[] subprotocols() default {};
    
        Class<? extends Decoder>[] decoders() default {};
    
        Class<? extends Encoder>[] encoders() default {};
    
        public Class<? extends ServerEndpointConfig.Configurator> configurator()
                default ServerEndpointConfig.Configurator.class;
    }

    复制代码

     

    我们看到最后的一个方法,也就是加粗的方法。可以看到,它要求返回一个ServerEndpointConfig.Configurator的子类,我们写一个类去继承它。

     

    按 Ctrl+C 复制代码

     

    按 Ctrl+C 复制代码

    当我们覆盖modifyHandshake方法时,可以看到三个参数,其中后面两个参数让我们感觉有点见过的感觉,我们查看一HandshakeRequest的源码

     

    复制代码

    package javax.websocket.server;
    
    import java.net.URI;
    import java.security.Principal;
    import java.util.List;
    import java.util.Map;
    
    /**
     * Represents the HTTP request that asked to be upgraded to WebSocket.
     */
    public interface HandshakeRequest {
    
        static final String SEC_WEBSOCKET_KEY = "Sec-WebSocket-Key";
        static final String SEC_WEBSOCKET_PROTOCOL = "Sec-WebSocket-Protocol";
        static final String SEC_WEBSOCKET_VERSION = "Sec-WebSocket-Version";
        static final String SEC_WEBSOCKET_EXTENSIONS= "Sec-WebSocket-Extensions";
    
        Map<String,List<String>> getHeaders();
    
        Principal getUserPrincipal();
    
        URI getRequestURI();
    
        boolean isUserInRole(String role);
    
        /**
         * Get the HTTP Session object associated with this request. Object is used
         * to avoid a direct dependency on the Servlet API.
         * @return The javax.servlet.http.HttpSession object associated with this
         *         request, if any.
         */
        Object getHttpSession();
    
        Map<String, List<String>> getParameterMap();
    
        String getQueryString();
    }

    复制代码

    我们发现它是一个接口,接口中规范了这样的一个方法

    复制代码

        /**
         * Get the HTTP Session object associated with this request. Object is used
         * to avoid a direct dependency on the Servlet API.
         * @return The javax.servlet.http.HttpSession object associated with this
         *         request, if any.
         */
        Object getHttpSession();

    复制代码

    上面有相应的注释,说明可以从Servlet API中获取到相应的HttpSession。

     

    当我们发现这个方法的时候,其实已经松了一口气了。

    那么我们就可以补全未完成的代码

     

    复制代码

    import javax.servlet.http.HttpSession;
    import javax.websocket.HandshakeResponse;
    import javax.websocket.server.HandshakeRequest;
    import javax.websocket.server.ServerEndpointConfig;
    import javax.websocket.server.ServerEndpointConfig.Configurator;
    
    /**
     * 从websocket中获取用户session
     *
     *
     */
    public class HttpSessionConfigurator extends Configurator {
    
        @Override
        public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
    
              HttpSession httpSession = (HttpSession) request.getHttpSession();
          
              sec.getUserProperties().put(HttpSession.class.getName(), httpSession);
        }
    }

    复制代码

     

    其实通过上面的源码分析,你们应该知道了HttpSession的获取。但是下面又多了一行代码

     sec.getUserProperties().put(HttpSession.class.getName(), httpSession);

    这行代码又是什么意思呢?

    我们看一下ServerEnpointConfig的声明

    public interface ServerEndpointConfig extends EndpointConfig

    我们发现这个接口继承了EndpointConfig的接口,好,我们看一下EndpointConfig的源码:

     

    复制代码

    package javax.websocket;
    
    import java.util.List;
    import java.util.Map;
    
    public interface EndpointConfig {
    
        List<Class<? extends Encoder>> getEncoders();
    
        List<Class<? extends Decoder>> getDecoders();
    
        Map<String,Object> getUserProperties();
    }

    复制代码

    我们发现了这样的一个方法定义

    Map<String,Object> getUserProperties();

    可以看到,它是一个map,从方法名也可以理解到,它是用户的一些属性的存储,那既然它提供了get方法,那么也就意味着我们可以拿到这个map,并且对这里面的值进行操作,

    所以就有了上面的

    sec.getUserProperties().put(HttpSession.class.getName(), httpSession);

     

     

    那么到此,获取HttpSession的源码分析,就完成了。

     

     

     

     

    3.2:设置HttpSession的类

    我们之前有说过,由于HTTP协议与websocket协议的不同,导致没法直接从websocket中获取协议,然后在3.1中我们已经写了获取HttpSession的代码,但是如果真的放出去执行,那么会报空指值异常,因为这个HttpSession并没有设置进去。

    好,这一步,我们来设置HttpSession。这时候我们需要写一个监听器。

     

    复制代码

    import javax.servlet.ServletRequestEvent;
    import javax.servlet.ServletRequestListener;
    import javax.servlet.http.HttpServletRequest;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class RequestListener implements ServletRequestListener {
    
        public void requestInitialized(ServletRequestEvent sre)  {
            //将所有request请求都携带上httpSession
            ((HttpServletRequest) sre.getServletRequest()).getSession();
    
        }
        public RequestListener() {
        }
    
        public void requestDestroyed(ServletRequestEvent arg0)  {
        }
    }

    复制代码

     

    然后我们需要把这个类注册为监听器,如果是普通的Spring工程,或者是servlet工程,那么要么在web.xml中配置,要么使用@WebListener注解。

    因为本文是以Spring boot工程来演示,所以这里只写Spring boot配置Listener的代码,其它的配置方式,请自行百度。

     

    这是使用@Bean注解的方式

    复制代码

    @Autowird
    private RequestListener requestListener;
      
    
        @Bean
        public ServletListenerRegistrationBean<RequestListener> servletListenerRegistrationBean() {
            ServletListenerRegistrationBean<RequestListener> servletListenerRegistrationBean = new ServletListenerRegistrationBean<>();
            servletListenerRegistrationBean.setListener(requestListener);
            return servletListenerRegistrationBean;
        }

    复制代码

    或者也可以使用@WebListener注解

    然后使用@ServletComponentScan注解,配置在启动方法上面。

     

     

     

     

    3.3:在websocket中获取用户的session

    然后刚才我们通过源码分析,是知道@ServerEndpoint注解中是有一个参数可以配置我们刚才继承的类。好的,我们现在进行配置。

    @ServerEndpoint(value = "/websocket" , configurator = HttpSessionConfigurator.class)

     

    接下来就可以在@OnOpen注解中所修饰的方法中,拿到EndpointConfig对象,并且通过这个对象,拿到之前我们设置进去的map

    复制代码

    @OnOpen
        public void onOpen(Session session,EndpointConfig config){
            HttpSession httpSession= (HttpSession) config.getUserProperties().get(HttpSession.class.getName());
            User user = (User)httpSession.getAttribute(SessionName.USER);
            if(user != null){
                this.session = session;
                this.httpSession = httpSession;
            }else{
                //用户未登陆
                try {
                    session.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    复制代码

     

     

    这下我们就从java的webscoket中拿到了用户的session。

     

    展开全文
  • nginx反向代理webSocket拿不到真实ip

    千次阅读 2018-06-30 19:10:08
    1、场景:nginx反向代理使用 WebSocketSession 里面 webSocketSession.getRemoteAddress().getHostString()方法经过了Nginx反向代理后得到的ip地址是127.0.0.1(就是Nginx反向代理的地址)。在本地测试过直接使用...
    • 1、场景:nginx反向代理后使用 WebSocketSession 里面 webSocketSession.getRemoteAddress().getHostString()方法经过了Nginx反向代理后得到的ip地址是127.0.0.1(就是Nginx反向代理的地址)。在本地测试过直接使用Tomcat是能够拿到真实IP的。
    • 2、解决方案
      Nginx配置:
    server {  
        listen 8080;   
        server_name 192.168.0.134 ;  
    
         location / {  
            proxy_set_header Host $host:$server_port;    
            proxy_set_header X-Real-Ip $remote_addr;    
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;  
    		proxy_http_version 1.1;
    		proxy_set_header Upgrade $http_upgrade;
    		proxy_set_header Connection "upgrade";
            proxy_pass http://127.0.0.1:8085;
        }  
    
    	
    }
    

    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection “upgrade”;
    是专门针对WebSocket配置的,具体可查看Nginx官方文档Nginx关于WebSocket的配置

    Nginx增加以下配置 
    proxy_set_header Host $host:$server_port; 非80端口 ,用80端口时 不需要$server_port 
    proxy_set_header X-Real-IP $remote_addr; 非必须,添加此项之后可以在代码中通过request.getHeader("X-Real-IP")获取ip
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; 
    proxy_set_header X-Forwarded-Proto $scheme; 
      
    <Engine name="Catalina" defaultHost="localhost"> 
    <Valve className="org.apache.catalina.valves.RemoteIpValve" 
    remoteIpHeader="X-Forwarded-For" 
    protocolHeader="X-Forwarded-Proto" 
    protocolHeaderHttpsValue="https" httpsServerPort="443"/> 非80端口时,必须增加httpsServerPort配置,不然request.getServerPort()方法返回 443. 
    

    此时经过反向代理到Tomcat就能获取到真实IP了。
    这里写图片描述

    展开全文
  • WebSocket使用

    2019-05-12 21:43:16
    文章目录1.websocket的由来2....使用websocket的缺点7.websocket 的通信过程8.如何用websocket8.1 客户端如何用websocket8.2 服务端如何用websocket(以springboot项目为例)9.http 与 websocket 的区别9.1 ...

    1.websocket的由来

      我们经常用的是HTTP协议,而HTTP协议是一种无状态的协议,要实现有状态的会话必须借助一些外部机制如session和cookie,这或多或少会带来一些不便,尤其是服务端和客户端需要实时交换数据的时候(监控,聊天),这个问题更加明显。为了适应这种环境,websocket就产生了。


    2.什么是websocket

      是一种在单个TCP连接上进行全双工通信的持久化协议。


    3.websocket的特点或作用

    1. 允许服务端主动向客户端推送数据(允许服务端主动向客户端推送数据)
    2. 在WebSocket API中,浏览器和服务器只需要完成一次握手,两者之间就直接可以创建持久性的连接,并进行双向数据传输。

    4.应用的场景

    1. 聊天:比如我们常用的两天软件,就用到了websocket
    2. 监控:实时监控一个网站的在线

    总之适用于:客户端与服务器段高频率低延迟交换事件。


    5.使用websocket的优点

    1. 更强的实时性
    2. 保持连接状态,创建一次连接后,之后通信时可以省略部分状态信息
    3. 较少的控制开销,在连接创建后,服务器和客户端之间交换数据时,用于协议控制的数据包头部相对较小。在不包含扩展的情况下,对于服务器到客户端的内容,此头部大小只有2至10字节(和数据包长度有关);对于客户端到服务器的内容,此头部还需要加上额外的4字节的掩码。相对于HTTP请求每次都要携带完整的头部,此项开销显著减少了

    6.使用websocket的缺点

    1. 由于websocket使用的持久连接,与服务器一直保持连接,对服务器压力很大

    7.websocket 的通信过程

      只需建立一次Request/Response消息对,之后都是TCP连接,避免了需要多次建立Request/Response消息对而产生的冗余头部信息。Request/Response需要三次w


    8.如何用websocket


    浏览器发送websocket请求头类似如下:
    在这里插入图片描述
    下面是对请求头部解释(比http协议多了Upgrade和Connection,是告诉服务器包协议设计为ws):

    • Accept-Encoding:浏览器可以接受的数据的压缩类型。
    • Accept-Language:浏览器可以接受的语言类型。
    • Cache-Control:no-cache不使用强缓存。
    • Connection:Upgrade 通知服务器通信协议提升。
    • Host:主机名。
    • Origin:用于验证浏览器域名是否在服务器许可范围内。
    • Pragma:no-cache HTTP/1.0定义的不使用本地缓存。
    • Sec-WebSocket-Extensions:permessage-deflate; client_max_window_bits
    • Sec-WebSocket-Key:lb69kw8CsB4CrSk9tKa3+g==
      握手协议密钥,base64编码的16字节的随机字符串。
    • Sec-WebSocket-Version:13 版本号。
    • Upgrade:websocket 使用websocket协议进行传输数据,而不使用HTTP/1.1。
    • User-Agent:用户代理字符串。

    服务器接收到客户端请求后做出响应并返回如下:
    在这里插入图片描述
    下面是服务器返回的头部解释:

    • Connection:Upgrade 通信协议提升。
    • Date:通信时间
    • Upgrade: websocket 传输协议升级为websocket。
    • Sec-WebSocket-Extensions:permessage-deflate
    • Sec-WebSocket-Accept:q9g5u1WfIWaAjNgMmjlTQTqkS/k=
      将Sec-WebSocket-Key的值进行一定的运算和该值进行比较来判断是否是目标服务器响应了WebSocket请求。
    • Upgrade: 使用websocket协议进行数据传输

    8.1 客户端如何用websocket

    这里我所指的客户端通常是指浏览器,而且都支持WebSocket API。你也可以通过window.WebSocket来判断你的浏览器是否支持WebSocket,

    var ws = null;
    function connect(){
    
           // 1. 创建websocket实例  
    		if ('WebSocket' in window){
               	ws = new WebSocket("ws://127.0.0.1:8086/socketServer/"+$("#username").val());
    		}    
    	    else if ('MozWebSocket' in window){
    	        ws = new MozWebSocket("ws://127.0.0.1:8086/socketServer/"+$("#username").val());
    	    }
    	    else{
    	        alert("该浏览器不支持websocket");    
    	    }
    
    	   // 2. 新建session,即创建连接时触发此方法
    	    ws.onopen = function() {
               // 可以在此写创建会话后想实现的的逻辑
    	    };  
    	    
            // 3. 接受消息,evt 是接收到服务端返回给客户端的数据
    	    ws.onmessage = function(evt) {
                // 可以在接受消息后想实现的的逻辑,比如修改页面上显示在线认数
    	    };    
    	        
    	    // 4. 关闭连接
    	    ws.onclose = function() {
                //  可以在此写会话关闭后想实现的的逻辑
    	    };   
    
    		// 5. 出现错误
            ws.onerror = function (e) {
                  //  可以在此写出现错误后想实现的的逻辑
            };
    }    
    
    // 客户端给服务端发送消息时,调用此方法
    function sendMsg() {    
        // 调用ws的send()事件
        ws.send(发送的内容);
    }  
    

    解释:

    • 首先要创建webSocket的实例,url一定是ws形式
    • 然后给ws绑定open,message,error,close四个事件
    • 发送数据使用send方法,该方法除了可以发送字符串以外还可以发送blob和二进制数据
    • 创建好的ws对象有一个readyState属性,它的取值有0,1,2,3分别表示正在连接,连接成功,正在关闭,连接关闭

    8.2 服务端如何用websocket(以springboot项目为例)

    • 第一步:引依赖

       <dependency>
       		<groupId>org.springframework.boot</groupId>
       		<artifactId>spring-boot-starter-websocket</artifactId>
       </dependency>
       <-- 使用springboot的内置tomcat时,就不需要引入javaEE-api -->
       <dependency>
       	<groupId>javax.servlet</groupId>
       	<artifactId>javax.servlet-api</artifactId>
       </dependency>
      
    • 第二步:启用websocket的支持

       import org.springframework.context.annotation.Bean;
       import org.springframework.context.annotation.Configuration;
       import org.springframework.web.socket.server.standard.ServerEndpointExporter;
       
       @Configuration  
       public class WebSocketConfig {  
           @Bean  
           public ServerEndpointExporter serverEndpointExporter(){  
               return new ServerEndpointExporter();  
           }  
       }
      
    • 第三步:通信的具体实现:
      具体实现可以参照如下例子,实现了一个简单的聊天功能:链接:https://pan.baidu.com/s/1iTjETNwQrICfHyDDh5yicg 提取码:0el5 ,可以参考下面这篇博客:https://blog.csdn.net/moshowgame/article/details/80275084

    简单说一下聊天实现的逻辑:每次客户端创建连接时会产生一个会话session,并存放起来,该session唯一标识,当客户端发送消息时,会给服务端发送包含发送给谁及发送内容的信息的消息message,然后客户端根据客户端传过来的发送给谁的信息查询对应的session,然后调用session.getBasicRemote().sendText(message)就可以给对方发送消息了,对方会监听ws.onmessage()方法,该方法就是监听对方发消息的,只要对方发消息就会触发该方法然后接受消息,如果时群发,循环调用上面的步骤即可


    9.http 与 websocket 的区别

      三次握手详解参见:https://www.jianshu.com/p/85aef5a0e3d8,
      四次挥手详解参见:https://www.cnblogs.com/qdhxhz/p/8470997.html

    9.1 相同点:

    1. 都属于应用层协议
    2. 都是用Request/Response模型进行连接的简历
    3. 都可以在网络中传输数据

    9.2 不同点:

    1. ws使用HTTP来建立连接,但是定义了一系列新的header域,这些域在HTTP中并不会使用
    2. ws连接建立之后,通信双方都可以在任何时刻向另一方发送数据
    3. ws连接建立之后即握手后,TCP套接字保持打开状态套接字是网络编程中的一种通信机制,是支持TCP/IP的网络通信的基本操作单元,可以看做是不同主机之间的进程进行双向通信的端点,简单的说就是通信的两方的一种约定,用套接字中的相关函数来完成通信过程),数据的传输使用帧来传递,不再需要Request消息
    4. ws的数据帧有序

    10. websocket 和 socket区别

      说到这个我不得不用这句话来回答你:就像Java和JavaScript的关系一样,两者没有丝毫的联系。socket即通常说的套接字,它是和网络中的运输层打交道的

    展开全文
  • Nginx配置WebSocket反向代理(Tomcat+Nginx)

    千次阅读 2018-10-21 23:09:26
    问题背景 最近的项目用到前端vue+后端springboot,需要用到nginx来做vue的代理和...WebSocket 和HTTP协议不同,但是WebSocket中的握手和HTTP中的握手兼容,它使用HTTP中的Upgrade协议头将连接从HTTP升级到WebSocke...
  • WebSocket是目前比较成熟的技术了,WebSocket协议为创建客户端和服务器端需要实时双向通讯的webapp提供了一个选择。其为HTML5的一部分,WebSocket相较于原来开发这类app的方法来说,其能使开发更加地简单。大部分...
  • Nginx系列 入门——Nginx系列——配置详解...进阶——Nginx系列——websocket反向代理与资源压缩 一、Nginx配置WebSocket反向代理 1、什么是WebSocket       WebSocket协议相比较于HTT
  • 使用Nginx对Websocket进行反向代理

    万次阅读 2018-11-27 21:56:08
    使用Nginx对Websocket进行反向代理背景Nginx配置示例Vue配置示例 背景 在Vue项目中,开发websocket时,将IP和端口号固定,或者根据NODE_ENV判断环境,修改IP和端口,相当不可取。当环境地址变更时,就需要重新打包,...
  • Websocket反向代理的Java实现。 与描述的方法类似,但使用Java实现。 这在Java应用程序服务器(例如Spring Boot)中可能很有用。 在根级别有一些nodejs脚本,可用于模仿验证代理服务器所需的功能。 常见的是脚本...
  • Nginx反向代理websocket协议的情况使用springboot项目获取客户端ip的地址本文只演示springboot项目的配置,其他项目请根据本文的配置自行配置nginx的相关配置springboot的配置解决办法 本文只演示springboot项目的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,866
精华内容 3,946
关键字:

websocket使用代理ip