Principes et connaissances de base de WebSocket pour implémenter le push de messages d'arrière-plan Java-javaDidacticiel-php.cn

1. Qu'est-ce que WebSocket

Le protocole WebSocket est un nouveau protocole réseau basé sur TCP. Il implémente une communication en duplex intégral entre le navigateur et le serveur, permettant au serveur d'envoyer des informations de manière proactive au client.

2. Principe de mise en œuvre

Dans le processus de mise en œuvre d'une connexion Websocket, une demande de connexion Websocket doit être envoyée via le navigateur, puis le serveur envoie une réponse. Ce processus est généralement appelé une. "poignée de main". Dans l'API WebSocket, le navigateur et le serveur n'ont besoin que d'effectuer une action de négociation, puis un canal rapide est formé entre le navigateur et le serveur. Les données peuvent être transmises directement entre les deux.

3. Avantages

Dans le mécanisme de transmission de messages précédent, l'interrogation Ajax était utilisée et le navigateur émettait automatiquement des requêtes à des intervalles de temps spécifiques. La méthode consomme beaucoup de ressources car il s’agit essentiellement d’une requête HTTP et elle est très maladroite. WebSocket effectue une négociation entre le navigateur et le serveur. Une fois la connexion établie, le serveur peut transmettre activement des données au client, et le client peut également envoyer des données au serveur à tout moment.

4. La différence entre WebSocket et Socket

1.WebSocket :

La phase d'établissement de la communication websocket s'appuie sur le protocole http. La phase initiale de prise de contact est le protocole http. Une fois la prise de contact terminée, elle passe au protocole websocket et est complètement séparée du protocole http.
Lors de l'établissement de la communication, le client initie activement une demande de connexion et le serveur écoute passivement.
Une fois la connexion de communication établie, la communication est en mode "full-duplex". En d'autres termes, le serveur et le client peuvent envoyer librement des données à tout moment, ce qui est très approprié pour les scénarios commerciaux dans lesquels le serveur souhaite transmettre activement des données en temps réel.
Le mode d'interaction n'est plus le mode "requête-réponse", et le protocole de communication est entièrement conçu par le développeur.
Les données de communication sont basées sur un « frame », qui peut transmettre directement des données textuelles ou des données binaires, avec une grande efficacité. Bien entendu, les développeurs doivent également prendre en compte les détails techniques tels que l’emballage, le déballage et la numérotation.

　2.Socket :

Le serveur surveille la communication et fournit passivement des services le client initie activement une demande de connexion au serveur ; , La communication est établie.
Chaque interaction est la suivante : le client initie activement une demande (requête) et le serveur répond passivement (réponse).
Le serveur ne peut pas transmettre activement les données au client.
Les données communiquées sont basées sur le format texte. Les données binaires (telles que les images, etc.) doivent être converties en texte en base64 et par d'autres moyens avant de pouvoir être transmises.

5. Client WebSocket :

var websocket = null;

var host = document.location.host;

var username = "${loginUsername}"; // 获得当前登录人员的userName

// alert(username)

//判断当前浏览器是否支持WebSocket

if ('WebSocket' in window) {

alert("浏览器支持Websocket")

websocket = new WebSocket('ws://'+host+'/mm-dorado/webSocket/'+username);

} else {

alert('当前浏览器 Not support websocket')

}

//连接发生错误的回调方法

websocket.onerror = function() {

　　alert("WebSocket连接发生错误")

setMessageInnerHTML("WebSocket连接发生错误");

};

//连接成功建立的回调方法

websocket.onopen = function() {

　　alert("WebSocket连接成功")

setMessageInnerHTML("WebSocket连接成功");

}

//接收到消息的回调方法

websocket.onmessage = function(event) {

alert("接收到消息的回调方法")

alert("这是后台推送的消息："+event.data);

　　　　 websocket.close();

　　　　alert("webSocket已关闭！")

}

//连接关闭的回调方法

websocket.onclose = function() {

setMessageInnerHTML("WebSocket连接关闭");

}

