वसंत के साथ वेब कोडिंग

मैं तुरंत कहूंगा कि इस तरह की बातचीत का एक मानक कार्यान्वयन मौजूद है ।



हालाँकि, चूंकि यह लेख "एकल-पृष्ठ अनुप्रयोगों में दूरस्थ सेवा विधियों की सरल कॉलिंग" विषय की एक निरंतरता है, इसलिए उपरोक्त विषय में वर्णित (jrspc) दृष्टिकोण के संदर्भ में वेब सॉकेट के साथ ajax को बदलने के लिए एक वैकल्पिक इंटरैक्शन स्कीम की आवश्यकता है।



पहले लेख में, अजाक्स का उपयोग करके सेवा विधियों को कॉल करने के लिए एक तंत्र का वर्णन किया गया था।



यह आलेख वर्णन करता है कि अनुप्रयोग के व्यावसायिक तर्क कोड को बदलने के बिना वेब सॉकेट के साथ AJAX को बदलने के साथ इस तंत्र को कैसे लागू किया जाए।



ऐसा प्रतिस्थापन एक तेज़ कनेक्शन देता है (अंत में परीक्षण), सर्वर मेमोरी को बचाता है, और सर्वर से क्लाइंट विधियों को कॉल करने की क्षमता जोड़ता है।



प्रदर्शित करने के लिए, एक छोटा सा चैट एप्लिकेशन लिखा गया था, जिठुब पर स्रोत कोड के साथ।

जिसका एक उदाहरण का उपयोग करते हुए, मैं यह समझाने की कोशिश करूंगा कि इस इंटरैक्शन के क्लाइंट और सर्वर भागों को कैसे लागू किया जाता है।

आवेदन टॉमकैट 7.042 सर्वर पर चलता है।

Https और wss (प्रमाणपत्र की पुष्टि नहीं) का समर्थन करता है, और सर्वर पर लॉग को बनाए नहीं रखता है।

सर्वर साइड

स्प्रिंग एप्लिकेशन के साथ वेब-सॉकेट इंटरैक्शन के संगठन के दौरान उत्पन्न होने वाला मुख्य प्रश्न यह सवाल था - यह कैसे सुनिश्चित करें कि स्प्रिंग घटकों को अपने दृश्य क्षेत्रों से कहा जाता है जो कि WebInocketServlet वर्ग की createWebSocketSbound विधि द्वारा दिए गए स्ट्रीमइनबाउंड ऑब्जेक्ट से HTTP सत्र से जुड़े होते हैं जो सत्र से जुड़ा नहीं है?



सर्वर घटकों के कॉलिंग के तरीकों के लिए आवश्यक कार्यक्षमता प्रदान करने के लिए, हमें किसी तरह से स्ट्रीमइनबाउंड वंश से काम करने वाले ApplicationContext तक पहुंचने की आवश्यकता है।



यदि हम ApplicationContext को अधिकृत करने का प्रयास करते हैं ताकि हम उन घटकों को प्राप्त कर सकें जिनकी हमें WebSocketServlet या StreamInbound उत्तराधिकारी में आवश्यकता है, तो हमें निराशा होगी, क्योंकि यह आरंभिक नहीं होगा, जो कि पूरी तरह से कानूनी है।



वेब सॉकेट हैंडलर से http सत्र के साथ जुड़े स्प्रिंग संदर्भों से घटकों को एक्सेस करने के लिए, हमें एक ऑब्जेक्ट बनाने की आवश्यकता है जो एक सत्र स्प्रिंग बीन होगा, और जिसे स्टोरेज क्लास के एक स्थिर ऑब्जेक्ट में संग्रहीत किया जाएगा, जिसके पास यह एक्सेस था स्ट्रीमइनबाउंड का वारिस होगा।



यह सत्र ऑब्जेक्ट (इसे ग्राहक प्रबंधक कहते हैं) एक http कनेक्शन स्थापित करने की प्रक्रिया के दौरान बनाया गया है।



तदनुसार, क्लाइंट, वेब सॉकेट के माध्यम से सर्वर के साथ बातचीत शुरू करने से पहले, एक http हैंडशेक-अनुरोध करना होगा, जिसके परिणामस्वरूप, उसे अपने क्लाइंट मैनेजर की आईडी प्राप्त करनी होगी।



