详解springboot集成websocket的两种实现方式

websocket跟常规的http协议的区别和优缺点这里大概描述一下

一、websocket与http 

http协议是用在应用层的协议，他是基于tcp协议的，http协议建立链接也必须要有三次握手才能发送信息。http链接分为短链接，长链接，短链接是每次请求都要三次握手才能发送自己的信息。即每一个request对应一个response。长链接是在一定的期限内保持链接。保持tcp连接不断开。客户端与服务器通信，必须要有客户端发起然后服务器返回结果。客户端是主动的，服务器是被动的。 
websocket是html5中的协议， 他是为了解决客户端发起多个http请求到服务器资源浏览器必须要经过长时间的轮训问题而生的，他实现了多路复用，他是全双工通信。在websocket协议下客服端和浏览器可以同时发送信息。

二、http的长连接与websocket的持久连接

http1.1的连接默认使用长连接（persistent connection），

即在一定的期限内保持链接，客户端会需要在短时间内向服务端请求大量的资源，保持tcp连接不断开。客户端与服务器通信，必须要有客户端发起然后服务器返回结果。客户端是主动的，服务器是被动的。

  在一个tcp连接上可以传输多个request/response消息对，所以本质上还是request/response消息对，仍然会造成资源的浪费、实时性不强等问题。

如果不是持续连接，即短连接，那么每个资源都要建立一个新的连接，http底层使用的是tcp，那么每次都要使用三次握手建立tcp连接，即每一个request对应一个response，将造成极大的资源浪费。

  长轮询，即客户端发送一个超时时间很长的request，服务器hold住这个连接，在有新数据到达时返回response

websocket的持久连接  只需建立一次request/response消息对，之后都是tcp连接，避免了需要多次建立request/response消息对而产生的冗余头部信息。

websocket只需要一次http握手，所以说整个通讯过程是建立在一次连接/状态中，而且websocket可以实现服务端主动联系客户端，这是http做不到的。

springboot集成websocket的不同实现方式：

pom添加依赖

 <dependency>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-websocket</artifactid>
    </dependency>

 因涉及到js连接服务端，所以也写了对应的html，这里集成下thymeleaf模板，前后分离的项目这一块全都是前端做的

 <dependency>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-thymeleaf</artifactid>
    </dependency>

配置文件：

server:
 port: 8885
 
#添加thymeleaf配置
thymeleaf:
 cache: false
 prefix: classpath:/templates/
 suffix: .html
 mode: html5
 encoding: utf-8
 content-type: text/html

1：自定义websocketserver，使用底层的websocket方法，提供对应的onopen、onclose、onmessage、onerror方法

1.1：添加websocketconfig配置类

/**
 * 开启websocket支持
 * created by huiyunfei on 2019/5/31.
 */
@configuration
public class websocketconfig {
  @bean
  public serverendpointexporter serverendpointexporter() {
    return new serverendpointexporter();
  }
}

1.2：添加websocketserver服务端类

package com.example.admin.web;
 
/**
 * created by huiyunfei on 2019/5/31.
 */
 
@serverendpoint("/websocket/{sid}")
@component
@slf4j
public class websocketserver {
  //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
  private static int onlinecount = 0;
  //concurrent包的线程安全set，用来存放每个客户端对应的mywebsocket对象。
  private static copyonwritearrayset<websocketserver> websocketset = new copyonwritearrayset<websocketserver>();
 
  //与某个客户端的连接会话，需要通过它来给客户端发送数据
  private session session;
 
