Java中Spring WebSocket详解

首先 pom.xml

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.5.8.RELEASE</version>
</parent>
<dependency>
	<groupId>org.apache.commons</groupId>
	<artifactId>commons-io</artifactId>
</dependency>
<dependency>
	<groupId>javax.websocket</groupId>
	<artifactId>javax.websocket-api</artifactId>
	<version>1.0</version>
	<scope>provided</scope>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-websocket</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
	<exclusions>
		<exclusion>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
		</exclusion>
	</exclusions>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

接收消息后的处理类 GameHandler :

import java.net.URI;
import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.PongMessage;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.AbstractWebSocketHandler;

public class GameHandler extends AbstractWebSocketHandler {
 /**
  * 处理字符串类的信息
  *
  * @param session
  * @param message
  * @throws Exception
  */
 @Override
 protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
  session.sendMessage(new TextMessage(message.asBytes()));
 }

 /**
  * 处理二进制类的信息
  *
  * @param session
  * @param message
  * @throws Exception
  */
 @Override
 protected void handleBinaryMessage(WebSocketSession session, BinaryMessage message) throws Exception {
  session.sendMessage(new BinaryMessage(message.getPayload()));
 }

 /**
  * ping-pong
  *
  * @param session
  * @param message
  * @throws Exception
  */
 @Override
 protected void handlePongMessage(WebSocketSession session, PongMessage message) throws Exception {

 }
 /**
  * 传出错误的处理
  *
  * @param session
  * @param exception
  * @throws Exception
  */
 @Override
 public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
 }
 /**
  * 连接关闭的处理
  *
  * @param session
  * @param status
  * @throws Exception
  */
 @Override
 public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
 }
 /**
  * 连接建立后的处理
  *
  * @param session
  * @throws Exception
  */
 @Override
 public void afterConnectionEstablished(WebSocketSession session) throws Exception {
 }
}

握手信息拦截器 WebSocketHandshakeInterceptor :

import java.util.Map;
import javax.servlet.http.Cookie;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

public class WebSocketHandshakeInterceptor implements HandshakeInterceptor {
 @Override
 public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse shr1, WebSocketHandler wsh, Map<String, Object> attributes) throws Exception {
  // 此处可以做一些权限认证的事情或者其他
  return true;
 }
 @Override
 public void afterHandshake(ServerHttpRequest shr, ServerHttpResponse shr1, WebSocketHandler wsh, Exception excptn) {
 }
}

使用WebSocket的配置类 WebSocketConfig :

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig extends WebMvcConfigurerAdapter implements WebSocketConfigurer {
@Override
 public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
  // 允许连接的域,只能以http或https开头
  String[] allowsOrigins = {"http://127.0.0.1:1213", "http://localhost:1213"};
  registry.addHandler(gameHandler(),"/game").addInterceptors(handshakeInterceptor()).setAllowedOrigins(allowsOrigins);
 }
 @Bean
 public GameHandler gameHandler() {
  return new GameHandler();
 }
 @Bean
 public WebSocketHandshakeInterceptor handshakeInterceptor() {
  return new WebSocketHandshakeInterceptor();
 }
}

启动类 Launcher :

@SpringBootApplication
public class Launcher {
 public static void main(String[] params) {
  SpringApplication.run(Launcher.class, params);
	}
}

配置文件 main/resources/application.properties:

server.port=1213
server.session-timeout=1800
server.undertow.io-threads=4
server.undertow.worker-threads=20
server.undertow.buffer-size=1024
server.undertow.buffers-per-region=1024
server.undertow.direct-buffers=true

前端的测试页面 main\resources\static\index.html

