Beispiel für Spring Integrated WebSocket -Anwendung (Teil 1)

Das folgende Tutorial ist ein CRM -System des Unternehmens, an dem ich an der Entwicklung eines Unternehmens teilgenommen habe und einige relevante Informationen erstellt hat. Es gibt viele Nachrichten -Push -Funktionen im System, und die WebSocket -Technologie wird darin verwendet. Der folgende Editor hat es für Ihre Referenz zusammengestellt und geteilt auf der Wulin Network -Plattform

1. MAVEN -Abhängigkeit

 <Depepentcy> <gruppe> javax.servlet </GroupId> <artifactId> javax.servlet-api </artifactId> <version> 3.1.0 </Version> </abhängig> <Depopenty> <gruppe> com.fasterxml.jackson.core </gruppe <artifactid> mackson-core </artifactid> </gruppen> <artifactid> mackson-core </artifactid> 0 </version> </abhängig> <depeopcy> <gruppe> com.fasterxml.jackson.core </GroupId> <artifactId> Jackson-Core </artifactid> <version> 2.3.0 </Version> </abhängig> </gruppId> com.fasterxml.jackson -Databind </artifactId> <version> 2.3.0 </Version> </abhängig> <abhängigkeit> <GroupId> org.springFramework </gruppId> <artifactId> Spring-Websocket </artifactid> <version> 4.0.1. Release </Version> </abhängig> <abhängigkeit> <GroupID> org.springFramework </gruppacid> <artifactId> Spring-Messaging </artifactid> <version> 4.0.1.Release </Version> </abhängig>

2. Konfiguration der Spring-Service

 <xml Version = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: context = "http://www.springframework.org/schema/cont ext "xmlns: mvc =" http://www.springframework.org/schema/mvc "xmlns: tx =" http://www.springframework.org/schema/tx " xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: webocket = "http://www.springframework.org/schema/websocket" xsi: Schemalocation = "http: //wwwwwwwwwwww .springFramework.org/schema/beanshttp: //www.springframework.org/schema/beans/spring-beans-3.xsdhttp: //www.springframework.org/schema/context/spring -Context-3.1.xsdhttp: //www.springframework.org/schema/mvchttp: //www.springframework.o RG/SCHEMA/MVC/SPRING-MVC-3.1.xsdhttp: //www.springframework.org/schema/txhttp: //www.spr ingframework.org/schema/tx/spring-tx-3.1.xsdhttp://www.springframework.org/schema/websockettttp://www.springFramework.org/schema/websocket/Spring-www.springFrameworks id = "webSocket"/> <webSocket: Handler> <WEBORSCOLT: maping path = "/webocket" Handler = "WebSocket"/> <WEBLOCKET: Handshake-Interceptors> <Bean/> <WenSocket: Handshake-Interceptors> </webSocket: Handlers> </beans>

Unter ihnen ist der Pfad, der dem Pfad entspricht, der Grenzflächenpfad, der im vorherigen Abschnitt durch das WS -Protokoll eingestellt wurde.