  //接收sid
  private string sid="";
 
 
  */
/**
   * 连接建立成功调用的方法*//*
  @onopen
  public void onopen(session session, @pathparam("sid") string sid) {
    this.session = session;
    websocketset.add(this);   //加入set中
    addonlinecount();      //在线数加1
    log.info("有新窗口开始监听:"+sid+",当前在线人数为" + getonlinecount());
    this.sid=sid;
    try {
      sendmessage("连接成功");
    } catch (ioexception e) {
      log.error("websocket io异常");
    }
  }
  */
/**
   * 连接关闭调用的方法
   *//*
  @onclose
  public void onclose() {
    websocketset.remove(this); //从set中删除
    subonlinecount();      //在线数减1
    log.info("有一连接关闭！当前在线人数为" + getonlinecount());
  }
  */
/**
   * 收到客户端消息后调用的方法
   *
   * @param message 客户端发送过来的消息*//*
  @onmessage
  public void onmessage(string message, session session) {
    log.info("收到来自窗口"+sid+"的信息:"+message);
    //群发消息
    for (websocketserver item : websocketset) {
      try {
        item.sendmessage(message);
      } catch (ioexception e) {
        e.printstacktrace();
      }
    }
  }
  */
/**
   *
   * @param session
   * @param error
   *//*
  @onerror
  public void onerror(session session, throwable error) {
    log.error("发生错误");
    error.printstacktrace();
  }
  */
/**
   * 实现服务器主动推送
   *//*
  public void sendmessage(string message) throws ioexception {
    this.session.getbasicremote().sendtext(message);
  }
  */
/**
   * 群发自定义消息
   * *//*
  public static void sendinfo(string message,@pathparam("sid") string sid) throws ioexception {
    log.info("推送消息到窗口"+sid+"，推送内容:"+message);
    for (websocketserver item : websocketset) {
      try {
        //这里可以设定只推送给这个sid的，为null则全部推送
        if(sid==null) {
          item.sendmessage(message);
        }else if(item.sid.equals(sid)){
          item.sendmessage(message);
        }
      } catch (ioexception e) {
        continue;
      }
    }
  }
  public static synchronized int getonlinecount() {
    return onlinecount;
  }
  public static synchronized void addonlinecount() {
    websocketserver.onlinecount++;
  }
  public static synchronized void subonlinecount() {
    websocketserver.onlinecount--;
  }
  public static copyonwritearrayset<websocketserver> getwebsocketset() {
    return websocketset;
  }
}

1.3：添加对应的controller

@controller
@requestmapping("/system")
public class systemcontroller {
  //页面请求
  @getmapping("/index/{userid}")
  public modelandview socket(@pathvariable string userid) {
    modelandview mav=new modelandview("/socket1");
    mav.addobject("userid", userid);
    return mav;
  }
  //推送数据接口
  @responsebody
  @requestmapping("/socket/push/{cid}")
  public map pushtoweb(@pathvariable string cid, string message) {
    map result = new hashmap();
    try {
      websocketserver.sendinfo(message,cid);
      result.put("code", 200);
      result.put("msg", "success");
    } catch (ioexception e) {
      e.printstacktrace();
    }
    return result;
  }

 1.4：提供socket1.html页面

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8"></meta>
  <title>title</title>
</head>
<body>
hello world!
 
</body>
<script>
  var socket;
  if(typeof(websocket) == "undefined") {
    console.log("您的浏览器不支持websocket");
  }else{
    console.log("您的浏览器支持websocket");
    //实现化websocket对象，指定要连接的服务器地址与端口 建立连接
    //等同于
    index = new websocket("ws://localhost:8885/websocket/2");
    //socket = new websocket("${basepath}websocket/${cid}".replace("http","ws"));
    //打开事件
    index.onopen = function() {
      console.log("socket 已打开");
      //socket.send("这是来自客户端的消息" + location.href + new date());
    };
    //获得消息事件
    index.onmessage = function(msg) {
      console.log(msg.data);
      //发现消息进入  开始处理前端触发逻辑
    };
    //关闭事件
    index.onclose = function() {
      console.log("socket已关闭");
    };
    //发生了错误事件
    index.onerror = function() {
      alert("socket发生了错误");
      //此时可以尝试刷新页面
    }
    //离开页面时，关闭socket
    //jquery1.8中已经被废弃，3.0中已经移除
    // $(window).unload(function(){
    //   socket.close();
    //});
  }
</script>
</html>

 总结：

浏览器debug访问 localhost:8885/system/index/1跳转到socket1.html，js自动连接server并传递cid到服务端，服务端对应的推送消息到客户端页面（cid区分不同的请求，server里提供的有群发消息方法）

2.1：基于stomp协议的websocket

使用stomp的好处在于，它完全就是一种消息队列模式，你可以使用生产者与消费者的思想来认识它，发送消息的是生产者，接收消息的是消费者。而消费者可以通过订阅不同的destination，来获得不同的推送消息，不需要开发人员去管理这些订阅与推送目的地之前的关系，spring官网就有一个简单的spring-boot的stomp-demo,如果是基于springboot，大家可以根据spring上面的教程试着去写一个简单的demo。

提供websocketconfig配置类

/**
 * @description:
registerstompendpoints(stompendpointregistry registry)
configuremessagebroker(messagebrokerregistry config)
这个方法的作用是定义消息代理，通俗一点讲就是设置消息连接请求的各种规范信息。
registry.enablesimplebroker("/topic")表示客户端订阅地址的前缀信息，也就是客户端接收服务端消息的地址的前缀信息（比较绕，看完整个例子，大概就能明白了）
registry.setapplicationdestinationprefixes("/app")指服务端接收地址的前缀，意思就是说客户端给服务端发消息的地址的前缀
 * @author:[e-mail]
 * @date: 2019/5/31
 */
@configuration
@enablewebsocketmessagebroker
public class websocketconfig extends abstractwebsocketmessagebrokerconfigurer {
 
//  这个方法的作用是添加一个服务端点，来接收客户端的连接。
//  registry.addendpoint("/socket")表示添加了一个/socket端点，客户端就可以通过这个端点来进行连接。
//  withsockjs()的作用是开启sockjs支持，
  @override
  public void registerstompendpoints(stompendpointregistry registry) {
    registry.addendpoint("/socket").withsockjs();
  }
  @override
  public void configuremessagebroker(messagebrokerregistry registry) {
    //表示客户端订阅地址的前缀信息，也就是客户端接收服务端消息的地址的前缀信息
    registry.enablesimplebroker("/topic");
    //指服务端接收地址的前缀，意思就是说客户端给服务端发消息的地址的前缀
    registry.setapplicationdestinationprefixes("/app");
  }
}

