💻 🏭 👨🏼‍🔧 सर्वर-साइड जावा कोड कंटेनर लगातार कनेक्शन समर्थन के साथ 👨🏼‍🏫 🚴🏼 👂🏼

त्याग

लेख में वर्णित सब कुछ एक व्यक्तिगत व्यावहारिक अनुभव है और "अंतिम सत्य" का शीर्षक होने का दावा नहीं करता है।

प्रस्तावना

नमस्ते मुझे कंप्यूटर गेम बनाने में दिलचस्पी है। मेरी पसंदीदा दिशा, जिसमें मैं लगातार सुधार करने और कुछ नया सीखने की कोशिश करता हूं, ब्राउज़र आधारित मल्टीप्लेयर गेम हैं।
Apache Tomcat को एक आइडिया के लिए एक प्रोटोटाइप बनाने के लिए सर्वलेट कंटेनर के रूप में उपयोग किया जाता है। वह http प्रोटोकॉल के माध्यम से क्लाइंट पार्ट के साथ संचार करता है। इस प्रकार के खेल के लिए, यह योजना काफी वैध है, और इसे लागू करने के लिए काफी सरल है।
लेकिन समयपूर्व अनुकूलन में से एक (हाँ, यह बुरा है, लेकिन यहां मैंने इसे अनुमति देने का फैसला किया) सर्वर और क्लाइंट के बीच एक स्थायी कनेक्शन का उपयोग करने का विचार था, क्योंकि ऐसी योजना में, प्रत्येक अनुरोध में कनेक्शन खोलने / बंद करने में समय बर्बाद नहीं होता है। योजना को लागू करने के लिए, हमने टॉमस्कैट के लिए वेबसोकेट एपीआई पर विचार किया, लेकिन आपकी बाइक लिखना दिलचस्प हो गया, इसलिए, बिल्ली के नीचे विकास के बारे में कहानी को पूरा करें।

उपकरण

इसलिए, इस विचार को लागू करने के लिए, हमने उपयोग किया:

NetBeans 7.2.1: इसमें, वास्तव में, इस समस्या को हल करने के लिए सभी जावा कोड लिखे गए हैं
Jdk 1.7
Netty: यह तय किया गया था कि nio का उपयोग किया जाए ताकि सर्वर बड़ी संख्या में कनेक्शनों पर संभव हो सके, इस ढांचे ने ठीक काम किया।
सॉकेट आईओ: ग्राहक पक्ष
Apache Tomcat 7.0.27: बेंचमार्किंग के लिए
मावेन: यह सब सामान बनाने के लिए

आर्किटेक्चर

सबसे पहले, आवेदन तर्क पर विचार करें:

कंटेनर को मुख्य वर्ग सॉकेटसर्वलेटकॉनटेनर द्वारा दर्शाया गया है । यह कंटेनर को शुरू / बंद करने के लिए कार्य करता है, और इसमें सर्वलेट के प्रबंधन के तरीके भी शामिल हैं। मैं यह नोट करना चाहता हूं कि लेख में सर्वलेट शब्द एक ऑब्जेक्ट को संदर्भित करता है जिसमें सर्वर कोड के साथ एक विधि होती है और इसका जेसीपी सर्वलेट विनिर्देश के साथ कोई लेना-देना नहीं है। ऐसे ऑब्जेक्ट सर्वलेट्स को कॉल करना मेरे लिए अधिक सुविधाजनक है।

दरअसल, हमारे पास बेस क्लास सर्वलेट है , जिसमें से सभी उपयोगकर्ता सर्वलेट्स विरासत में मिलते हैं, कनेक्शन सत्र वर्ग ( सॉकेटसेंशन ), जिसका उपयोग सत्र के बारे में जानकारी संग्रहीत करने और उपयोगकर्ता को संदेश भेजने के लिए किया जाता है (मैंने ऐसा क्यों किया, मैं बाद में समझाऊंगा )। इनकमिंग और आउटगोइंग बफ़र्स ( InputBuffer और OutputBuffer ) की कक्षाएं क्रमशः लागू की गईं।