इस अनुरोध का परिणाम क्लाइंट कोड को दो तरीकों से हस्तांतरित किया जा सकता है - क्लाइंटमैनेजर आईड को जनरेट किए गए पेज में, या ऐजैक्स रिक्वेस्ट के माध्यम से, स्टैटिक पेज से (यहाँ - ऐजैक्स के माध्यम से विकल्प लागू किया जाता है)।



यह अनुरोध सत्र नियंत्रक के initializeClientManager विधि में संसाधित किया गया है:

@Controller @Scope("session") public class ClientManagerController { @Autowired private ClientManager clientManager; @RequestMapping(value = "/init", method = RequestMethod.POST) @ResponseBody private String initializeClientManager(HttpSession session) { JSONObject result = new JSONObject(); try{ boolean loged = ClientManagersStorage.checkClientManager(clientManager, session) ; result.put("loged", loged); result.put("clientManagerId", clientManager.getId()); }catch(Throwable th){ result.put("error", th.toString()); } return result.toString(); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ClientManagersStorage हमारे सत्र क्लाइंट प्रबंधकों का भंडार है, जिसमें शून्य के लिए प्रबंधक की जाँच करने, नया बनाने, रिपॉजिटरी में जोड़ने, खोज करने और हटाने के लिए विधियाँ हैं।

 public class ClientManagersStorage { final static private Map<String, ClientManager> clientManagers = new ConcurrentHashMap <String, ClientManager>(); public static boolean checkClientManager(ClientManager clientManager, HttpSession session) { ClientManager registeredClientManager = clientManagers.get(clientManager.getId()); if (registeredClientManager == null) { clientManager.setSession(session); addClientManager(clientManager); registeredClientManager = clientManager; } return registeredClientManager.getUser() != null; } ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

(सत्र जीवनचक्र प्रबंधन पर थोड़ा नीचे चर्चा की जाएगी)



जैसा कि आप देख सकते हैं, प्रबंधकों को एक स्थिर मानचित्र में संग्रहीत किया जाता है, कुंजी उनके हैशकोड के साथ होती है, और जब उपयोगकर्ता पृष्ठ को फिर से लोड करता है, तो उसी प्रबंधक को उसे सौंपा जाता है।



इस प्रबंधक की आईडी क्लाइंट को क्लाइंट क्लाइंट पेज पर प्रतिक्रिया के चर में दी जाती है।



क्लाइंट द्वारा अपने प्रबंधक की आईडी प्राप्त करने के बाद, वह कनेक्शन स्थापित करने के अनुरोध के एकमात्र पैरामीटर में अपने क्लाइंटमैनग्रैड को पास करके एक वेब सॉकेट कनेक्शन खोल सकता है।



इस कनेक्शन को खोलने का अनुरोध WebSocketConnectorServlet वर्ग के अमूर्त WebSocketServlet के कार्यान्वयन की CreateWebSocketInbound विधि में संसाधित किया गया है।

 @Override protected StreamInbound createWebSocketInbound(String paramString, HttpServletRequest request) { String clientManagerId = request.getParameter("clientManagerId"); ClientManager clientManager = ClientManagersStorage.findClientManager(clientManagerId); if(clientManager == null){ return new WebSocketConnection(null); } log.debug("new connection"); return new WebSocketConnection(clientManager); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसमें, clientManagerId अनुरोध से लिया गया है, उस पर ClientManager पाया जाता है, और WebSocketConnection ऑब्जेक्ट (जो StreamInbound है) बनाया जाता है, जिसके लिए ClientManager बाध्य है।



चूंकि ClientManager एक सत्र एक है, और इसे एक "सामान्य" http अनुरोध में बनाया गया था, सभी स्प्रिंग बीन्स इसमें से अप्लीकेशन कॉन्टेक्स्ट ऑटो-ट्रस्ट के माध्यम से सुलभ होंगे, जो यहां, सही ढंग से आरंभीकृत किया जाएगा)।



क्लाइंट के साथ एक नया कनेक्शन खोलते समय, WebSocketConnection क्लास की ऑनऑन विधि को कहा जाता है, जिसमें इससे जुड़ा ClientManager ऑब्जेक्ट आईडी (हैकोडकोड) द्वारा अपने कनेक्शन मैप में इस WebSocketConnection को जोड़ता है।

