Was ist der Unterschied zwischen WebSocket und Socket?

Unterschied: Socket ist die API des TCP/IP-Netzwerks. Es handelt sich um eine abstrahierte Schicht, um die Verwendung von TCP oder UDP zu erleichtern. Es handelt sich um eine Reihe von Schnittstellen zwischen der Anwendungsschicht und der Übertragungssteuerungsschicht Protokoll der Anwendungsschicht.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, Dell G3-Computer.

Verwandte Empfehlungen: „Programmiervideo“

Einführung und Prinzipien von WebSocket

Das WebSocket-Protokoll ist ein neues Protokoll von HTML5. Es implementiert eine Vollduplex-Kommunikation zwischen dem Browser und dem Server. Der erste Handshake muss mithilfe einer HTTP-Anfrage abgeschlossen werden.

——Baidu-Enzyklopädie

Zweck: Instant Messaging, Alternative zu Umfragen

Sofortnachrichten auf Websites sind weit verbreitet, z. B. QQ auf Webseiten, Chat-Systemen usw. Zur Lösung dieses Problems werden nach bisherigen technischen Möglichkeiten üblicherweise Polling- und Comet-Technologien eingesetzt.

HTTP-Protokoll ist ein nicht persistentes, einseitiges Netzwerkprotokoll. Nachdem eine Verbindung hergestellt wurde, darf der Browser nur eine Anfrage an den Server stellen, bevor der Server die entsprechenden Daten zurückgeben kann. Wenn Instant Messaging erforderlich ist, sendet der Browser durch Abfrage in einem bestimmten Zeitintervall (z. B. 1 Sekunde) eine Anforderungsanforderung an den Server und gibt dann die neuesten Daten an den Browser zurück. Der offensichtlichste Nachteil dieser Methode besteht darin, dass kontinuierlich Anfragen gesendet werden müssen und der Header der HTTP-Anfrage normalerweise sehr lang ist. Um eine kleine Datenmenge zu übertragen, muss ein hoher Preis gezahlt werden, was sehr unwirtschaftlich ist und beansprucht viel Bandbreite.

Nachteile: Es führt zu zu vielen unnötigen Anfragen, wodurch Datenverkehr und Serverressourcen verschwendet werden. Jede Anfrage und Antwort verschwendet eine gewisse Menge an Datenverkehr für dieselben Header-Informationen.

Das Aufkommen von WebSocket kann diesen Mangel jedoch ausgleichen. In WebSocket müssen Server und Browser lediglich eine Handshake-Aktion über das HTTP-Protokoll durchführen und dann einen separaten TCP-Kommunikationskanal für die Datenübertragung einrichten.

Prinzip

WebSocket ist ein Protokoll der Anwendungsschicht wie HTTP, aber es ist ein bidirektionales Kommunikationsprotokoll, das auf TCP basiert.

Verbindungsprozess – Handshake-Prozess

• 1. Browser und Server stellen eine TCP-Verbindung her, Drei-Wege-Handshake. Dies ist die Grundlage der Kommunikation, die Übertragungskontrollschicht. Wenn sie ausfällt, wird sie später nicht ausgeführt.
• 2. Nach erfolgreicher TCP-Verbindung übermittelt der Browser Informationen wie die von WebSocket unterstützte Versionsnummer über das HTTP-Protokoll an den Server. (HTTP-Handshake vor dem Start)
• 3. Nachdem der Server die Handshake-Anfrage des Clients erhalten hat, verwendet er auch das HTTP-Protokoll zur Rückmeldung von Daten.
• 4. Nach Erhalt der Verbindungserfolgsmeldung wird die Kommunikation über den TCP-Kanal übertragen.

Die Beziehung zwischen WebSocket und HTTP

Gleiche Punkte

• 1 Sie basieren beide auf TCP und sind beide zuverlässige Übertragungsprotokolle.
• 2. Es sind alles Protokolle der Anwendungsschicht.

Unterschiede