यह भी सहायक वर्ग विन्यास को लागू करने के लिए आवश्यक था, जो xml प्रारूप में कॉन्फ़िगरेशन फ़ाइल को पार्स करने के लिए जिम्मेदार है। उल्लेख क्यूहैंडलर और टास्कहैंडलर वर्गों का होना चाहिए।

QueueHandler एक अनुरोध पंक्ति हैंडलर है और इसमें प्रसंस्करण के लिए टास्क वर्ग का एक उदाहरण जोड़ने के लिए एक विधि है।
TaskHandler Runnable इंटरफ़ेस को लागू करता है। रन विधि में सबमिट किए गए अनुरोध का प्रसंस्करण होता है।
टास्क क्लास में उस अनुरोध के बारे में जानकारी होती है जो आ गई है (जो सर्वर को दिए गए पैरामीटर को संदर्भित करता है) और नेटवर्क के साथ काम करने के तरीके (रीड \ राइट)।

अब नेटवर्क के साथ काम के संगठन पर विचार करें:

मैं नेट्टी के साथ काम का ब्यौरा नहीं दूंगा, क्योंकि यह मेरे पहले ही हो चुका है (नेटी पर उनके लेख के लिए Rena4ka habrayuzer के लिए विशेष धन्यवाद)। एक आधिकारिक साइट पर एक हब्र या प्रलेखन पर पढ़ें क्योंकि यह आपके लिए अधिक सुविधाजनक होगा। मैं केवल उस हिस्से पर विचार करूंगा जो मूल सिद्धांत को समझने के लिए आवश्यक है एक व्यक्ति द्वारा जिसे नेटी के साथ प्रोग्रामिंग अनुभव नहीं है।
ServerPipelineFactory वर्ग एक ChannelPipeline कारखाना है और इसे कार्य करने के लिए Netty के लिए आवश्यक है। मुझे 3 वर्गों को लागू करना पड़ा: विकोडक , एनकोडर , NioHandler ।
पहले 2 पैकेट के हैंडलर हैं जो सर्वर पर आए थे। डिकोडर नेटवर्क से आने वाले पैकेट को सही ढंग से पार्स करने के लिए जिम्मेदार है और टास्क क्लास का एक उदाहरण देता है। एनकोडर नेटवर्क पर टास्क इंस्टेंस को सही ढंग से लिखने और क्लाइंट को भेजने के लिए जिम्मेदार है।
NioHandler , वास्तव में, एक नेटवर्क प्रबंधक है: कनेक्शन स्वीकार करता है, प्रसंस्करण के लिए कार्य भेजता है और सत्रों का प्रबंधन करता है।

प्रोटोकॉल

क्लाइंट और सर्वर के बीच संवाद करने के लिए, आपको अपने स्वयं के प्रोटोकॉल की आवश्यकता होती है। मैंने इसे काफी सरल और शाब्दिक बनाने का फैसला किया।
नतीजतन, क्लाइंट इस तरह दिखने वाले सर्वर को एक क्वेरी स्ट्रिंग भेजता है: servlet_name [sysDiv] request_ametameters।
क्वेरी पैरामीटर की सूची का प्रारूप: name1 = value1, name2 = value2, ...

उदाहरण : "टीएस [sysDiv] संदेश = हैलो habrahabr.ru"।

यह ध्यान दिया जाना चाहिए कि प्रोटोकॉल इस अर्थ में सममित है कि क्लाइंट को उस सर्वलेट का संकेत मिलता है जो प्रतिक्रिया उत्पन्न करता है और पारित मापदंडों की सूची।

और अब हम अपने कंटेनर के कोड पर विचार करने के लिए सीधे पास होंगे। लेकिन सबसे पहली बात।

कॉन्फ़िगरेशन फ़ाइल स्वरूप

<?xml version="1.0" encoding="utf-8"?> <config> <address>localhost</address> <port>9999</port> <workThreadCount>2</workThreadCount> <processThreadCount>2</processThreadCount> </config>