3. Implementierung von HandshakeInterceptor

 Paket cn.bridgeli.websocket; import cn.bridgeli.utils.usermanager; importieren cn.bridgeli.util.dateutil; org.slf4j.loggerfactory; import org.springframework org.springframework.web.context.request.servletRequestattributes; Import org.springFramework.web.Socket.WebsocketHandher; java.util.Map;/*** @Description :Create a handshake interface* @Date: 16-3-3*/public class HandshakeInterceptor extends HttpSessionHandshakeInterceptor{private static final Logger logger = LoggerFactory.getLogger(HandshakeInterceptor.class);@Overridepublic boolean beforeHandshake(ServerHttpRequest Request, ServerhttPesponse -Antwort, WebSockeThandler WsHandler, Karte <String, Objekt> Attribute) löst Ausnahme aus {logger.info ("Bevor er erstellen ..."); ServletRequestAttributes attrs = (ServletRequestattributes) RequestContexXTholder.getrequestatTributes (); UserManager.GetSessionUser (attr.getRequest ()); userocketvo userSocketvo = new userocketvo (); String mail = ""; if (null! Date ());} userocketvo.setUseremail (E -Mail); Attribute.put ("Session_user", userocketvo); return super.beeHandshake (Anfrage, Antwort, Wshandler, Attribute);}@oversidePublic void Afterhandshake (serverhttprequest request, serverhttPesponse -Antwort, WebSockeThandler WSHandler, Ausnahme ex) {logger.info ("Nach dem Erstellen von Handshake ...").

Weil ich nicht sehr gut verstehe, halte ich den ursprünglichen Code in maximalem Maße. Dies soll den aktuellen Login-Benutzer von einzelnen Anmeldungen herausnehmen, ihn in ein UserSocketvo-Objekt umwandeln und in die Karte einfügen. Schauen wir uns also die Definition des UserSocketvo -Objekts an

4. Definition von UserSocketvo

 Paket cn.bridgeli.websocket; import org.springframework.web.socket.websocketSession; Import Java.util.date;/*** @Description: Benutzer-Socket-Verbindungsentität*@date: 16-3-7*/öffentliche Klasse userocketvo {private String useremail; // Benutzer -E -Mail private Datumsverbindungszeit; // erfolgreiche Verbindungszeit Private Datum Voraussetzung; // Letzte Antragszeit Private Datum NewRequestTime; // Neues Anfragezeitpunkt privates Datum lastsendTime = neuer Datum (); // die letzte Sendungszeit der Entfernung Meldung privates Datum lastTasksendTime = new Datum (); // die letzte Sendezeit der anstehenden Aufgabe private WebSocketSession WebSocketSession; // Die WSSession, die dem Benutzer entspricht

Das Wichtigste ist die WebSocketSession -Eigenschaft, die wir später verwenden werden

5. Implementierung von WebSocketendpoint

 Paket cn.bridgeli.websocket; import org.slf4j.logger; import org.slf4j.loggerfactory; import org.springframework.bean.factory.Annotation org.springframework.web.socket.textMessage; import org.springframework.web.socket.WebsocketSession; TextWebsockethandler {private statische logger logger logger = loggerfactory.getLogger (WebSocketendPoint.Class);@autowiredPrivate NewsListenerImpl NewsListener; @OverrideProtected void HandletExtMessage (WebsocketSession Session, TextMessage). TextMessage (message.getPayload ()+"auf Server empfangen"); Session (UserSocketvo) Session.getAttributes (). Get ("session_user"); if (null! if (wsSessionLocalcache.exists (usersocketvo.getUseremail ()) {WSSessionLocalCache.remove (UserSocketvo.getUseremail ()); userocketvo); NewsListener.afterConnectionESTABLEDS (userocketvo.getUseremail ());} logger.info ("Socket erfolgreich etablierte Verbindung ..."); super.afterConnectionESTABLEDS (Session);}@overidepublic void AfterConnectionCloded (WebSocketSSession -Session -Session -Session -Session -Session -Session -Session -Session) Throws -Ausnahme {{{{WebSocketSSession -Session, Cessel. (Userocketvo) session.getAttributes (). Get ("session_user"); if (null!

6. Implementierung von WSSessionLocalcache

 Paket Cn.Bridgeli.Websocket; Import Java.io.Serializable; Import Java.util.ArrayList; Import Java.util.hashMap; Serialisierbar {private statische Karte <String, userSocketvo> wsSessioncache = new HashMap <> (); public static boolean exists (String useremail) {if (! UserSocketVo){wsSessionCache.put(userEmail, UserSocketVo);}public static UserSocketVo get(String userEmail){return wsSessionCache.get(userEmail);}public static void remove(String userEmail){wsSessionCache.remove(userEmail);}public static List<UserSocketVo> getAllSessions(){return new ArrayList <> (WssSessioncache.Values ​​());}}

Nach der Betrachtung seiner Implementierung ist der Effekt offensichtlicher. Es speichert die neuesten Daten jeder BenutzerSocketvo. Tatsächlich wurde unsere Websocket -Implementierung hier berechnet, aber es gibt immer noch eine Kernklasse (Charlies Klasse über Geschäftslogik), die nicht implementiert wurde. Im nächsten Artikel, Beispiel für Spring Integrated WebSocket Application (Teil 2), werden wir sehen, wie diese Klasse implementiert wird.

Einführung in das Websocket -Protokoll

Das WebSocket-Protokoll ist eine wichtige Funktion im Webfeld, das durch die RFC-6455-Spezifikation definiert ist: Voller Duplex, dh eine wechselseitige Kommunikation zwischen dem Client und dem Server. Es ist ein aufregendes Feature. Die Branche erforscht dieses Feld schon lange. Zu den verwendeten Technologien gehören Java Applet, XMLHTTPrequest, Adobe Flash, ActiveXObject, verschiedene Comet-Technologien, serverseitige Senden von Ereignissen usw.

Es ist zu verstehen, dass Sie vor der Verwendung des WebSocket -Protokolls das HTTP -Protokoll verwenden müssen, um den anfänglichen Handshake zu erstellen. Dies stützt sich auf einen Mechanismus, der HTTP erstellt und Protokoll -Upgrades (oder Protokollkonvertierungen) anfordern. Wenn der Server zustimmt, reagiert er auf den HTTP -Statuscode 101, was darauf hinweist, dass er das Protokoll wechselt. Unter der Annahme, dass ein erfolgreicher Handschlag über TCP -Sockets und die HTTP -Protokoll -Upgrade -Anforderung übergeben wird, kann sowohl der Client als auch der Server Nachrichten aneinander senden.

Feder Framework 4.0 und höher führte ein neues Modul vor, nämlich das Feder-Websocket-Modul. Es bietet Unterstützung für die Websocket -Kommunikation. Es ist mit der Java WebSocket-API-Spezifikation JSR-356 kompatibel und bietet gleichzeitig zusätzliche Funktionen.

In welchem ​​Szenario sollten Sie WebSocket verwenden

In Webanwendungen ist der Client und der Server Ereignisse mit höherer Häufigkeit und niedrigerer Latenz für WebSocket geeignet. Daher eignet sich WebSocket für Anwendungsszenarien wie Finanzen, Spiele und Zusammenarbeit.
Es ist möglicherweise nicht für andere Anwendungsszenarien geeignet. Beispielsweise erfordert ein Nachrichtenabonnement die Ausstellung von Nachrichten, und es ist auch in Ordnung, eine lange Wahl von mehreren Minuten voneinander entfernt zu verwenden, und die Verzögerung hier ist akzeptabel.
Selbst in Anwendungen, bei denen eine geringe Latenz erforderlich ist, sollte die Anzahl der übertragenen Nachrichten sehr gering ist (z.

Nur in Szenarien mit geringer Latenz- und Hochfrequenznachrichtenkommunikation ist die Auswahl des WebSocket -Protokolls sehr geeignet. Ist es auch in einem solchen Anwendungsszenario immer noch möglich, WebSocket -Kommunikation zu wählen? Oder wählen Sie REST HTTP -Kommunikation?
Die Antwort ist, dass es von den Anforderungen der Anwendung abhängt. Es ist jedoch auch möglich, diese beiden Technologien gleichzeitig zu verwenden, um Daten zu setzen, die häufig in WebSocket ausgetauscht werden müssen, und die REST-API als prozessbasierte Geschäftsinformationstechnologie zu verwenden. Wenn eine bestimmte Informationen im REST -API -Anruf an mehrere Clients übertragen werden müssen, kann sie auch über WebSocket -Verbindung implementiert werden.

Das Spring Framework bietet @Controller Annotation und @RestController Annotation, die beide für die Verarbeitung von HTTP -Anforderungen und die Verarbeitung von WebSocket -Nachrichten verwendet werden können. Darüber hinaus können Spring MVC -Anforderungsverarbeitungsmethoden oder andere Verarbeitungsmethoden für Anwendungsanforderungen das WebSocket -Protokoll problemlos an alle interessierten Clients oder benannten Benutzer verwenden.