<!DOCTYPE html>
<html lang="zh-CN">
 <head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Platform Gateway</title>
  <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="external nofollow" rel="stylesheet">
  <!--<link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap-theme.min.css" rel="external nofollow" rel="stylesheet">-->
  <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
  <script src="https://cdn.bootcss.com/jquery-scrollTo/2.1.2/jquery.scrollTo.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/pako/1.0.6/pako.min.js"></script>
  <!--[if lt IE 9]>
   <script src="https://cdn.bootcss.com/html5shiv/3.7.3/html5shiv.min.js"></script>
   <script src="https://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
  <![endif]-->
  <style>
   #message{
    height: 600px;
    overflow-y:auto;
   }
  </style>
 </head>
 <body>
  <div class="container">
   <h1>WebSocket Test Page</h1>
   <hr/>
   <div class="form-inline">
    <div class="form-group">
     <label for="wsAddr">WebSocket Address: </label>
     <div class="input-group">
      <span class="input-group-addon" id="basic-ws">ws://127.0.0.1:1213/</span>
      <input type="text" class="form-control" id="basic-ws-addr" aria-describedby="basic-ws" placeholder="game" data-container="body" data-placement="top" data-content="链接地址不能为空,请填写">
     </div>
    </div>
    <button type="button" id="btnConnect" class="btn btn-primary" onclick="connect();">
     <span class="glyphicon glyphicon-resize-small" aria-hidden="true"></span>
     连接
    </button>
    <button type="button" id="btnClose" class="btn btn-danger" disabled="disabled" onclick="closeWebSocket();">
     <span class="glyphicon glyphicon-remove" aria-hidden="true"></span>
     断开
    </button>
    <button type="button" id="btnSend" class="btn btn-info" disabled="disabled" style="margin-left: 50px;" onclick="send();">
     <span class="glyphicon glyphicon-transfer" aria-hidden="true"></span>
     发送消息
    </button>
   </div><br/>
   <textarea class="form-control" id="inMsg" rows="5" placeholder="在这里输入需要发送的信息..."></textarea>
   <hr/>
   <div id="message"></div>
  </div>
  <script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
  <script type="text/javascript">
     function zip(str) {
      var binaryString = pako.gzip(str, {to: 'string'});
      return btoa(binaryString);
     }
     function unzip(b64Data) {
      var strData = atob(b64Data);
      var charData = strData.split('').map(function (x) {
       return x.charCodeAt(0);
      });
      var binData = new Uint8Array(charData);
      var data = pako.inflate(binData);
      strData = String.fromCharCode.apply(null, new Uint16Array(data));
      return strData;
     }
     var websocket = null;
     var wsBaseUrl = null;
     var wsUrl = null;
     function init() {
      wsBaseUrl = "ws://" + window.location.host + "/";
      $("#basic-ws").text(wsBaseUrl);
      $(function () {
       $('[data-toggle="popover"]').popover();
      });
      return false;
     }
//关闭WebSocket连接
     function closeWebSocket() {
      if (websocket) {
       websocket.close();
      }
      return false;
     }

//将消息显示在网页上
     function setMessageInnerHTML(who, msg) {
      var message = null;
      if (who === 1) {
       message = '<div class="alert alert-success" role="alert">本地: ' + msg + '</div>';
      } else {
       message = '<div class="alert alert-info" role="alert">服务器: ' + msg + '</div>';
      }
      document.getElementById('message').innerHTML = (document.getElementById('message').innerHTML + message);
      $("#message").scrollTo('100%');
      return false;
     }

//发送消息
     function send() {
      if (websocket) {
       var message = $("#inMsg").val();
       websocket.send(zip(message));
       setMessageInnerHTML(1, message);
      }
      return false;
     }
     function connect() {
      var url = $("#basic-ws-addr").val();
      if (url.length <= 0) {
       $('#basic-ws-addr').popover('show');
       setTimeout(function () {
        $('#basic-ws-addr').popover('hide');
       }, 3000);
      } else {
       wsUrl = wsBaseUrl + url;
       if ('WebSocket' in window) {
        websocket = new WebSocket(wsUrl);
        //连接发生错误的回调方法
        websocket.onerror = function () {
         setMessageInnerHTML(0, "WebSocket连接发生错误 -> " + wsUrl);
         $("#btnConnect").removeAttr("disabled");
         $("#btnClose").attr("disabled", "disabled");
         $("#btnSend").attr("disabled", "disabled");
        };

        //连接成功建立的回调方法
        websocket.onopen = function () {
         setMessageInnerHTML(0, "WebSocket连接成功 -> " + wsUrl);
         $("#btnConnect").attr("disabled", "disabled");
         $("#btnClose").removeAttr("disabled");
         $("#btnSend").removeAttr("disabled");
        };

        //接收到消息的回调方法
        websocket.onmessage = function (event) {
         setMessageInnerHTML(0, unzip(event.data));
        };

        //连接关闭的回调方法
        websocket.onclose = function () {
         setMessageInnerHTML(0, "WebSocket连接关闭 -> " + wsUrl);
         $("#btnConnect").removeAttr("disabled");
         $("#btnClose").attr("disabled", "disabled");
         $("#btnSend").attr("disabled", "disabled");
        };

        //监听窗口关闭事件,当窗口关闭时,主动去关闭websocket连接,防止连接还没断开就关闭窗口,server端会抛异常。
        window.onbeforeunload = function () {
         closeWebSocket();
        };
       } else {
        alert('Not support websocket');
       }
      }
      return false;
     }
     window.onload = init();
  </script>
 </body>
