java使用websocket，并且获取HttpSession，源码分析

一：本文使用范围

此文不仅仅局限于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的子类，我们写一个类去继承它。

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;

public class HttpSessionConfigurator extends Configurator {

    @Override
    public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {

　　　　//怎么搞？
    }
}

当我们覆盖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注解的方式

@Autowirdprivate 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。

出处
： http://www.cnblogs.com/zhuxiaojie/p/6238826.html

时间： 2024-12-29 07:37:39

java使用websocket，并且获取HttpSession，源码分析的相关文章

java并发锁ReentrantReadWriteLock读写锁源码分析

1.ReentrantReadWriterLock基础 所谓读写锁,是对访问资源共享锁和排斥锁,一般的重入性语义为 如果对资源加了写锁,其他线程无法再获得写锁与读锁,但是持有写锁的线程,可以对资源加读锁(锁降级):如果一个线程对资源加了读锁,其他线程可以继续加读锁. java.util.concurrent.locks中关于多写锁的接口:ReadWriteLock public interface ReadWriteLock { /** * Returns the lock used for r

Java入门系列之集合Hashtable源码分析（十一）

前言 上一节我们实现了散列算法并对冲突解决我们使用了开放地址法和链地址法两种方式,本节我们来详细分析源码,看看源码中对于冲突是使用的哪一种方式以及对比我们所实现的,有哪些可以进行改造的地方. Hashtable源码分析 我们通过在控制台中实例化Hashtable并添加键值对实例代码来分析背后究竟做了哪些操作,如下: public static void main(String[] args) { Hashtable hashtable = new Hashtable(); hashtable.p

Java入门系列之集合HashMap源码分析（十四）

前言 我们知道在Java 8中对于HashMap引入了红黑树从而提高操作性能,由于在上一节我们已经通过图解方式分析了红黑树原理,所以在接下来我们将更多精力投入到解析原理而不是算法本身,HashMap在Java中是使用比较频繁的键值对数据类型,所以我们非常有必要详细去分析背后的具体实现原理,无论是C#还是Java原理解析,从不打算一行行代码解释,我认为最重要的是设计思路,重要的地方可能会多啰嗦两句. HashMap原理分析 我们由浅入深,循序渐进,首先了解下在HashMap中定义的几个属性,稍后会

JAVA随笔篇一（Timer源码分析和scheduleAtFixedRate的使用）

写完了基础篇,想了很久要不要去写进阶篇,去写JSP等等的使用方法,最后决定先不去写,因为自己并不是JAVA方面的大牛,目前也在边做边学,所以决定先将自己不懂的拿出来学并记下来. Timer是Java自带的java.util.Timer类,通过调度一个java.util.TimerTask任务.这种方式可以让程序按照某一个频度执行. 1.Timer类的源码分析: public class Timer { /** * The timer task queue. This data structure

1.Java集合-HashMap实现原理及源码分析

哈希表(Hash  Table)也叫散列表,是一种非常重要的数据结构,应用场景及其丰富,许多缓存技术(比如memcached)的核心其实就是在内存中维护一张大的哈希表,而HashMap的实现原理也常常出现在各类的面试题中,这里对java集合框架中的对应实现HashMap的实现原理进行讲解,然后对JDK7的HashMap的源码进行分析 哈希算法,是一类算法: 哈希表(Hash  Table)是一种数据结构: 哈希函数:是支撑哈希表的一类函数: HashMap 是 Java中用哈希数据结构实现的Ma

Java并发编程中线程池源码分析及使用

当Java处理高并发的时候,线程数量特别的多的时候,而且每个线程都是执行很短的时间就结束了,频繁创建线程和销毁线程需要占用很多系统的资源和时间,会降低系统的工作效率. 参考http://www.cnblogs.com/dolphin0520/p/3932921.html 由于原文作者使用的API 是1.6 版本的,参考他的文章,做了一些修改成 jdk 1.8版本的方法,涉及到的内容比较多,可能有少许错误. API : jdk1.8.0_144 ThreadPoolExecutor类 Java中线

Java集合框架之一：ArrayList源码分析

版权声明:本文为博主原创文章,转载请注明出处,欢迎交流学习! ArrayList底层维护的是一个动态数组,每个ArrayList实例都有一个容量.该容量是指用来存储列表元素的数组的大小.它总是至少等于列表的大小.随着向 ArrayList 中不断添加元素,其容量也自动增长. ArrayList不是同步的(也就是说不是线程安全的),如果多个线程同时访问一个ArrayList实例,而其中至少一个线程从结构上修改了列表,那么它必须保持外部同步,在多线程环境下,可以使用Collections.synch

2.Java集合-ConcurrentHashMap实现原理及源码分析

一.为何用ConcurrentHashMap 在并发编程中使用HashMap可能会导致死循环,而使用线程安全的HashTable效率又低下. 线程不安全的HashMap 在多线程环境下,使用HashMap进行put操作会引起死循环,导致CPU利用率接近100%,所以在并发情况下不能使用HashMap 效率低下的HashTable Hashtable使用synchronized来保证线程的安全,但是在线程竞争激烈的情况下Hashtable的效率非常低下.当一个线程访问Hashtable的同步方法,

6.Java集合-LinkedList实现原理及源码分析

Java中LinkedList的部分源码(本文针对1.7的源码) LinkedList的基本结构 jdk1.7之后,node节点取代了 entry ,带来的变化是,将1.6中的环形结构优化为了直线型链表结构,从双向循环链表变成了双向链表 在LinkedList中,我们把链子的"环"叫做"节点",每个节点都是同样的结构.节点与节点之间相连,构成了我们LinkedList的基本数据结构,也是LinkedList的核心. 我们再来看一下LinkedList在jdk1.6和

Java -- 基于JDK1.8的ThreadLocal源码分析

1,最近在做一个需求的时候需要对外部暴露一个值得应用  ,一般来说直接写个单例,将这个成员变量的值暴露出去就ok了,但是当时突然灵机一动(现在回想是个多余的想法),想到handle源码里面有使用过ThreadLocal这个类,想了想为什么不想直接用ThreadLocal保存数据源然后使用静态方法暴露出去呢,结果发现使用ThreadLocal有时候会获取不到值,查了下原因原来同事是在子线程中调用的(捂脸哭泣),所以还是要来看一波源码,看看ThreadLocal底层实现,适用于哪些场景 2,我们现在