• 1. WebSocket ist ein bidirektionales Kommunikationsprotokoll, das das Socket-Protokoll simuliert und Informationen in beide Richtungen senden oder empfangen kann. HTTP ist einseitig.
• 2. WebSocket erfordert einen Handshake, um eine Verbindung herzustellen.

Kontakt

WebSocket Beim Aufbau eines Handshakes werden Daten über HTTP übertragen. Nach der Einrichtung ist das HTTP-Protokoll jedoch während der tatsächlichen Übertragung nicht mehr erforderlich.

Die Beziehung zwischen WebSocket und Socket

Socket ist eigentlich kein Protokoll, sondern eine zur Vereinfachung der Verwendung von TCP oder UDP abstrahierte Schicht. Es handelt sich um eine Reihe von Schnittstellen zwischen der Anwendungsschicht und der Übertragungssteuerungsschicht.

Socket ist eine zwischengeschaltete Software-Abstraktionsschicht für die Kommunikation zwischen der Anwendungsschicht und der TCP/IP-Protokollfamilie. Es handelt sich um eine Reihe von Schnittstellen. Im Entwurfsmodus ist Socket eigentlich ein Fassadenmodus, der die komplexe TCP/IP-Protokollfamilie hinter der Socket-Schnittstelle verbirgt. Für Benutzer ist alles eine Reihe einfacher Schnittstellen, die es Socket ermöglichen, Daten so zu organisieren, dass sie dem angegebenen Protokoll entsprechen.

Wenn zwei Hosts kommunizieren, müssen sie eine Verbindung über Socket herstellen, und Socket verwendet das TCP/IP-Protokoll, um eine TCP-Verbindung herzustellen. TCP-Verbindungen basieren stärker auf dem zugrunde liegenden IP-Protokoll, während IP-Protokollverbindungen auf niedrigeren Schichten wie der Verbindungsschicht basieren.

WebSocket ist ein typisches Protokoll der Anwendungsschicht.

Der Unterschied

Socket ist ein Protokoll der Übertragungssteuerungsschicht und WebSocket ist ein Protokoll der Anwendungsschicht.

Die Beziehung zwischen HTML5 und WebSocket

Die WebSocket-API ist Teil des HTML5-Standards. Dies bedeutet jedoch nicht, dass WebSocket in HTML verwendet werden muss oder nur in browserbasierten Anwendungen verwendet werden kann.

Tatsächlich bieten viele Sprachen, Frameworks und Server WebSocket-Unterstützung, wie zum Beispiel:

• * C-basiertes libwebsocket.org
• * Node.js-basiertes Socket.io
• * Python-basiertes ws4py
• * C++-basiertes WebSocket++
• * Apache-Unterstützung für WebSocket: Apache-Modul mod_proxy_wstunnel
• * Ngin x Unterstützung für WebSockets: NGINX als WebSockets-Proxy, NGINX kündigt Unterstützung für WebSocket-Protokoll und WebSocket-Proxying an
• * Betrieb des Mechanismus.

WebSocket ist ein neues Protokoll in HTML5. Es realisiert eine Vollduplex-Kommunikation zwischen dem Browser und dem Server, wodurch Serverressourcen und Bandbreite besser gespart werden können. Es basiert auf TCP und überträgt Daten wie HTTP über TCP.

WebSocket ist ein bidirektionales Kommunikationsprotokoll. Nach dem Herstellen einer Verbindung können der WebSocket-Server und der Browser/Client-Agent aktiv Daten aneinander senden oder empfangen, genau wie Socket; WebSocket erfordert einen TCP-ähnlichen Client und Server Die beiden Enden werden durch einen Handshake verbunden und können erst dann miteinander kommunizieren, wenn die Verbindung erfolgreich ist.

Die Interaktion zwischen herkömmlichem HTTP-Client und Server im Nicht-WebSocket-Modus ist wie in der folgenden Abbildung dargestellt:

Abbildung 1. Traditionelles HTTP-Request-Response-Client-Server-Interaktionsdiagramm

