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

function onenSocket(){
　　　/*newsinfo2为项目的根目录，websocket为请求地址，后台通过注解接收*/
    var socket = new WebSocket("ws://localhost:8080/newsinfo2/webSocket/");
       
        if(typeof(socket) == undefined){
            alert("您的浏览器不支持webSocket,请换一个浏览器...");
            return ;
        }
　　　　/*websocket接收消息的函数*/
        socket.onmessage = function(msg){
            if(msg == "已登录"){
                alert("您的账号已在另一个地方尝试登录，如果不是您知晓的情况，请及时修改密码...");
            }else if(msg == "登录成功"){
                location.href="../index/index.html";
            }else if(msg == "修改密码"){
                alert("您账号的密码已经被修改！如果不是你自己知晓的情况，请及时修改密码...");
                location.href="../login/login.html";
            }
        }
        //socket打开时的方法
        socket.onopen = function(){
        }
        //socket关闭时的方法
        socket.onclose = function(){
        }
         //socket出错时的方法
        socket.onerror = function(){
        }
        /*//在页面加载时自动断开链接，这样就不会异常断开链接，后台不会报错误
        $(document).ready(function(){
            socket.close();
        });*/
}

@ServerEndpoint(value = "/webSocket/")
public class WebSocketServer {

public static CopyOnWriteArraySet<WebSocketServer> webSocketServerSet = new CopyOnWriteArraySet<WebSocketServer>();

package news.webSocket;

import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;

import javax.servlet.http.HttpSession;
import javax.websocket.EndpointConfig;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;

import news.bean.UserInfo;
import news.config.Configuretor;
import news.utils.LogerUtils;
import news.utils.StaticValue;

/**
 * webSocketServer类，用于处理登录挤退现象，
 * 思路：登录时，要判断该账号是否已创建一个webSocket对象存储起来了，根据这个判断的结果来进行下一步动作
 * @author 徐金仁
 */
@ServerEndpoint(value = "/webSocket/" , configurator = Configuretor.class)
public class WebSocketServer {
    //用于存储webSocketServer
    public static CopyOnWriteArraySet<WebSocketServer> webSocketServerSet = new CopyOnWriteArraySet<WebSocketServer>();
    private Session session;  //与某个客户端连接的会话,该session是属于WebSocket的session，不属于HttpSession
    private String sid; //用户的编号
    private Logger log = LogerUtils.getLogger(this.getClass());
    @Autowired
    private HttpSession httpSession_;
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((session == null) ? 0 : session.hashCode());
        result = prime * result + ((httpSession_ == null) ? 0 : httpSession_.hashCode());
        result = prime * result + ((sid == null) ? 0 : sid.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        WebSocketServer other = (WebSocketServer) obj;
        if (session == null) {
            if (other.session != null)
                return false;
        } else if (!session.equals(other.session))
            return false;
        if (httpSession_ == null) {
            if (other.httpSession_ != null)
                return false;
        } else if (!httpSession_.equals(other.httpSession_))
            return false;
        if (sid == null) {
            if (other.sid != null)
                return false;
        } else if (!sid.equals(other.sid))
            return false;
        return true;
    }

    public static CopyOnWriteArraySet<WebSocketServer> getWebSocketServerSet() {
        return webSocketServerSet;
    }

    public static void setWebSocketServerSet(CopyOnWriteArraySet<WebSocketServer> webSocketServerSet) {
        WebSocketServer.webSocketServerSet = webSocketServerSet;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public HttpSession gethttpSession_() {
        return httpSession_;
    }

    public void sethttpSession_(HttpSession httpSession_) {
        this.httpSession_ = httpSession_;
    }

    public void setSession(Session session) {
        this.session = session;
    }
    
    /**
     * 获取HttpSession
     * @return
     */
    public HttpSession getHttpSession(){
        return this.httpSession_;
    }
    
    /**
     * 获取session
     * @return
     */
    public Session getSession(){
        return this.session;
    }
    
    /**
     * 连接的时候需要调用的方法
     * @throws IOException 
     */
    @OnOpen
    public void onOpen(Session session,  EndpointConfig config) throws IOException{
        HttpSession httpSession = (HttpSession) config.getUserProperties().get(HttpSession.class.getName());
        this.session = session;
        this.httpSession_ = httpSession;
        System.out.println("链接中..." + httpSession_.getId());
        //StaticValue为自定义的存放key值的类，里面都是一些常量
        Object obj =  (this.httpSession_.getAttribute(StaticValue.CURRENT_USER));
        if(obj != null){ //说明还链接中
            this.sid = String.valueOf(((UserInfo)obj).getUid());
            log.info(this.sid + "正在链接中...");
            if(!webSocketServerSet.contains(this)){
                webSocketServerSet.add(this); //将连接到的添加进入set里面
            }
        }else{ //说明不链接了
            //等会在写
        }
        /*this.sendMessage("连接成功！");*/
    }
    /**
     * 发送消息的方法
     * @param string
     * @throws IOException 
     */
    public void sendMessage(String msg) throws IOException  {
        this.session.getBasicRemote().sendText(msg);
    }
    
    /**
     * 出现错误的方法
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session , Throwable error){
        log.error( this.sid + "websocket出错断开链接");
    }
    /**
     * 当连接断开时，调用的方法
     */
    @OnClose
    public void onClose(){
        webSocketServerSet.remove(this);
    }
    
    /**
     * 根据sid查询webSocket
     * @param sid
     * @return
     */
    public static WebSocketServer getWebSocket(String sid){
        for(WebSocketServer w : webSocketServerSet){
            if(sid.equals(w.sid)){
                return w;
            }
        }
        return null;
    }
}

@RequestMapping("login")
    public UserInfo login(String uname, String upwd, HttpSession session) throws IOException{
        int result = 0;
        UserInfo userInfo = new UserInfo();
        userInfo.setUname(uname);
        userInfo.setUpwd(upwd);
        UserInfo us = null;
        us = loginService.login(userInfo);
        if(us == null){
            us = new UserInfo();
            us.setUid(-1); //表示账号或密码不对
        }else{//如果查寻到账号和密码都没有错误，则要判断是否已经被登录了，
            WebSocketServer wws = WebSocketServer.getWebSocket(String.valueOf(us.getUid()));
            if(wws != null){ //如果有
                wws.sendMessage("已登录");
                us.setUid(-2); //表示已登录
            }else{//表示暂时没有人登录，您是第一个，要将信息存储一下
                session.setAttribute("userInfo", us);
                session.setAttribute(StaticValue.CURRENT_USER, us);
                System.out.println("session的id:" + session.getId());
            }
        }
        System.out.println(us);
        return us;