WebSocket: जेटी वेब सॉकेट का उपयोग करके एक वेब एप्लिकेशन को लागू करें। भाग 1

शुभ दोपहर, अभिभावक!

प्रोग्रामर के महान दिवस पर सभी को और सभी को बधाई! मैं आपको काम करने वाला कोड, भरोसेमंद सॉकेट और सबसे उन्नत उपयोगकर्ता चाहता हूं!

एक कॉन्सर्ट एजेंसी के स्वचालन पर काम करते हुए, विकास के कुछ चरण में मुझे एक अधिसूचना प्रणाली की आवश्यकता थी। मेरे द्वारा लिखे गए वेब एप्लिकेशन के माध्यम से स्वचालन को एक्सेस किया जाता है। और, तदनुसार, उपयोगकर्ता के ब्राउज़र पर तत्काल सूचनाएं आनी चाहिए।

इस कार्य को कार्यान्वित करने के लिए, तीन समाधान हैं:

• "अंतहीन आइफ्रेम",
• XMLHttpRequest (उर्फ अजाक्स) का उपयोग करते हुए,
• WebSocket का उपयोग करना।

मैं तुरंत पहला समाधान "झाडू" करता हूं (मैं कारणों को नहीं समझाता, वेब डेवलपर्स मुझे समझेंगे)।

दूसरा समाधान अधिक लोकप्रिय है, लेकिन इसकी कमियां हैं:

• ब्राउज़र हर सेकंड एक अनुरोध भेजता है, जिससे एक अतिरिक्त लोड होता है:
  • सर्वर
  • ओएस जिस पर ब्राउज़र काम करता है;
  • और सर्वर पर फिर से, क्योंकि सर्वर लगातार नवीनतम सूचनाओं का चयन करने के लिए डेटाबेस अनुरोध को निष्पादित करता है।
• उपयोगकर्ता की ऑनलाइन स्थिति को ट्रैक करना मुश्किल है (उदाहरण के लिए, आपको डेटाबेस में सत्रों को संग्रहीत करने और समय-समय पर प्रत्येक की निगरानी करने की आवश्यकता है)।

तीसरा समाधान वैसा ही है जैसा डॉक्टर ने आदेश दिया था।

तो, WebSocket।

WebSocket के नुकसान के बीच, केवल यह तथ्य कि अब तक केवल वेबकिट ब्राउज़र ही उनका समर्थन करते हैं (वे Google Chrome और Apple Safari हैं) महत्वपूर्ण हैं।

आइए क्लाइंट और सर्वर के बीच फुल-डुप्लेक्स मैसेजिंग की मूल संभावना के साथ एक वेब एप्लिकेशन के रूप में एक साधारण चैट को लागू करने का प्रयास करें।

ग्राहक पक्ष कार्यान्वयन

क्लाइंट की तरफ जावास्क्रिप्ट पर वेब पॉकेट्स को लागू करना सरल है, हमने इस पर ज्यादा समय नहीं दिया है। हम लिस्टिंग देख रहे हैं।

var socket = new WebSocket("ws://myserver.com:8081/"); socket.onopen = function () { console.log(" "); }; socket.onclose = function () { console.log (" "); }; socket.onmessage = function (event) { console.log ("   :", event.data); }; 

आप सर्वर को भेजें () विधि का उपयोग करके संदेश भेज सकते हैं:
socket.send(messageString);

सर्वर साइड कार्यान्वयन

सर्वर पर समाधान को लागू करना अधिक जटिल दिखता है। नेटवर्क पर आप कई कार्यान्वयन विकल्प पा सकते हैं, जिनमें से मेरे सबसे करीब थे:

• JWebSocket ,
• जेट्टी वेबसोकेट,
• नोड.जेएस वेबस्केट ।

इनमें से, JWebSocket का अर्थ है कि यह WebSocket के साथ काम करने का एक बड़ा ढांचा है, जो एक ही समय में एक विश्वसनीय स्टैंडअलोन सर्वर भी है। JWebSocket को एक अलग पोस्ट की आवश्यकता होती है। और अब हम J2EE: जेट्टी प्लेटफॉर्म पर सबसे सरल समाधान पर ध्यान केंद्रित करेंगे।