• Die Interaktion zwischen Client und Server Der WebSocket-Modus sieht wie folgt aus:

Abbildung 2. WebSocket-Anfrage-Antwort-Client-Server-Interaktionsdiagramm

Ein Vergleich der obigen Abbildung zeigt, dass im Vergleich zum herkömmlichen HTTP-Modus, bei dem jede Anfrage-Antwort vom Client eine Etablierung erfordert Bei der Verbindung mit dem Server ähnelt WebSocket dem Kommunikationsmodus für lange Socket-TCP-Verbindungen. Sobald die WebSocket-Verbindung hergestellt ist, werden nachfolgende Daten in Form einer Frame-Sequenz übertragen. Bevor der Client die WebSocket-Verbindung trennt oder der Server die Verbindung trennt, müssen Client und Server die Verbindungsanforderung nicht erneut initiieren. Bei massiver Parallelität und hoher Interaktionslast zwischen Client und Server wird der Verbrauch von Netzwerkbandbreitenressourcen erheblich gesenkt und es ergeben sich offensichtliche Leistungsvorteile. Darüber hinaus sendet und empfängt der Client Nachrichten in Echtzeit über dieselbe dauerhafte Verbindung. Der sexuelle Vorteil liegt auf der Hand.

Werfen wir einen Blick auf den Unterschied zwischen WebSocket-Kommunikation und herkömmlichem HTTP anhand der interaktiven Nachrichten zwischen Client und Server:

Auf dem Client instanziiert new WebSocket ein neues WebSocket-Clientobjekt, und die Verbindung ähnelt ws:/ /yourdomain: Die Server-WebSocket-URL des Ports/Pfads. Das WebSocket-Clientobjekt analysiert und identifiziert sie automatisch als WebSocket-Anfrage, wodurch eine Verbindung zum Server-Port hergestellt und der Handshake-Prozess zwischen den beiden Parteien durchgeführt wird Client ist ähnlich:

Listing 1. WebSocket-Client-Verbindungsbericht Wie aus dem Artikel

GET /webfin/websocket/ HTTP/1.1
Host: localhost
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: xqBt3ImNzJbYqRINxEFlkg==
Origin: 
http://localhost
:8080
Sec-WebSocket-Version: 13
http://localhost
:8080
Sec-WebSocket-Version: 13

hervorgeht, ähnelt die vom Client initiierte WebSocket-Verbindungsnachricht der herkömmlichen HTTP-Nachricht. Der Parameterwert „Upgrade: websocket“ zeigt dies an Dies ist eine Anfrage vom Typ WebSocket. „Sec-WebSocket-Key“ ist eine vom WebSocket-Client gesendete Anfrage. Der Base64-codierte Chiffretext erfordert, dass der Server eine entsprechende verschlüsselte „Sec-WebSocket-Accept“-Antwort zurückgibt Fehler „Fehler beim WebSocket-Handshake“ und schließen Sie die Verbindung.

Das vom Server nach Empfang der Nachricht zurückgegebene Datenformat ist ähnlich:

Listing 2. Antwortnachricht des WebSocket-Servers

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: K7DJLdLooIwIG/MOpvWFB3y3FE8=

Der Wert von „Sec-WebSocket-Accept“ wird vom Server mit demselben Schlüssel wie der Client berechnet Nach der Ausgabe wird „HTTP/1.1 101 Switching Protocols“ an den Client zurückgegeben. Dies zeigt an, dass der Server die Client-Verbindung des WebSocket-Protokolls akzeptiert. Nach einer solchen Anforderungs-Antwort-Verarbeitung ist der WebSocket-Verbindungs-Handshake des Client-Servers erfolgreich und die anschließende TCP-Kommunikation kann erfolgen durchgeführt werden.

In Bezug auf die Entwicklung ist die WebSocket-API ebenfalls sehr einfach. Wir müssen nur WebSocket instanziieren, eine Verbindung herstellen, und dann können der Server und der Client einander Nachrichten senden und darauf antworten Abschnitt zur WebSocket-Implementierung und Fallanalyse weiter unten.