workThreadCount - थ्रेड्स की संख्या जो नेटवर्क से संदेश प्राप्त करते हैं और नेटवर्क को लिखते हैं (नेटी को इनिशियलाइज़ करने के लिए आवश्यक है)।
processThreadCount - सर्वर पर आने वाले अनुरोधों की सामान्य कतार को संसाधित करने वाले थ्रेड्स की संख्या। उनमें, वास्तव में, क्वेरी स्ट्रिंग्स की पार्सिंग है, सभी सर्वर कोड का संचालन और प्रतिक्रियाओं का गठन।

SocketServletContainer

यह वर्ग एक सिंगलटन है, क्योंकि यह एक "केंद्रीय" वर्ग है और इसलिए इसे कार्यक्रम के अन्य वर्गों से एक्सेस करना अधिक सुविधाजनक होगा। और, ज़ाहिर है, प्रति एप्लिकेशन सर्वर की 1 प्रति निहित है (इसलिए, एक थ्रेड-सुरक्षित सिंगलटन कार्यान्वयन की आवश्यकता नहीं है)। जो, मेरी राय में, तर्कसंगत है।

 public class SocketServletContainer { private Channel channel; private ServerBootstrap networkServer; private QueueHandler queueHander; private Map<String, Servlet> servlets; private Config conf; private static SocketServletContainer server= null; private static List<SocketSession> list= new ArrayList<SocketSession>(); public List<SocketSession> getListSession() { return list; } static public SocketServletContainer getInstance() { if (server==null) { server= new SocketServletContainer(); } return server; } private SocketServletContainer() { conf= new Config("conf.xml"); // ,   -  Exception. try { conf.read(); } catch(Exception e) { throw new ContainerInitializeException(e.toString()); } servlets= new HashMap<String, Servlet>(); } public void start() { // Netty ExecutorService bossExec = new OrderedMemoryAwareThreadPoolExecutor(1, 400000000, 2000000000, 60, TimeUnit.SECONDS); ExecutorService ioExec = new OrderedMemoryAwareThreadPoolExecutor(conf.getWorkThreadCount(), 400000000, 2000000000, 60, TimeUnit.SECONDS); networkServer = new ServerBootstrap(new NioServerSocketChannelFactory(bossExec, ioExec, conf.getWorkThreadCount())); networkServer.setOption("backlog", 500); networkServer.setOption("connectTimeoutMillis", 10000); networkServer.setPipelineFactory(new ServerPipelineFactory()); channel = networkServer.bind(new InetSocketAddress(conf.getAddress(), conf.getPort())); //    queueHander= new QueueHandler(conf.getProcessThreadCount()); System.out.println("Ready"); } // «»   public void stop() { if (channel.isOpen()) { ChannelFuture future= channel.close(); future.awaitUninterruptibly(); } queueHander.stop(); } public QueueHandler getQueueHandler() { return this.queueHander; } //      public void registerServlet(Servlet servlet, String name) { //    -    HashMap. synchronized(servlets) { if (!servlets.containsKey(name)) { servlets.put(name, servlet); } } } public Servlet getServlet(String name) { return servlets.get(name); } }

सर्वलेट

यहां सब कुछ सरल और स्पष्ट है। DoRequest मेथड उस समय कहा जाता है जब कोई पैकेट इस सर्वलेट को कॉल करने के निर्देश पर आता है।
ज़म: सत्र को doRequest पद्धति से पारित किया जाता है ताकि सर्वलेट सभी उपलब्ध सत्रों की सूची प्राप्त कर सके और उन्हें एक संदेश भेज सके। उदाहरण के लिए, चैट को लागू करते समय।

 abstract public class Servlet { abstract public void doRequest(InputBuffer input, OutputBuffer output, SocketSession session); }

SocketSession

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

 public class SocketSession { private static byte[] idPool; public int generateId() { synchronized(idPool) { if (idPool==null) { idPool= new byte[20000]; for (int j=0;j<idPool.length;j++) { idPool[j]=0; } } for (int j=0;j<idPool.length;j++) { if (idPool[j]==0) { idPool[j]=1; return j; } } return -1; } } private int id; private Channel channel; //      List  . public SocketSession(Channel channel) { this.channel= channel; this.id= generateId(); //    if (this.id==-1) { OutputBuffer out= new OutputBuffer(); out.setPar("error", "Connection limit error"); send(out, "System Servlet"); //  System.err.println("Connection limit error"); return; } SocketServletContainer.getInstance().getListSession().add(this); } public int getId() { return id; } //  .            . public void send(OutputBuffer output, String servletName) { synchronized(channel) { channel.write(new Task(servletName, output.toString())); } } // , ,      - «»  public void close() { synchronized(idPool) { idPool[this.id]= 0; } channel.close(); SocketServletContainer.getInstance().getListSession().remove(this); } }

InputBuffer

प्रारंभिक निर्माण में होता है, स्रोत स्ट्रिंग में निर्दिष्ट प्रारूप में क्वेरी मापदंडों की एक सूची होनी चाहिए।

 public class InputBuffer { private Map<String, String> map= new HashMap<String, String>(); public InputBuffer(String source) { String[] par= source.split(","); for (int j=0; j< par.length; j++) { if (!par[j].contains("=")) { continue; } String[] data= par[j].split("="); if (data.length<2) { System.err.println("Parsing Error"); continue; } map.put(data[0], data[1]); } } public String getPar(String key) { return map.get(key); } }

OutputBuffer

वर्ग इंटरफ़ेस बहुत सीधा है। एक महत्वपूर्ण नोट यह है कि आपको toString () विधि को ओवरराइड करने की आवश्यकता है, क्योंकि इसका उपयोग सॉकेट सेशन वर्ग में प्रतिक्रिया बनाने के लिए किया जाता है।

 public class OutputBuffer { private List<String> list= new ArrayList<String>(); public void setPar(String key, String par) { list.add(key+"="+par); } @Override public String toString() { StringBuilder res= new StringBuilder(); for (int j=0; j< list.size();j++) { res.append(list.get(j)); if (j!=list.size()-1) { res.append(","); } } return res.toString(); } }

कॉन्फ़िग

मैं इस वर्ग का कार्यान्वयन नहीं दूंगा, क्योंकि इसका इंटरफ़ेस सॉकेटसर्वलेटकॉनटेनर में उपयोग किए जाने वाले से स्पष्ट है, और इंटरनेट पर जावा पर एक्सएमएल पार्सर्स के बहुत सारे कार्यान्वयन हैं और मुझे आशा है कि पाठक इसके लिए सबसे उपयुक्त पाएंगे।
व्यक्तिगत रूप से, मैंने DOM पार्सर का उपयोग किया।

QueueHandler

इस वर्ग को लागू करना भी बहुत आसान है। अंदर, इसमें एक थ्रेड पूल होता है जो कार्यों ( टास्कहैंडलर ) को संभालता है। मैंने योजना को एक विश्वसनीय और सिद्ध धागापूल कार्यान्वयन में स्थानांतरित कर दिया। Executors.newFixedThreadPool (n) फैक्ट्री का उपयोग पूल बनाने के लिए किया जाता है।

जब रोक विधि को कॉल किया जाता है, तो कतार में पहले से मौजूद कार्यों को संसाधित किया जाएगा, लेकिन प्रसंस्करण के लिए नए टास्कहैंडर्स स्वीकार नहीं किए जाएंगे।

 public class QueueHandler { private ExecutorService threadPool; private int threadPoolSize; public QueueHandler(int size) { threadPoolSize= size; threadPool= Executors.newFixedThreadPool(threadPoolSize); } public void stop() { threadPool.shutdown(); } public void addTaskToProcess(Task task, SocketSession session) { threadPool.execute(new TaskHandler(task, session)); } }

TaskHandler

यहां सब कुछ बहुत सरल भी है। खिलाड़ी का सत्र और संसाधित किए जाने वाले कार्य को कंस्ट्रक्टर में स्थानांतरित कर दिया जाता है।

 public class TaskHandler implements Runnable{ private Task task; private SocketSession session; public TaskHandler(Task task, SocketSession session) { this.task= task; this.session= session; } @Override public void run() { //     Servlet servlet= SocketServletContainer.getInstance().getServlet(task.getServletName()); OutputBuffer output= new OutputBuffer(); //  ,   . if (servlet==null) { output.setPar("error", "servlet not found"); session.send(output, "Error Message"); return; } //     servlet.doRequest(new InputBuffer(task.getBuffer()),output, session); //  . session.send(output, task.getServletName()); } }

कार्य

टास्क ऑब्जेक्ट में फ़ील्ड "सर्वलेट नाम" और "बफर" है। एक बफर क्वेरी पैरामीटर की एक स्ट्रिंग है।
क्लास के उदाहरणों को लिखने के लिए स्टेटिक लिखने / पढ़ने के तरीकों की आवश्यकता होती है।

 public class Task { private String servletName=""; private String buffer=""; public Task(String servletName, String buffer) { this.servletName= servletName; this.buffer= buffer; } public Task() { } public String getServletName() { return servletName; } public String getBuffer() { return buffer; } //    public void get(ChannelBuffer buffer) { int length= buffer.readInt(); byte[] bytes= new byte[length]; buffer.readBytes(bytes); String input= new String(bytes); String[] data= input.split(java.util.regex.Pattern.quote("[sysDiv]")); if (data.length<2) { System.err.println("Parsing error"); return; } this.servletName= data[0]; this.buffer= data[1]; } //    public void send(ChannelBuffer buffer) { String output= this.servletName + "[sysDiv]"+ this.buffer; buffer.writeInt(output.getBytes().length); buffer.writeBytes(output.getBytes()); } public static Task read(ChannelBuffer buffer) { Task task= new Task(); task.get(buffer); return task; } public static void write(Task task, ChannelBuffer buffer) { task.send(buffer); } }

नेटवर्क भाग

जैसा कि वादा किया गया है, मैं विस्तार से काम करने पर विचार नहीं करूंगा, मैं सिर्फ कोड दूंगा और उन बिंदुओं को समझाऊंगा जो तर्क के कार्यान्वयन से संबंधित हैं।

ServerPipelineFactory

 public class ServerPipelineFactory implements ChannelPipelineFactory { @Override public ChannelPipeline getPipeline() throws Exception { return Channels.pipeline(new Encoder(),new Decoder(),new NioHandler()); } }

डिकोडर

पैकेट निम्न प्रारूप में सर्वर पर आता है: पहले 4 बाइट्स "उपयोगी" डेटा की लंबाई हैं, फिर डेटा ही। डिकोडर पढ़ने को लागू करता है ताकि ऊपर स्थित परतों में, हम इस तथ्य के बारे में नहीं सोच सकें कि डेटा अभी तक पूरी तरह से नहीं आया है।

 public class Decoder extends ReplayingDecoder<DecoderState> { public enum DecoderState { READ_LENGTH, READ_CONTENT; } public Decoder() { super(DecoderState.READ_LENGTH); } private int length; @Override public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } @Override public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } @Override protected Object decode(ChannelHandlerContext arg0, Channel arg1, ChannelBuffer buffer, DecoderState state) { switch (state) { case READ_LENGTH: length = buffer.readInt(); checkpoint(DecoderState.READ_CONTENT); case READ_CONTENT: ChannelBuffer frame= buffer.readBytes(length); // task       Task task= Task.read(frame); checkpoint(DecoderState.READ_LENGTH); return task; default: throw new Error( "Shouldn't reach here" ); } } }

एनकोडर

 public class Encoder extends OneToOneEncoder { @Override protected Object encode(ChannelHandlerContext channelhandlercontext, Channel channel, Object obj) throws Exception { //    Task,      if(!(obj instanceof Task)) { return obj; } Task task= (Task)obj; ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); // task   Task.write(task, buffer); return buffer; } }

NioHandler

यह ऑब्जेक्ट नेटवर्क के साथ काम करने की मुख्य घटनाओं को संसाधित करता है: ग्राहकों को जोड़ना, संदेश प्राप्त करना, डिस्कनेक्ट करना।

 public class NioHandler extends SimpleChannelUpstreamHandler { private SocketSession session; @Override public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { //     session= new SocketSession(e.getChannel()); System.out.println("Has connect"); } @Override public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { session.close(); } @Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) { if(e.getChannel().isOpen()) { //  Task       QueueHandler. Task message= (Task)e.getMessage(); SocketServletContainer.getInstance().getQueueHandler().addTaskToProcess(message, session); } } @Override public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) { //  .  ,    . session.close(); e.getCause().printStackTrace(System.err); ctx.getChannel().close(); } }

सर्वलेट उदाहरण

 public class TS extends Servlet { @Override public void doRequest(InputBuffer input, OutputBuffer output, SocketSession session) { output.setPar("request", input.getPar("message")+session.getId()); } }

यह कैसे काम करता है या एप्लिकेशन का मुख्य वर्ग है

दरअसल, एप्लिकेशन में कोड की इतनी सारी लाइनें नहीं हैं, सब कुछ सरल और पारदर्शी है।

 public class App { public static void main( String[] args ) throws ContainerInitializeException { SocketServletContainer server= SocketServletContainer.getInstance(); server.registerServlet(new TS(), "TS"); server.start(); } }

कुछ परीक्षण

खैर, कंटेनर लिखा है, यह काम करता है। मैंने इसके लिए एक क्लाइंट रैपर बनाने से परेशान नहीं किया, मैंने खुद को सीधे सॉकेट पर लिखने तक सीमित कर दिया, यह कुछ इस तरह दिखता है:

 socket = new Socket("127.0.0.1", 9999); DataOutputStream dos= new DataOutputStream(socket.getOutputStream()); DataInputStream dis= new DataInputStream(socket.getInputStream()); String buffer= "TS[sysDiv]message=IloveJava"; dos.writeInt(buffer.getBytes().length+4); dos.writeInt(buffer.getBytes().length); dos.write(buffer.getBytes()); dos.flush();

सामान्य तौर पर, जैसा कि लेख की बहुत शुरुआत में कहा गया है, इस तरह की प्रणाली का निर्माण समयपूर्व अनुकूलन में से एक है जिसे मैंने खुद को अनुमति देने का फैसला किया था। इसलिए, यह मूर्खतापूर्ण होगा कि हम एक दो परीक्षण न करें, क्योंकि हम सभी ने इसे लिखा था।

दरअसल, मैंने इस समाधान की तुलना http पर चलने वाले सर्वलेट कंटेनर से करने का निर्णय लिया।
परीक्षणों के लिए, एक सर्वलेट विकसित किया गया था जो टॉमकैट में घूमता है और निर्मित कंटेनर के अंदर काम करने वाला एक सर्वलेट है।

ज़म: मैंने जानबूझकर http प्रोटोकॉल के प्रदर्शन और सॉकेट्स के समाधानों की तुलना की, क्योंकि इस गेम प्रोजेक्ट के कार्यान्वयन के लिए टॉमकैट ने जिस वेब-सॉकेट का सफलतापूर्वक समर्थन किया था, उस पर मेरे द्वारा विचार नहीं किया गया था।

परीक्षण की विशेषताएं:

दोनों सर्वलेट्स ने लगभग एक ही संचालन किया, अर्थात्, उन्होंने आउटपुट स्ट्रीम को एक ही पंक्ति लिखी।
अनुरोध को संसाधित करते समय परीक्षण पैरामीटर जो मेरी रुचि रखता है, सर्वर से प्रतिक्रिया समय है
स्थानीय स्तर पर माप किए गए
मुझे मानक जावा भाषा टूल का उपयोग करके प्रतिक्रिया समय मिला
मुझे विशिष्ट संख्याओं में कोई दिलचस्पी नहीं थी, लेकिन परिणामों के क्रम की तुलना करने के बाद से, परीक्षण बहुत "मोटे तौर पर" लिखा गया था
प्रत्येक परीक्षण के लिए, 10,000 प्रश्नों को एक ही पैरामीटर के साथ किया गया था, जिसके बाद औसत मूल्य की गणना की गई थी

और इसका परिणाम यह है: टॉम्कट के लिए औसतन 1 "खाली" सर्वलेट प्रसंस्करण , 0, 99 एमएस लिया।
लेख में वर्णित कंटेनर 0.09 एमएस में एक समान कार्य के साथ सामना किया।

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

कार्यसूची:

एक छोटी सूची भी थी जिसे अभी भी एक समान प्रणाली के लिए लागू किया जा सकता है, जिसे मैं भी दूंगा:

इनपुट डेटा की मान्यता। आप इनपुट बफर के लिए एक वैध (स्ट्रिंग मास्क) विधि जोड़ सकते हैं, जो स्वचालित रूप से संबंधित मापदंडों के लिए डेटा प्रकार मास्क का उपयोग करके वांछित (न केवल स्ट्रिंग) प्रकार में बदल देगा। यह कुछ इस तरह दिख सकता है: मान्य करें ("संदेश: स्ट्रिंग, गिनती: int");
डेटा एन्क्रिप्शन जोड़ें। यह इसके लिए है कि बाइट [] बफर लिखा जाता है, राइटआउटएफ 8 () नहीं, हालांकि प्रोटोकॉल टेक्स्ट है। आप इंटरफ़ेस क्रिप्टो {} लागू कर सकते हैं, जिसमें 2 विधियाँ होंगी: कोड () और एनकोड ()। और क्रिप्टोग्राफी एल्गोरिथ्म के सुविधाजनक परिवर्तन या चयन के लिए इस तरह के एक इंटरफेस के कार्यान्वयन को सॉकेटसर्वलेटकॉनटेनर () को पास किया जाना चाहिए।
एनोटेशन के साथ काम करें (जैसा कि टॉमकैट में किया गया है) और विलंबित सर्वलेट इनिशियलाइज़ेशन।
सीमांकन परिरक्षण के साथ इनपुट बफर के सुरक्षित पार्सिंग
अन्य उपयोगी छोटी चीजों का एक गुच्छा जो इस तरह की प्रणाली में आवश्यक हो सकता है।

एक निष्कर्ष के बजाय

कंटेनर के परिणामों ने मेरी उम्मीदों को पूरी तरह से संतुष्ट किया। NIO का उपयोग करके हमें आर्थिक रूप से प्रवाह का उपभोग करने और मौजूदा हार्डवेयर के लिए कंटेनर को कॉन्फ़िगर करने की अनुमति दी गई है ताकि यह यथासंभव कुशलता से काम करे।
कंटेनर जो कार्यक्षमता प्रदान करता है, वह आपको "निम्न-स्तरीय" चीजों के बारे में चिंता किए बिना, जैसे कि पैकेट पार्सिंग और इतने पर (सब कुछ मुझे लगता था, टॉमकैट पर विकसित करने के लिए उपयोग किया जाता है) के बारे में चिंता किए बिना एप्लिकेशन को आसानी से विकसित करने की अनुमति देता है।

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

मुझे उम्मीद है कि यह लेख पाठकों के लिए दिलचस्प होगा और किसी के लिए उपयोगी साबित होगा। मैंने पूरी तस्वीर को व्यक्त करने की कोशिश की, शायद मैं तर्क और कोड की मात्रा के साथ बहुत दूर चला गया। लिखित सामग्री पर आपके प्रश्न और सुझाव सुनकर मुझे प्रसन्नता हुई।

सर्वर-साइड जावा कोड कंटेनर लगातार कनेक्शन समर्थन के साथ