हमारे पास क्या है? आइए नज़र डालते हैं आरेख पर।



मेरे मामले में, हमारे पास पोर्ट 8080 पर ग्लासफ़िश सर्वलेट कंटेनर है। ब्राउज़र ग्लासफ़िश [1] के लिए एक अनुरोध भेजता है, जो ब्राउज़र पर एक चैट पेज [2] प्रसारित करता है, जो उपयोगकर्ता के अनुरोध पर वेबसर्केट [3] प्रोटोकॉल के माध्यम से पोर्ट 8081 से सर्वर से जुड़ता है। फिर ब्राउज़र और सर्वर के बीच एक पूर्ण द्वैध डेटा विनिमय होता है [4]।

लेखन के समय, जेट्टी का नवीनतम संस्करण 8.0.1.v20110908 है। डाउनलोड, अनपैक (मैं मावेन का उपयोग करने वाले सभी डेवलपर्स से माफी चाहता हूं), वितरण से हम 6 पुस्तकालयों में रुचि रखते हैं:

• घाट-निरंतरता-8.0.1.v20110908.jar,
• घाट-http-8.0.1.v20110908.jar,
• घाट-कब-8.0.1.v20110908.jar,
• घाट-server-8.0.1.v20110908.jar,
• घाट-util-8.0.1.v20110908.jar,
• घाट-WebSocket-8.0.1.v20110908.jar।

इन पुस्तकालयों को परियोजना में जोड़ें।

क्लाइंट की ओर लौटते हुए, इसे यहाँ से डाउनलोड करें (मैं HTML कोड को सूचीबद्ध करके पोस्ट को अव्यवस्थित नहीं करना चाहता)। प्रोजेक्ट के वेब पेज पर chat.html फ़ाइल जोड़ें। परिनियोजन विवरणक (web.xml) में, "खोज-फाइल" के रूप में chat.html निर्दिष्ट करें।

अब थोड़ा जेट्टी के बारे में।

Jetty एंबेडेड सर्वर क्लास में है। org.eclipse.jetty.server.Server। और कंस्ट्रक्टर में सर्वर का पता या हमारे मामले में पोर्ट नंबर हो सकता है:

Server jetty = new Server(8081);

अगला, हमें आवश्यक हैंडलर को जेटी में जोड़ने और इसे चलाने की आवश्यकता है। जेट्टी क्रमशः प्रारंभ () और स्टॉप () मापदंडों के बिना विधियों के साथ शुरू और बंद हो जाती है। लेकिन हैंडलर हमें अपना लिखने, एक नया वर्ग बनाने की आवश्यकता है। हमारे लिए WebSocket कनेक्शन को संसाधित करने के लिए एक हैंडलर होना चाहिए, हमें इसे org.eclipse.jetty.websocket.WebSocketHandler से इनहेरिट करना होगा:

public class ChatWebSocketHandler extends WebSocketHandler {
…
}
WebSocketHandler वर्ग में एक सार doWebSocketConnect () विधि है। यह वास्तव में, कहा जाता है जब ब्राउज़र जेटी के साथ एक नया कनेक्शन खोलता है, और एक वेबसकेट ऑब्जेक्ट लौटाता है।

हमें अपने WebSocket क्लास को भी परिभाषित करना चाहिए, और हम इसे org.eclipse.jetty.websocket.WebSocket.OnTextMessage इंटरफ़ेस से इनहेरिट करेंगे- यह इंटरफ़ेस वेबसर्केट प्रोटोकॉल से गुजरने वाले डेटा के साथ काम करता है, जैसा कि टेक्स्ट डेटा के साथ होता है। Org.eclipse.jetty.websocket.WebSocket.OnTextMessage इंटरफ़ेस में तीन विधियाँ शामिल हैं:

• onOpen () - एक सॉकेट खोलने के बाद बुलाया;
• onClose () - सॉकेट बंद करने से पहले बुलाया;
• onMessage () - क्लाइंट से एक संदेश आने पर कॉल किया जाता है।