WebSocket-Implementierung

Wie oben erwähnt, ist die Implementierung von WebSocket in zwei Teile unterteilt: den Client und den Server. Der Client (normalerweise ein Browser) gibt eine WebSocket-Verbindungsanforderung aus und der Server reagiert auf Implementierungsaktionen ähnlich dem TCP-Handshake , sodass zwischen dem Browser-Client und dem WebSocket-Server ein schneller HTTP-Kanal für lange Verbindungen gebildet wird. Durch die anschließende direkte Datenübertragung zwischen beiden entfällt die Notwendigkeit, eine Verbindung aufzubauen und zu antworten.

Das Folgende ist eine kurze Beschreibung der WebSocket-Server-API und der Client-API. WebSocket-Server-API .WebSocket-Serverunterstützung

Hersteller	Anwendungsserver	Bemerkungen
IBM	WebSphere	WebSphere 8.0 oder höher wird unterstützt, und frühere Versionen 7.X in Kombination mit MQTT unterstützen ähnliche lange HTTP-Verbindungen
Orakel	WebLogic	WebLogic 12c-Unterstützung, 11g- und 10g-Versionen unterstützen ähnliche lange HTTP-Verbindungen über HTTP Publish
Microsoft	IIS	IIS 7.0+. Unterstützung
Apache	Tomcat	Tomcat 7.0.5+ unterstützt, 7.0.2X und 7.0.3X werden über benutzerdefinierte API unterstützt
	Jetty	Jetty 7.0＋ unterstützt

以下我们使用 Tomcat7.0.5 版本的服务端示例代码说明 WebSocket 服务端的实现：

JSR356 的 WebSocket 规范使用 javax.websocket.*的 API，可以将一个普通 Java 对象（POJO）使用 @ServerEndpoint 注释作为 WebSocket 服务器的端点，代码示例如下：

清单 3.WebSocket 服务端 API 示例

 @ServerEndpoint("/echo")
 public class EchoEndpoint {

 @OnOpen
 public void onOpen(Session session) throws IOException {
 //以下代码省略...
 }
 
 @OnMessage
 public String onMessage(String message) {
 //以下代码省略...
 }

 @Message(maxMessageSize=6)
 public void receiveMessage(String s) {
 //以下代码省略...
 } 

 @OnError
 public void onError(Throwable t) {
 //以下代码省略...
 }
 
 @OnClose
 public void onClose(Session session, CloseReason reason) {
 //以下代码省略...
 } 
 
 }

代码解释：

上文的简洁代码即建立了一个 WebSocket 的服务端，@ServerEndpoint("/echo") 的 annotation 注释端点表示将 WebSocket 服务端运行在 ws://[Server 端 IP 或域名]:[Server 端口]/websockets/echo 的访问端点，客户端浏览器已经可以对 WebSocket 客户端 API 发起 HTTP 长连接了。

使用 ServerEndpoint 注释的类必须有一个公共的无参数构造函数，@onMessage 注解的 Java 方法用于接收传入的 WebSocket 信息，这个信息可以是文本格式，也可以是二进制格式。

OnOpen 在这个端点一个新的连接建立时被调用。参数提供了连接的另一端的更多细节。Session 表明两个 WebSocket 端点对话连接的另一端，可以理解为类似 HTTPSession 的概念。

OnClose 在连接被终止时调用。参数 closeReason 可封装更多细节，如为什么一个 WebSocket 连接关闭。

更高级的定制如 @Message 注释，MaxMessageSize 属性可以被用来定义消息字节最大限制，在示例程序中，如果超过 6 个字节的信息被接收，就报告错误和连接关闭。

