streamalism.org

1. Áttekintés

Ebben a cikkben egy gyors példát fogunk készíteni az új Spring 5 WebSockets API és a Spring WebFlux által nyújtott reaktív funkciók felhasználásával.

A WebSocket egy jól ismert protokoll, amely lehetővé teszi a teljes duplex kommunikációt az ügyfél és a szerver között, általában olyan webes alkalmazásokban használják, ahol az ügyfélnek és a szervernek nagy gyakorisággal és alacsony késéssel kell kicserélnie az eseményeket.

A Spring Framework 5 korszerűsítette a WebSockets támogatást a keretben, reaktív képességekkel egészítve ki ezt a kommunikációs csatornát.

A Spring WebFlux-ról itt talál további információt.

2. Maven-függőségek

A tavaszi-indító-indítók függőségeket fogjuk használni a rugó-indítás-integráció és a rugó-indítás-indító-webflux használatához, amelyek jelenleg a Spring Milestone Repository-ban érhetők el.

Ebben a példában a legfrissebb elérhető verziót, a 2.0.0.M7-et használjuk, de mindig meg kell szereznünk a Maven tárházban elérhető legfrissebb verziót:

 org.springframework.boot spring-boot-starter-integráció org.springframework.boot spring-boot-starter-webflux 

3. A WebSocket beállítása tavasszal

Konfigurációnk elég egyszerű: beadjuk a WebSocketHandler hogy kezelje a socket munkamenetet a Tavaszi WebSocket alkalmazásban.

@Autowired private WebSocketHandler webSocketHandler; 

Hozzunk létre továbbá egy HandlerMapping bab-annotált módszer, amely felelős lesz a lekérdezések és a kezelő objektumok leképezéséért:

@Bean public HandlerMapping webSocketHandlerMapping () {Map map = new HashMap (); map.put ("/ event-emitter", webSocketHandler); SimpleUrlHandlerMapping handlerMapping = új SimpleUrlHandlerMapping (); handlerMapping.setOrder (1); handlerMapping.setUrlMap (térkép); return handlerMapping; }

Az az URL, amelyhez kapcsolódhatunk, a következő lesz: ws: // localhost: / event-emitter.

4. WebSocket üzenetkezelés tavasszal

A mi ReactiveWebSocketHandler osztály felelős lesz a WebSocket munkamenet szerver oldali kezeléséért.

Megvalósítja a WebSocketHandler felületet, így felülírhatjuk a fogantyú módszer, amellyel az üzenetet elküldik a WebSocket kliensnek:

A @Component public class ReactiveWebSocketHandler a WebSocketHandler {// privát mezőket valósítja meg ... (WebSocketMessage :: getPayloadAsText) .log ()); }}

5. Egyszerű reaktív WebSocket kliens létrehozása

Hozzunk létre most egy Spring Reactive WebSocket klienst, amely képes csatlakozni és információt cserélni a WebSocket szerverünkkel.

5.1. Maven-függőség

Először a Maven-függőségek.

 org.springframework.boot spring-boot-starter-webflux 

Itt ugyanazt a spring-boot-starter-webflux-ot használjuk, mint korábban a reaktív WebSocket kiszolgáló alkalmazásunk beállításához.

5.2. WebSocket kliens

Most hozzuk létre a ReactiveClientWebSocket osztály, felelős a szerverrel való kommunikáció megkezdéséért:

public class ReactiveJavaClientWebSocket {public static void main (String [] args) dobja az InterruptedException {WebSocketClient kliens = új ReactorNettyWebSocketClient (); client.execute (URI.create ("ws: // localhost: 8080 / event-emitter"), session -> session.send (Mono.just (session.textMessage ("event-spring-reactive-client-websocket") )) .thenMany (session.receive () .map (WebSocketMessage :: getPayloadAsText) .log ()) .then ()) .block (Duration.ofSeconds (10L)); }}

A fenti kódban láthatjuk, hogy a ReactorNettyWebSocketClient, ami a WebSocketClient megvalósítás a Netty reaktorral való használatra.

Ezenkívül az ügyfél az URL-en keresztül csatlakozik a WebSocket szerverhez ws: // localhost: 8080 / event-emitter, munkamenet létrehozása, amint csatlakozik a szerverhez.

Azt is láthatjuk, hogy üzenetet küldünk a szervernek („event-tavasz-reaktív-kliens-websocket“) A csatlakozási kérelemmel együtt.

Továbbá a módszer Küld hívásra kerül, paraméterként egy típusú változót vár Kiadó, amely esetünkben a mi Kiadó van Monó és T egy egyszerű karakterláncevent-me-from-reaktív-java-client-websocket“.

Sőt, a akkorSok (…) módszer elvárás a Fényáram típusú Húr hivatkozik. A kap() A metódus bejövő üzenetek fluxusát kapja, amelyeket később stringekké alakítanak át.

Végül a Blokk() A módszer arra kényszeríti az ügyfelet, hogy a megadott idő után (példánkban 10 másodperc) leváljon a szerverről.

5.3. Az ügyfél elindítása

A futtatásához ellenőrizze, hogy a Reactive WebSocket Server fut-e. Ezután indítsa el a ReactiveJavaClientWebSocket osztályban, és láthatjuk a sysout naplózza a kibocsátott eseményeket:

[reaktor-http-nio-4] INFO reaktor.Flux.Map.1 - onNext ({"eventId": "6042b94f-fd02-47a1-911d-dacf97f12ba6", "eventDt": "2018-01-11T23: 29: 26.900 "})

A Reactive WebSocket kiszolgálónk naplójában láthatjuk azt az üzenetet is, amelyet az ügyfél küldött a csatlakozási kísérlet során:

[reaktor-http-nio-2] reaktor.Flux.Map.1: onNext (event-me-from-reaktív-java-kliens)

Láthatjuk a megszakadt kapcsolat üzenetét is, miután az ügyfél befejezte a kéréseit (esetünkben a 10 másodperc után):

[reaktor-http-nio-2] reaktor.Flux.Map.1: onComplete ()

6. Böngésző WebSocket kliens létrehozása

Hozzunk létre egy egyszerű HTML / Javascript kliens WebSocket-et a reaktív WebSocket szerver alkalmazásunk felhasználásához.

 var clientWebSocket = new WebSocket ("ws: // localhost: 8080 / event-emitter"); clientWebSocket.onopen = function () {console.log ("clientWebSocket.onopen", clientWebSocket); console.log ("clientWebSocket.readyState", "websocketstatus"); clientWebSocket.send ("event-me-from-browser"); } clientWebSocket.onclose = function (error) {console.log ("clientWebSocket.onclose", clientWebSocket, hiba); események ("Bezárás"); } clientWebSocket.onerror = function (error) {console.log ("clientWebSocket.onerror", clientWebSocket, hiba); események ("Hiba történt"); } clientWebSocket.onmessage = function (error) {console.log ("clientWebSocket.onmessage", clientWebSocket, hiba); események (hiba.adatok); } function events (responseEvent) {document.querySelector (". events"). internalHTML + = responseEvent + "
"; }  

Ha fut a WebSocket szerver, és megnyitja ezt a HTML fájlt egy böngészőben (pl .: Chrome, Internet Explorer, Mozilla Firefox stb.), Látnunk kell a képernyőn kinyomtatott eseményeket, eseményenként 1 másodperces késleltetéssel, a a WebSocket szerver.

{"eventId": "c25975de-6775-4b0b-b974-b396847878e6", "eventDt": "2018-01-11T23: 56: 09.780"} {"eventId": "ac74170b-1f71-49d3-8737-b3f9a8a352f9", "eventDt": "2018-01-11T23: 56: 09.781"} {"eventId": "40d8f305-f252-4c14-86d7-ed134d3e10c6", "eventDt": "2018-01-11T23: 56: 09.782"}

7. Következtetés

Itt bemutattunk egy példát arra, hogyan lehet WebSocket kommunikációt létrehozni a szerver és az ügyfél között az Spring 5 Framework használatával, a Spring Webflux által biztosított új reaktív szolgáltatások megvalósításával.

Mint mindig, a teljes példa megtalálható a GitHub adattárunkban.