  @Override protected void onOpen(WsOutbound outbound) { if(clientManager != null){ clientManager.addConnection(this); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

(उपयोगकर्ता को कई विंडो में एप्लिकेशन खोलने के लिए कई कनेक्शन के लिए समर्थन आवश्यक है, जिनमें से प्रत्येक अपना वेब सॉकेट कनेक्शन बनाएगा।)



कनेक्शन को खोलने के बाद, क्लाइंट सर्वर विधियों पर कॉल के लिए अनुरोध भेज सकता है जो कि वेबसॉफ्टकॉन्नेक्शन वर्ग के ओवररेटेड ऑनमेस्टेज विधि में संसाधित किया जाएगा।

  @Override protected void onTextMessage(CharBuffer message) throws IOException { try { String connectionId = String.valueOf(this.hashCode()); String request = message.toString(); clientManager.handleClientRequest(request, connectionId); } catch (Throwable th) { log.error("in onTextMessage: " + th); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हैंडल क्लाइंट क्लाइंट क्लास की विधि - अनुरोध को संसाधित करता है और कनेक्शन के लिए परिणाम लिखता है:

 @Autowired private RequestHandler requestHandler; public void handleClientRequest(String request, String connectionId) { log.debug("handleClientRequest request=" + request); log.debug("handleClientRequest user=" + getUser()); /** handleRequest - never throws exceptions ! */ JSONObject response = requestHandler.handleRequest(request, this); String responseJson = response.toString(); CharBuffer buffer = CharBuffer.wrap(responseJson); WebSocketConnection connection = connections.get(connectionId); try { connection.getWsOutbound().writeTextMessage(buffer); } catch (IOException ioe) { log.error("in handleClientRequest: in writeTextMessage: " + ioe); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अनुरोधहैंडलर एक ऑटो-विश्वसनीय घटक है जो प्रसंस्करण अनुरोधों के लिए जिम्मेदार है।

ApllicationContext को इसमें वेल्ड किया गया है, जिसकी मदद से यह सर्विस ऑब्जेक्ट ढूंढता है।



इसका हैंडल रीसेंट मेथड एक सर्विस कंपोनेंट को खोजता है और क्लाइंट को उस पर जरूरत के तरीकों को कॉल करता है, जिस तरह पिछले आर्टिकल से कॉमनसेव कॉन्सट्रॉलर क्लास से प्रोसेसएजैक्स रीपेस्ट विधि।





यह बातचीत की सामान्य योजना है।



अब जब ग्राहक प्रबंधक एक http सत्र के साथ आरंभीकृत होता है, उस पर करीब से नज़र डालते हैं।



एक सत्र में टाइमआउट से गिरने की संपत्ति है, जो डिफ़ॉल्ट रूप से 30 मिनट है।

इससे बचने के लिए, हम इसके मान को अधिकतम पर सेट करते हैं, और सत्र को अमान्य करते हैं जब हमें इसकी आवश्यकता होती है - अर्थात्, दो मामलों में: पहला मामला - जब किसी ने आवेदन से नहीं अनुरोध किया, और दूसरा जब क्लाइंट ने एप्लिकेशन पृष्ठ को बंद कर दिया।



पहला मामला प्रारंभिक विधि में सीधे संभाला गया है:

  public class ClientManager{ public void setSession(HttpSession session) { /** session will be invalidated at connection removing */ session.setMaxInactiveInterval(Integer.MAX_VALUE);//69.04204112011317 years this.session = session; new Thread(new Runnable() { @Override public void run() { /** Giving time to client, for establish websocket connection. */ try {Thread.sleep(60000);} catch (InterruptedException ignored) {} /** if client not connected via websocket until this time - it is bot */ if (connections.size() == 0) {removeMe();} } }).start(); } private void removeMe() {ClientManagersStorage.removeClientManager(this);} ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और WebSocketConnection वर्ग के ऑनक्लो विधि में दूसरा:

 public class WebSocketConnection{ @Override protected void onClose(int status) { if(clientManager != null){ clientManager.removeConnection(this); } } ... } public class ClientManager{ public void removeConnection(WebSocketConnection webSocketConnection) { String connectionId = getObjectHash(webSocketConnection); connections.remove(connectionId); if (connections.size() == 0) { log.debug("removeConnection before wait: connections.size()=" + connections.size()); /** may be client just reload page? */ try {Thread.sleep(waitForReloadTime);} catch (Throwable ignored) {} if (connections.size() == 0) { /** no, client leave us (page closed in browser)*/ ClientManagersStorage.removeClientManager(this); log.debug("client " + getId() + " disconnected"); } } } ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सत्र ClientManagersStorage वर्ग के removeClientManager विधि में अक्षम है:

 public static void removeClientManager(ClientManager clientManager) { ClientManager removed = clientManagers.remove(clientManager.getId()); if(removed == null){return;} User user = removed.getUser(); if(user != null){ Broadcaster.broadcastCommand("userPanel.setLogedCount", UserService.logedCount.decrementAndGet()); } Broadcaster.broadcastCommand("userPanel.setOnlineCount", ClientManagersStorage.getClientManagersCount()); try { clientManager.getSession().invalidate(); clientManager.setSession(null); } catch (Throwable th) { log.error("at removeClientManager: " + th); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उसी पद्धति का उपयोग करते हुए, उपयोगकर्ताओं को सूचित किया जाता है कि पेज विज़िटर की संख्या बदल गई है (क्लाइंट पर इन सूचनाओं का प्रसंस्करण नीचे वर्णित है)।



सर्वर पर होने वाली घटनाओं के बारे में उपयोगकर्ताओं को सूचित करने के लिए, ब्रॉडकास्टर क्लास का उपयोग किया जाता है, जिसमें दो विधियाँ हैं: ब्रॉडकास्टमांड और सेंडकमांडटाउज़र:

 public class Broadcaster{ public static void broadcastCommand(String method, Object params) { for (ClientManager clientManager : ClientManagersStorage.getClientManagers().values()) { clientManager.sendCommandToClient(method, params); } } public static void sendCommandToUser(Long userId, String method, Object params) { List<ClientManager> userClientManagers = ClientManagersStorage.findUserClientManagers(userId); for(ClientManager clientManager: userClientManagers){ clientManager.sendCommandToClient(method, params); } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ग्राहक प्रबंधक वर्ग का SendCommandToClient विधि इस तरह काम करती है:

 public void sendCommandToClient(String method, Object params) { for(WebSocketConnection connection: connections.values()){ sendCommandToClientConnection(connection, method, params); } } private void sendCommandToClientConnection(WebSocketConnection connection, String method, Object params) { JSONObject commandBody = new JSONObject(); if(params == null){params = new JSONObject();} commandBody.put("method", method); commandBody.put("params", params); CharBuffer buffer = CharBuffer.wrap(commandBody.toString()); try { connection.getWsOutbound().writeTextMessage(buffer); } catch (IOException ioe) { log.error("in sendCommandToClient: in writeTextMessage: " + ioe); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस पर, हम सर्वर भाग के साथ समाप्त हो जाएंगे, और क्लाइंट भाग पर आगे बढ़ेंगे।

ग्राहक भाग

ग्राहक भाग को तीन कार्यक्षमताओं को लागू करना चाहिए:



पहले ajax पर एक हैंडशेक है, सत्र क्लाइंटमैनेगर को इनिशियलाइज़ करने के लिए, दूसरा एक वेब सॉकेट ट्रांसपोर्ट है, jsrpc रिक्वेस्ट भेजने और उनके उत्तर प्राप्त करने के लिए, और तीसरा सर्वर से क्लाइंट पर फ़ंक्शंस की कॉल है।



पहला भाग सबसे सरल है:



चूँकि हम Angular का उपयोग कर रहे हैं, $ http का उपयोग ajax अनुरोध को प्रारंभ करने के लिए किया जाता है http सत्र:

  var appName = "jrspc-ws"; var secured = document.location.protocol == "https:" ? "s" : ""; var HttpSessionInitializer = {url: "http"+secured+"://"+ document.location.host +"/"+appName+"/init"}; /** called from root-controller.js after its initialization */ HttpSessionInitializer.init = function($http) { $http.post(this.url, "").success(function(response){ if (response.error) { error(response.error); } else { loged = response.loged; Server.initialize("ws"+secured+"://"+ document.location.host +"/"+appName+"/ws?clientManagerId="+response.clientManagerId); if(loged){Listeners.notify("onLogin");} } }).error(function() {error("network error!");}); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सर्वर पर, यह अनुरोध ClientManagerController वर्ग के initializeClientManager विधि में संसाधित किया जाता है, जिसके कोड को सर्वर भाग के विवरण में ऊपर दिया गया है।



सॉकेट कनेक्शन को आरंभ किया जाता है Server.initialize फ़ंक्शन में:

  connector.initialize = function(url) { connector.url = url; try { connector.connect(url); return true; } catch (ex) { p("in connector.initialize: " + ex); return false; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कनेक्टर - आंतरिक सर्वर ऑब्जेक्ट जो वेब सॉकेट कनेक्शन के लिए जिम्मेदार है (इसका पूरा कोड ws-कनेक्टर . js फ़ाइल में है)



Ws-कनेक्टर.js से कोड, जो jrspc अनुरोध उत्पन्न करने के लिए जिम्मेदार है:

  Server.socketRequests = {}; var requestId = 0; function sendSocket(service, method, params, successCallback, errorCallback, control) { if (!checkSocket()) {return;} requestId++; if(!params){params = [];} if(!isArray(params)){params = [params];} var data = { service : service, method : method, params : params, requestId : requestId }; Server.socketRequests["request_" + requestId] = { successCallback : successCallback, errorCallback : errorCallback, control : control }; if (control) {control.disabled = true;} var message = JSON.stringify(data); log("sendSocket: "+message); connector.socket.send(message); } ... Server.call = sendSocket;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Ws-कनेक्टर.js से कोड, जो अनुरोधों को संसाधित करने और सर्वर आदेशों को संसाधित करने के लिए जिम्मेदार है:

  connector.socket.onmessage = function(message) { var data = message.data; var response = JSON.parse(data); var requestId = response.requestId; if (requestId) {/** server return response */ var control = Server.socketRequests["request_" + requestId].control; if (control) {control.disabled = false;} if (response.error) { var errorCallback = Server.socketRequests["request_" + requestId].errorCallback; if (errorCallback) { try { errorCallback(response.error); } catch (ex) { error("in connector.socket.onmessage errorCallback: " + ex + ", data=" + data); } }else{ error(response.error); } } else { var successCallback = Server.socketRequests["request_" + requestId].successCallback; if (successCallback) { try { successCallback(response.result); } catch (ex) { error("in connector.socket.onmessage successCallback: " + ex + ", data=" + data); } } } delete Server.socketRequests["request_" + requestId]; } else { /** server call client or broadcast */ var method = eval(response.method); var params = response.params; try { method(params); } catch (ex) { error("in connector.socket.onmessage call method: " + ex + ", data=" + data); } } };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उपरोक्त ढांचे का उपयोग करने से आप सभी व्यावसायिक तर्क को लागू कर सकते हैं जो चैट कार्यक्षमता के लिए जिम्मेदार है - क्लाइंट पर दो कार्यों में ( चैट-कंट्रोलर.जेएस ):

  self.sendMessage = function(command){ var message = {to: (self.sendPrivate ? self.privateTo : "all"), from: userPanel.user.login, text: self.newMessage, clientTime: new Date().getTime()}; Server.call("chatService", "dispatchMessage", message, function(){ self.newMessage = ""; self.$digest(); }, function(error){self.onError(error);}, command); } /** called from server */ self.onChatMessage = function (message){ message.isPrivate = (message.to != "all"); self.messages.push(message); self.$digest(); chatConsole.scrollTop = chatConsole.clientHeight + chatConsole.scrollHeight; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और एक सर्वर विधि:

  @Component public class ChatService extends AbstractService{ @Autowired private UserManager userManager; @Secured("User") @Remote public void dispatchMessage(ChatMessage message){ message.setServerTime(new Date().getTime()); String to = message.getTo(); if("ALL".equalsIgnoreCase(to)){ Broadcaster.broadcastCommand("chatPanel.onChatMessage", message); }else{ User fromUser = getUser(); message.setFrom(fromUser.getLogin()); User toUser = userManager.findByLogin(to); if(toUser == null){throw new RuntimeException("User "+to+" not found!");} Broadcaster.sendCommandToUser(toUser.getId(), "chatPanel.onChatMessage", message); Broadcaster.sendCommandToUser(fromUser.getId(), "chatPanel.onChatMessage", message); } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

गति परीक्षण, धारावाहिक और समानांतर भेजने के साथ 1000 अनुरोध, अजाक्स और वेबस्कैट के लिए:



क्रमिक रूप से: अजाक्स (3474, 3380, 3377) ws (1299, 1113, 1054)

समानांतर: अजाक्स (1502, 1515, 1469) ws (616, 637, 632)







सभी आलोचनाओं और त्रुटियों के संकेत की बहुत सराहना की जाएगी।