</html>

到此就可以使用 WebSocket 进行前后端的通信了,如果大家还有不明白的或者有更好的方法,可以在下方的留言区讨论。

(0)

相关推荐

  • Java Socket编程心跳包创建实例解析

    1.什么是心跳包? 心跳包就是在客户端和服务器间定时通知对方自己状态的一个自己定义的命令字,按照一定的时间间隔发送,类似于心跳,所以叫做心跳包. 用来判断对方(设备,进程或其它网元)是否正常运行,采用定时发送简单的通讯包,如果在指定时间段内未收到对方响应,则判断对方已经离线.用于检测TCP的异常断开.基本原因是服务器端不能有效的判断客户端是否在线,也就是说,服务器无法区分客户端是长时间在空闲,还是已经掉线的情况.所谓的心跳包就是客户端定时发送简单的信息给服务器端告诉它我还在而已.代码就是每隔几分

  • 基于BIO的Java Socket通信详解

    BIO,即阻塞IO,在基于Socket的消息通信过程中,Socket服务端向外部提供服务,而Socket客户端可以建立到Socket服务端的连接,进而发送请求数据,然后等待Socket服务端处理,并返回处理结果(响应). 基于BIO的通信,Socket服务端会发生阻塞,即在监听过程中每次accept到一个客户端的Socket连接,就要处理这个请求,而此时其他连接过来的客户端只能阻塞等待.可见,这种模式下Socket服务端的处理能力是非常有限的,客户端也只能等待,直到服务端空闲时进行请求的处理.

  • Java Socket编程服务器响应客户端实例代码

    通过输入流来读取客户端信息,相应的时候通过输出流来实现. 服务端类的代码: import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.net.ServerSocket; impo

  • Java编程Socket实现多个客户端连接同一个服务端代码

    Java Socket(套接字)通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄.应用程序通常通过"套接字"向网络发出请求或者应答网络请求. 使用Socket实现多个客户端和同一客户端通讯:首先客户端连接服务端发送一条消息,服务端接收到消息后进行处理,完成后再回复客户端一条消息.本人通过自己的思维编写了一份服务端和客户端实现的代码,望能与大家相互学习,共同进步. 服务端代码 /** * Socket服务端 * 功能说明: * */ public cl

  • Java Socket通信之聊天室功能

    本文实例为大家分享了Java Socket聊天室功能的具体代码,供大家参考,具体内容如下 Client.java import java.io.*; import java.net.*; import java.util.*; public class Client { public int port = 8083; Socket socket = null; public static void main(String[] args) { new Client(); //开始执行 } publ

  • Java多线程编程实现socket通信示例代码

    流传于网络上有关Java多线程通信的编程实例有很多,这一篇还算比较不错,代码可用.下面看看具体内容. TCP是Tranfer Control Protocol的 简称,是一种面向连接的保证可靠传输的协议.通过TCP协议传输,得到的是一个顺序的无差错的数据流.发送方和接收方的成对的两个socket之间必须建 立连接,以便在TCP协议的基础上进行通信,当一个socket(通常都是server socket)等待建立连接时,另一个socket可以要求进行连接,一旦这两个socket连接起来,它们就可以

  • Java Socket通信介绍及可能遇到的问题解决

    前言 本文主要给大家介绍了关于Java中Socket通信的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. Java中基于TCP协议实现网络通信的两个类:客户端的Socket和服务器端的ServerSocket. Socket通信模型如图所示: 不管Socket通信的功能有多复杂,任何socket通信过程的基本结构都是一样的. 其基本步骤为: ①分别在客户端和服务器端创建Socket和ServerSocket实例:服务器端通过.accept()方法等待请求并阻塞.请求收

  • Java编程利用socket多线程访问服务器文件代码示例

    这篇文章将向大家展示Java编程利用socket多线程访问服务器文件代码示例,如果您想先了解Java多线程socket编程的基础知识,可以看下这篇文章:Java多线程编程实现socket通信示例代码. 接下来进入正文,我们看看利用socket多线程访问服务器代码: ServerMain.java package com.ysk.webServer; import java.io.File; import java.io.IOException; import java.net.ServerSoc

  • Java中Spring WebSocket详解

    首先 pom.xml <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.8.RELEASE</version> </parent> <dependency> <groupId>org.apache.com

  • Java中的静态内部类详解及代码示例

    1. 什么是静态内部类 在Java中有静态代码块.静态变量.静态方法,当然也有静态类,但Java中的静态类只能是Java的内部类,也称为静态嵌套类.静态内部类的定义如下: public class OuterClass { static class StaticInnerClass { ... } } 在介绍静态内部类之前,首先要弄清楚静态内部类与Java其它内部类的区别. 2. 内部类 什么是内部类?将一个类的定义放在另一个类的内部,就是内部类.Java的内部类主要分为成员内部类.局部内部类.

  • java中正则表达式实例详解

    Java中正则表达式运用实例(参看java中正则表达式运用详解): 测试代码 package test; /** * 在String的matches()方法,split()方法中使用正则表达式. * @author fhd001 */ public class RegexTest { public static void main(String[] args) { /* * 普通字符 */ String str1 = "abc45abc345"; String[]arr1 = str1

  • Java中初始化块详解及实例代码

    Java中初始化块详解 在Java中,有两种初始化块:静态初始化块和非静态初始化块. 静态初始化块:使用static定义,当类装载到系统时执行一次.若在静态初始化块中想初始化变量,那仅能初始化类变量,即static修饰的数据成员. 非静态初始化块:在每个对象生成时都会被执行一次,可以初始化类的实例变量. 非静态初始化块会在构造函数执行时,且在构造函数主体代码执行之前被运行. 括号里的是初始化块,这里面的代码在创建Java对象时执行,而且在构造器之前执行! 其实初始化块就是构造器的补充,初始化块是

  • Java中的HashSet详解和使用示例_动力节点Java学院整理

    第1部分 HashSet介绍 HashSet 简介 HashSet 是一个没有重复元素的集合. 它是由HashMap实现的,不保证元素的顺序,而且HashSet允许使用 null 元素. HashSet是非同步的.如果多个线程同时访问一个哈希 set,而其中至少一个线程修改了该 set,那么它必须 保持外部同步.这通常是通过对自然封装该 set 的对象执行同步操作来完成的.如果不存在这样的对象,则应该使用 Collections.synchronizedSet 方法来"包装" set.

  • java 中cookie的详解及简单实例

    java 中cookie的详解 Java对cookie的操作比较简单,主要介绍下建立cookie和读取cookie,以及如何设定cookie的生命周期和cookie的路径问题. 建立一个无生命周期的cookie,即随着浏览器的关闭即消失的cookie,代码如下 HttpServletRequest request HttpServletResponse response Cookie cookie = new Cookie("cookiename","cookievalue&

  • Java中final关键字详解

    谈到final关键字,想必很多人都不陌生,在使用匿名内部类的时候可能会经常用到final关键字.另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法. 主要介绍:一.final关键字的基本用法.二.深入理解final关键字 一.final关键字的基本用法 在Java中,final关键字可以用来修饰类.方法和变量(包括成员变量和局部变量).下面就从这三个方面来了解一下final关键字的基本用法. 1.修饰类 当用final修饰一个类时,表明这个类不能

  • Java 中的HashMap详解和使用示例_动力节点Java学院整理

    第1部分 HashMap介绍 HashMap简介 HashMap 是一个散列表,它存储的内容是键值对(key-value)映射. HashMap 继承于AbstractMap,实现了Map.Cloneable.java.io.Serializable接口. HashMap 的实现不是同步的,这意味着它不是线程安全的.它的key.value都可以为null.此外,HashMap中的映射不是有序的. HashMap 的实例有两个参数影响其性能:"初始容量" 和 "加载因子&quo

  • java 中归并排序算法详解

    java 中归并排序算法详解 归并排序算法,顾名思义,是一种先分再合的算法,其算法思想是将要排序的数组分解为单个的元素,每个元素就是一个单个的个体,然后将相邻的两个元素进行从小到大或从大到小的顺序排序组成一个整体,每个整体包含一到两个元素,然后对相邻的整体继续"合"并,因为每个整体都是排过序的,因而可以采用一定的算法对其进行合并,合并之后每个整体包含三到四个元素,继续对相邻的整体进行合并,直到所有的整体都合并为一个整体,最终得到的整体就是将原数组进行排序之后的结果. 对于相邻的整体,其

  • java中参数传递方式详解

    java中参数传递方式详解 java新手入门面临的一个经典的话题,本文意在终结这个话题,java中有说法:Java里面参数传递都是按值传递,怎么理解这句话?用文字说明恐怕不容易说明白,说明白恐怕也难以想明白. 前提 先明确一下,按值还是按引用的概念,它是来自c++语言,引用不是汉语词典中的一个词,而是c++的概念--"&"这个符号还记得吧? 为什么有这个话题呢?其一,是对按引用传递理解不透彻:其二,诸多java书籍及讨论论点并没有切中要害. 一句话概括,按值传参还是按引用传参,

随机推荐