यह सरल लग रहा है! चलो ChatWebSocketHandler लिस्टिंग पर एक नज़र डालें।

 import java.io.IOException; import java.util.Set; import java.util.concurrent.CopyOnWriteArraySet; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.servlet.http.HttpServletRequest; import org.eclipse.jetty.websocket.WebSocket; import org.eclipse.jetty.websocket.WebSocketHandler; public class ChatWebSocketHandler extends WebSocketHandler { /** *    */ private final Set<ChatWebSocket> webSockets = new CopyOnWriteArraySet<ChatWebSocket>(); /** *       * @param request * @param protocol  (   ws  wss) * @return */ @Override public WebSocket doWebSocketConnect(HttpServletRequest request, String protocol) { //      //         // throw new Exception(); //   ,       //      return new ChatWebSocket(); } private class ChatWebSocket implements WebSocket.OnTextMessage { /** *   */ private Connection connection; /** *   */ private String userName = null; /** *     */ private final Pattern authCmdPattern = Pattern.compile("^\\/auth ([\\S]+).*"); /** *       */ private final Pattern getUsersCmdPattern = Pattern.compile("^\\/getUsers.*"); /** *      */ private final Pattern helpCmdPattern = Pattern.compile("^\\/help.*"); /** *      * @param connection */ @Override public void onOpen(Connection connection) { //     ChatWebSocket::connection this.connection = connection; //      ChatWebSocketHandler::webSockets webSockets.add(this); } /** *      * @param data */ @Override public void onMessage(String data) { //       data = data.replaceAll("<", "<").replaceAll(">", ">"); //     if (authCmdPattern.matcher(data).matches()) { Matcher matcher = authCmdPattern.matcher(data); matcher.find(); //     userName = matcher.group(1); try { //      ChatWebSocketHandler::webSockets for (ChatWebSocket webSocket : webSockets) { //   ,     webSocket.connection.sendMessage("inf|" + (webSocket.equals(this) ? "  " : ("   <b>" + userName + "</b>"))); } } catch (IOException x) { //          connection.disconnect(); } //       } else if (getUsersCmdPattern.matcher(data).matches()) { String userList = ""; //      ChatWebSocketHandler::webSockets for (ChatWebSocket webSocket : webSockets) { userList += webSocket.userName + ", "; } userList = userList.substring(0, userList.length() - 2); try { //     connection.sendMessage("inf|  : " + userList); } catch (IOException x) { //          connection.disconnect(); } //      } else if (helpCmdPattern.matcher(data).matches()) { String helpMessage = "     " + "       Enter.<br />" + "   :<br />" + "<ul><li><b>/help</b> -    </li>" + "<li><b>/getUsers</b> -    </li>" + "<li><b>/auth <i></i></b> -  </li></ul>"; try { //   connection.sendMessage("inf|" + helpMessage); } catch (IOException x) { //          connection.disconnect(); } //       } else { try { //     if (userName == null) { connection.sendMessage("err|  <br />" + "  <b>/help</b>  "); return; } //      ChatWebSocketHandler::webSockets for (ChatWebSocket webSocket : webSockets) { //       in   //  ,  -  out webSocket.connection.sendMessage((webSocket.equals(this) ? "out|" : ("in|" + userName + "|")) + data); } } catch (IOException x) { //          connection.disconnect(); } } } /** *       * @param closeCode * @param message */ @Override public void onClose(int closeCode, String message) { //      ChatWebSocketHandler::webSockets webSockets.remove(this); } } } 

और इसलिए हम ChatWebSocketHandler में क्या देखते हैं:

• 1 संपत्ति - सॉकेट्स का एक सेट;
• 1 विधि जो हमें एक नया सॉकेट बनाती है और लौटाती है;
• 1 निजी वर्ग जो इस WebSocket को लागू करता है।

ChatWebSocket वर्ग में, हम onMessage () विधि में रुचि रखते हैं। इसमें, हम क्लाइंट और सर्वर भागों के बीच डेटा के आदान-प्रदान के लिए एक प्रोटोकॉल लागू करेंगे। टिप्पणियों में इसके काम के सिद्धांत को दिखाया गया है।

एक्सचेंज प्रोटोकॉल क्या है?

सर्वर क्लाइंट से सभी पाठ संदेश प्राप्त करता है, तीन आदेशों को उनसे अलग किया जा सकता है:

• / सामान्य उपनाम // प्राधिकरण के लिए
• / getUsers // उपयोगकर्ताओं की सूची के लिए
• / सहायता // सहायता के लिए

क्लाइंट को निम्न पैटर्न वाले सर्वर से संदेश प्राप्त होते हैं:

• inf | सूचना // सूचना आई
• में | nic | संदेश // उपयोगकर्ता निक से आने वाला संदेश
• out | message // मेरा संदेश भेजा गया है
• त्रुटि | त्रुटि // त्रुटि जानकारी आ गई है

बाकी को फिर से चित्रित नहीं किया जाएगा - सब कुछ टिप्पणियों में वर्णित है।

अब सबसे महत्वपूर्ण क्षण पर चलते हैं - जेट्टी सर्वर को लॉन्च करना। इसलिए, हमारे पास एक कार्य है: सर्वलेट कंटेनर शुरू करते समय, जेट्टी चलाएं; सर्वलेट कंटेनर को रोकने से पहले, जेट्टी बंद करें। GlassFish में इसे लागू करने का सबसे आसान तरीका है कि आप अपना ContextListener लिखें। आइए देखते हैं क्यों? एक नया वर्ग बनाएं और इसे javax.servlet.ServletContextListener इंटरफ़ेस से इनहेरिट करें। सूची देखें।

 import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; import org.eclipse.jetty.server.Server; import org.eclipse.jetty.server.handler.DefaultHandler; public class ChatServerServletContextListener implements ServletContextListener { /** *   Jetty */ private Server server = null; /** *       * @param event */ @Override public void contextInitialized(ServletContextEvent event) { try { //   Jetty  8081  this.server = new Server(8081); //  ChatWebSocketHandler   Jetty ChatWebSocketHandler chatWebSocketHandler = new ChatWebSocketHandler(); //     WebSocketHandlerContainer chatWebSocketHandler.setHandler(new DefaultHandler()); //     jetty server.setHandler(chatWebSocketHandler); //  Jetty server.start(); } catch (Throwable e) { e.printStackTrace(); } } /** *       * @param event */ @Override public void contextDestroyed(ServletContextEvent event) { //   jetty -  if (server != null) { try { //  Jetty server.stop(); } catch (Exception e) { e.printStackTrace(); } } } } 

Javax.servlet.ServletContextListener इंटरफ़ेस में स्व-व्याख्यात्मक नाम के साथ दो विधियाँ हैं: ReferenceInitialized (), ReferenceDestroyed ()।

अब हमें बस इतना करना है कि हमारे ContextListener को तैनाती डिस्क्रिप्टर (web.xml) में प्लग कर दें। मैं उसकी सूची दूंगा:

 <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> <session-config> <session-timeout> 30 </session-timeout> </session-config> <welcome-file-list> <welcome-file>chat.html</welcome-file> </welcome-file-list> <listener> <listener-class>ChatServerServletContextListener</listener-class> </listener> </web-app> 

खैर अब आप प्रोजेक्ट शुरू कर सकते हैं। ब्राउज़र में, एक साथ दो विंडो खोलें और लिप्त रहें। कृपया समय पर ध्यान दें, संदेश लगभग तुरंत आते हैं। अजाक्स पर ऐसी गति प्राप्त करना लगभग असंभव है।

निष्कर्ष

पूरा प्रोजेक्ट यहां डाउनलोड किया जा सकता है
परियोजना पूरी तरह से ग्लासफिश 2.x, 3.x और टॉमकैट 5.0 से कम नहीं है। इस परियोजना का निर्माण Netbeans 7.0.1 में किया गया था। परियोजना के अंदर, आप चींटी को तैनात करने के लिए चींटी-तैनात.एक्सएमएल पा सकते हैं। एक बार फिर, मैं मावेन का उपयोग करने वाले डेवलपर्स से बेतहाशा माफी मांगता हूं।

लेख के दूसरे भाग में, मैं उन समस्याओं का विस्तार से वर्णन करूंगा, जो वेबस्केट के साथ काम करते समय उत्पन्न होती हैं, और उनके समाधान।
तीसरे भाग में, मैं वर्णन करूंगा कि जेट्टी सर्वर पर ddos ​​हमलों से कैसे निपटा जाए।

आपका ध्यान देने के लिए धन्यवाद। सभी एक बार फिर से एक खुश छुट्टी!