 2.2：controller提供对应请求的接口

//页面请求
  @getmapping("/socket2")
  public modelandview socket2() {//@pathvariable string userid
    modelandview mav=new modelandview("html/socket2");
    //mav.addobject("userid", userid);
    return mav;
  }
 
  /**
   * @description:这个方法是接收客户端发送功公告的websocket请求，使用的是@messagemapping
   * @author:[e-mail]
   * @date: 2019/5/31
   */
  @messagemapping("/change-notice")//客户端访问服务端的时候config中配置的服务端接收前缀也要加上 例：/app/change-notice
  @sendto("/topic/notice")//config中配置的订阅前缀记得要加上
  public custommessage greeting(custommessage message){
    system.out.println("服务端接收到消息："+message.tostring());
    //我们使用这个方法进行消息的转发发送！
    //this.simpmessagingtemplate.convertandsend("/topic/notice", value);(可以使用定时器定时发送消息到客户端)
    //    @scheduled(fixeddelay = 1000l)
    //    public void time() {
    //      messagingtemplate.convertandsend("/system/time", new date().tostring());
    //    }
    //也可以使用sendto发送
    return message;
  }

2.3：提供socket2.html

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8" />
  <title>spring boot+websocket+广播式</title>
 
</head>
<body onload="disconnect()">
<noscript><h2 style="color: #ff0000">貌似你的浏览器不支持websocket</h2></noscript>
<div>
  <div>
    <button id="connect" onclick="connect();">连接</button>
    <button id="disconnect" disabled="disabled" onclick="disconnect();">断开连接</button>
  </div>
  <div id="conversationdiv">
    <label>输入你的名字</label><input type="text" id="name" />
    <button id="sendname" onclick="sendname();">发送</button>
    <p id="response"></p>
  </div>
</div>
<script th:src="@{/js/sockjs.min.js}"></script>
<script th:src="@{/js/stomp.min.js}"></script>
<script th:src="@{/js/jquery-3.2.1.min.js}"></script>
<script type="text/javascript">
  var stompclient = null;
 
  function setconnected(connected) {
    document.getelementbyid('connect').disabled = connected;
    document.getelementbyid('disconnect').disabled = !connected;
    document.getelementbyid('conversationdiv').style.visibility = connected ? 'visible' : 'hidden';
    $('#response').html();
  }
 
  function connect() {
    var socket = new sockjs('/socket'); //1
    stompclient = stomp.over(socket);//2
    stompclient.connect({}, function(frame) {//3
      setconnected(true);
      console.log('开始进行连接connected: ' + frame);
      stompclient.subscribe('/topic/notice', function(respnose){ //4
        showresponse(json.parse(respnose.body).responsemessage);
      });
    });
  }
 
 
  function disconnect() {
    if (stompclient != null) {
      stompclient.disconnect();
    }
    setconnected(false);
    console.log("disconnected");
  }
 
  function sendname() {
    var name = $('#name').val();
    stompclient.send("/app/change-notice", {}, json.stringify({ 'name': name }));//5
  }
 
  function showresponse(message) {
    var response = $("#response");
    response.html(message);
  }
</script>
</body>
</html>

2.4:对应的js引用可以去网上下载

2.5：浏览器debug访问localhost:8885/system/socket2，点击连接连接到服务器，数据内容可以推送到服务器以及服务器消息回推。

2.6：实现前端和服务端的轮训可以页面ajax轮训也可以后端添加定时器

@component
@enablescheduling
public class timetask {
  private static logger logger = loggerfactory.getlogger(timetask.class);
 
  @scheduled(cron = "0/20 * * * * ?")
  public void test(){
    system.err.println("*********  定时任务执行  **************");
    copyonwritearrayset<websocketserver> websocketset =
        websocketserver.getwebsocketset();
    int i = 0 ;
    websocketset.foreach(c->{
      try {
        c.sendmessage(" 定时发送 " + new date().tolocalestring());
      } catch (ioexception e) {
        e.printstacktrace();
      }
    });
 
    system.err.println("/n 定时任务完成.......");
  }
}

代码在 的admin项目里

基于stomp协议的广播模式和点对点模式消息推送可参考：

https://www.cnblogs.com/hhhshct/p/8849449.html

https://www.cnblogs.com/jmcui/p/8999998.html

到此这篇关于springboot集成websocket的两种实现方式的文章就介绍到这了,更多相关springboot集成websocket内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！