注意：早期不同应用服务器支持的 WebSocket 方式不尽相同，即使同一厂商，不同版本也有细微差别，如 Tomcat 服务器 7.0.5 以上的版本都是标准 JSR356 规范实现，而 7.0.2x/7.0.3X 的版本使用自定义 API （WebSocketServlet 和 StreamInbound， 前者是一个容器，用来初始化 WebSocket 环境；后者是用来具体处理 WebSocket 请求和响应，详见案例分析部分），且 Tomcat7.0.3x 与 7.0.2x 的 createWebSocketInbound 方法的定义不同，增加了一个 HttpServletRequest 参数，使得可以从 request 参数中获取更多 WebSocket 客户端的信息，如下代码所示：

清单 4.Tomcat7.0.3X 版本 WebSocket API

public class EchoServlet extends WebSocketServlet {
@Override
protected StreamInbound createWebSocketInbound(String subProtocol,
HttpServletRequest request) {
 //以下代码省略....
return new MessageInbound() {
 //以下代码省略....
}
protected void onBinaryMessage(ByteBuffer buffer)
throws IOException {
 //以下代码省略...
}
protected void onTextMessage(CharBuffer buffer) throws IOException {
 getWsOutbound().writeTextMessage(buffer);
 //以下代码省略...
}
};
}
}

因此选择 WebSocket 的 Server 端重点需要选择其版本，通常情况下，更新的版本对 WebSocket 的支持是标准 JSR 规范 API，但也要考虑开发易用性及老版本程序移植性等方面的问题，如下文所述的客户案例，就是因为客户要求统一应用服务器版本所以使用的 Tomcat 7.0.3X 版本的 WebSocketServlet 实现，而不是 JSR356 的 @ServerEndpoint 注释端点。

WebSocket 客户端 API

对于 WebSocket 客户端，主流的浏览器（包括 PC 和移动终端）现已都支持标准的 HTML5 的 WebSocket API，这意味着客户端的 WebSocket JavaScirpt 脚本具备良好的一致性和跨平台特性，以下列举了常见的浏览器厂商对 WebSocket 的支持情况：

表 2.WebSocket 客户端支持

浏览器	支持情况
Chrome	Chrome version 4+支持
Firefox	Firefox version 5+支持
IE	IE version 10+支持
Safari	IOS 5+支持
Android Brower	Android 4.5+支持

客户端 WebSocket API 基本上已经在各个主流浏览器厂商中实现了统一，因此使用标准 HTML5 定义的 WebSocket 客户端的 JavaScript API 即可，当然也可以使用业界满足 WebSocket 标准规范的开源框架，如 Socket.io。

以下以一段代码示例说明 WebSocket 的客户端实现：

清单 5.WebSocket 客户端 API 示例

var ws = new WebSocket(“ws://echo.websocket.org”); 
 ws.onopen = function(){ws.send(“Test!”); }; 
 ws.onmessage = function(evt){console.log(evt.data);ws.close();}; 
 ws.onclose = function(evt){console.log(“WebSocketClosed!”);}; 
 ws.onerror = function(evt){console.log(“WebSocketError!”);};

第一行代码是在申请一个 WebSocket 对象，参数是需要连接的服务器端的地址，同 HTTP 协议开头一样，WebSocket 协议的 URL 使用 ws://开头，另外安全的 WebSocket 协议使用 wss://开头。

第二行到第五行为 WebSocket 对象注册消息的处理函数，WebSocket 对象一共支持四个消息 onopen, onmessage, onclose 和 onerror，有了这 4 个事件，我们就可以很容易很轻松的驾驭 WebSocket。

当 Browser 和 WebSocketServer 连接成功后，会触发 onopen 消息；如果连接失败，发送、接收数据失败或者处理数据出现错误，browser 会触发 onerror 消息；当 Browser 接收到 WebSocketServer 发送过来的数据时，就会触发 onmessage 消息，参数 evt 中包含 Server 传输过来的数据；当 Browser 接收到 WebSocketServer 端发送的关闭连接请求时，就会触发 onclose 消息。我们可以看出所有的操作都是采用异步回调的方式触发，这样不会阻塞 UI，可以获得更快的响应时间，更好的用户体验。

想要查阅更多相关文章，请访问PHP中文网！！

Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen WebSocket und Socket?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!