//监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。

window.onbeforeunload = function() {

closeWebSocket();

}

//关闭WebSocket连接

function closeWebSocket() {

websocket.close();

}

//将消息显示在网页上

function setMessageInnerHTML(innerHTML) {

document.getElementById('message').innerHTML += innerHTML + '<br/>';

}

6. Serveur WebSocket (arrière-plan Java) :

1. Classe principale :

package com.mes.util;

import java.io.IOException;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import javax.websocket.OnClose;

import javax.websocket.OnError;

import javax.websocket.OnMessage;

import javax.websocket.OnOpen;

import javax.websocket.Session;

import javax.websocket.server.PathParam;

import javax.websocket.server.ServerEndpoint;

import org.springframework.stereotype.Component;

import org.springframework.stereotype.Service;

import com.google.gson.JsonObject;

import net.sf.json.JSONObject;

@ServerEndpoint("/webSocket/{username}")

public class WebSocket {

private static int onlineCount = 0;

private static Map<String, WebSocket> clients = new ConcurrentHashMap<String, WebSocket>();

private Session session;

private String username;

@OnOpen

public void onOpen(@PathParam("username") String username, Session session) throws IOException {

this.username = username;

this.session = session;

addOnlineCount();

clients.put(username, this);

System.out.println("已连接");

}

@OnClose

public void onClose() throws IOException {

clients.remove(username);

subOnlineCount();

}

@OnMessage

public void onMessage(String message) throws IOException {

JSONObject jsonTo = JSONObject.fromObject(message);

String mes = (String) jsonTo.get("message");

if (!jsonTo.get("To").equals("All")){

sendMessageTo(mes, jsonTo.get("To").toString());

}else{

sendMessageAll("给所有人");

}

@OnError

public void onError(Session session, Throwable error) {

error.printStackTrace();

}

public void sendMessageTo(String message, String To) throws IOException {

// session.getBasicRemote().sendText(message);

//session.getAsyncRemote().sendText(message);

for (WebSocket item : clients.values()) {

if (item.username.equals(To) )

item.session.getAsyncRemote().sendText(message);

}

public void sendMessageAll(String message) throws IOException {

for (WebSocket item : clients.values()) {

item.session.getAsyncRemote().sendText(message);

}

public static synchronized int getOnlineCount() {

return onlineCount;

}

public static synchronized void addOnlineCount() {

WebSocket.onlineCount++;

}

public static synchronized void subOnlineCount() {

WebSocket.onlineCount--;

}

public static synchronized Map<String, WebSocket> getClients() {

return clients;

}

　2. Appelez votre propre code :

WebSocket ws = new WebSocket();

JSONObject jo = new JSONObject();

jo.put("message", "这是后台返回的消息！");

jo.put("To",invIO.getIoEmployeeUid());

ws.onMessage(jo.toString());

1 2 3 4 5

WebSocket ws = nouveau WebSocket(); JSONObject jo = nouveau JSONObject(); jo.put("message", "Voici le message renvoyé par l'arrière-plan!" ); jo.put("À",invIO.getIoEmployeeUid()); ws.onMessage(jo.toString());

　　7.所需maven依赖：

<dependency>

<groupId>javax.websocket</groupId>

<artifactId>javax.websocket-api</artifactId>

<version>1.1</version>

<scope>provided</scope>

</dependency>

<dependency>

<groupId>javax</groupId>

<artifactId>javaee-api</artifactId>

<version>7.0</version>

<scope>provided</scope>

</dependency>

2 3

4 5

9 10 11 12 13 14 15

 <dépendance> <groupId>javax.websocket</groupId> <artifactId>javax.websocket-api</artifactId> <version>1.1</version> <scope>fourni</scope> </dépendance> <dépendance> <groupId>javax</groupId> <artifactId>javaee-api</artifactId> <version>7.0</version> <scope>fourni</scope> </dépendance> 

相关文章：Java中websocket消息推送一个基于WebSocket的WEB消息推送框架相关视频：Websocket视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!