भाग 6. सर्वलेट कंटेनर

यह सामग्री "उद्यम विकास का परिचय" श्रृंखला का हिस्सा है। पिछले लेख:

• नेटवर्किंग के बारे में
• सॉफ्टवेयर आर्किटेक्चर के बारे में
• HTTP/HTTPS के बारे में
• मेवेन की मूल बातें के बारे में
• सर्वलेट्स के बारे में (एक साधारण वेब एप्लिकेशन लिखना)

पिछले लेख में, हम सर्वलेट्स से परिचित हुए और वेब एप्लिकेशन बनाने के लिए उनका उपयोग करना सीखा। समय आ गया है कि इस मस्ती के एक अनिवार्य हिस्से पर करीब से नज़र डाली जाए: सर्वलेट कंटेनर।

विषयसूची:

• सर्वलेट कंटेनर क्या है?
• सर्वलेट कंटेनर कैसे उपयोग किए जाते हैं?
• टॉमकैट को स्थापित करना और शुरू करना
• टोमकैट में एक आवेदन तैनात करना
• HTTP के बजाय HTTPS का उपयोग करना
• प्रमाण पत्र बनाना
• सर्वर को कॉन्फ़िगर करना
• गतिशील रूप से HTML पृष्ठ उत्पन्न करना
• टॉमकैट के विकल्प

सर्वलेट कंटेनर क्या है?

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

सर्वलेट कंटेनर कैसे उपयोग किए जाते हैं?

रूटिंग अनुरोधों के अलावा, सर्वलेट कंटेनर अन्य कार्य भी करता है:

1. यह जेएसपी फाइलों से गतिशील रूप से एचटीएमएल पेज उत्पन्न करता है।
2. यह HTTPS संदेशों को एन्क्रिप्ट/डिक्रिप्ट करता है।
3. यह सर्वलेट प्रशासन के लिए प्रतिबंधित पहुंच प्रदान करता है।

सामान्य तौर पर, यह सब अच्छा लगता है। अब हमें केवल यह पता लगाने की जरूरत है कि इसे व्यवहार में कैसे लाया जाए। ठीक है, किसी चीज़ का उपयोग कैसे करना है, यह जानने के लिए, बस गोता लगाएँ और उसका उपयोग करने का प्रयास करें :) तो, आज हम अभ्यास करने जा रहे हैं! सबसे लोकप्रिय सर्वलेट कंटेनर Apache Tomcat है । यह खुला स्रोत है और इसे मुफ्त में इस्तेमाल किया जा सकता है। यहां अपने ऑपरेटिंग सिस्टम के लिए टॉमकैट डाउनलोड करें और हम "इन एक्शन" कंटेनरों के साथ काम करने की खोज करेंगे।

टॉमकैट को स्थापित करना और शुरू करना

1. टॉमकैट को स्थापित करने के लिए, डाउनलोड किए गए संग्रह को वांछित निर्देशिका में अनज़िप करें।

2. कृपया ध्यान दें कि टॉमकैट को शुरू करने और चलाने के लिए जावा संस्करण 8 या उच्चतर की आवश्यकता है। सत्यापित करें कि JAVA_HOME पर्यावरण चर JDK के वर्तमान संस्करण का संदर्भ देता है।

3. अगला, आपको टॉमकैट के लिए उपयोगकर्ता पहुंच को कॉन्फ़िगर करने की आवश्यकता है । यह tomcat-users.xml फ़ाइल में किया जाता है, जो गोपनीय फ़ोल्डर में स्थित है।

   टॉमकैट में चार प्रीसेट भूमिकाएँ हैं:

   • मैनेजर-गुई — ग्राफिकल इंटरफेस और स्टेटस पेज तक पहुंच
   • मैनेजर-स्क्रिप्ट — टेक्स्ट इंटरफ़ेस और स्थिति पृष्ठ तक पहुंच
   • मैनेजर-जेएमएक्स - जेएमएक्स और स्टेटस पेज तक पहुंच
   • प्रबंधक-स्थिति - केवल स्थिति पृष्ठ तक पहुंच

   <Tomcat-users> टैग के अंदर, हम इन भूमिकाओं को स्पष्ट रूप से निर्दिष्ट करते हैं और उन्हें हमारे उपयोगकर्ता को सौंपते हैं:

   <role rolename="manager-gui"/>
   <role rolename="manager-script"/>
   <role rolename="manager-jmx"/>
   <role rolename="manager-status"/>
   <user username="user" password="password"
       roles="manager-gui, manager-script, manager-jmx, manager-status"/>

   अब सब कुछ लॉन्च करने के लिए तैयार है!

4. बिन फ़ोल्डर में, स्टार्टअप.bat फ़ाइल (Linux पर startup.sh) चलाएँ।

5. कुछ सेकंड के बाद, अपने ब्राउज़र में http://localhost:8080/ लिंक खोलें । आपको एक ग्राफिकल डैशबोर्ड दिखाई देगा:

   यदि आप इस तरह का मेनू देखते हैं, तो टॉमकैट चल रहा है।

6. यदि यह नहीं चल रहा है, तो मैन्युअल रूप से JAVA_HOME और CATALINA_HOME पर्यावरण चरों की जाँच करें:

   • JAVA_HOME - इसे Java 8+ के वर्तमान संस्करण का संदर्भ देना चाहिए।
   • CATALINA_BASE - इसे टॉमकैट का संदर्भ देना चाहिए या अनुपस्थित होना चाहिए (इसे टॉमकैट के दूसरे संस्करण का संदर्भ नहीं देना चाहिए)।

टोमकैट में एक आवेदन तैनात करना

हम टॉमकैट लॉन्च करने में कामयाब रहे, इसलिए अब इसमें कुछ प्रोजेक्ट तैनात करने का समय आ गया है। आइए पिछले लेख के सर्वलेट्स का उपयोग करें । मुख्य सर्वलेट:

import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class MainServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
       HttpSession session = req.getSession();
       Integer visitCounter = (Integer) session.getAttribute("visitCounter");
       if (visitCounter == null) {
           visitCounter = 1;
       } else {
           visitCounter++;
       }
       session.setAttribute("visitCounter", visitCounter);
       String username = req.getParameter("username");
       resp.setContentType("text/html");
       PrintWriter printWriter = resp.getWriter();
       if (username == null) {
           printWriter.write("Hello, Anonymous" + "");
       } else {
           printWriter.write("Hello, " + username + "");
       }
       printWriter.write("Page was visited " + visitCounter + " times.");
       printWriter.close();
   }
}

इंडेक्स सर्वलेट:

import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/")
public class IndexServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
       resp.sendRedirect(req.getContextPath() + "/hello");
   }
}

परिनियोजन से पहले, हमें अपने सर्वलेट्स को WAR फ़ाइल में पैकेज करने की आवश्यकता होती है। मेवेन आमतौर पर ऐसा करने के लिए प्रयोग किया जाता है, लेकिन एक WAR फ़ाइल बनाने के लिए आपको एक web.xml फ़ाइल की आवश्यकता होती है जिसमें सभी सर्वलेट्स के लिए मैपिंग हो। सर्वलेट लिखने के लिए हमने नए @WebServlet एनोटेशन का उपयोग किया, इसलिए हमारे पास web.xml फ़ाइल नहीं है। सौभाग्य से, आइडिया हमारे लिए गंदा काम कर सकता है, हमारे प्रोजेक्ट को WAR फ़ाइल में लपेट सकता है। ऐसा करने के लिए, प्रोजेक्ट स्ट्रक्चर खोलें (Ctrl+Shift+Alt+S) -> आर्टिफैक्ट्स -> वांछित WAR फ़ाइल चुनें -> "प्रोजेक्ट बिल्ड में शामिल करें" के बगल में स्थित चेकबॉक्स चुनें -> "ओके" पर क्लिक करें। आइए Ctrl+F9 कुंजी संयोजन का उपयोग करके प्रोजेक्ट बनाएं। अब हमारी WAR फाइल टारगेट डायरेक्टरी में है ।हम इसे एक कंटेनर में डाल देंगे । इसे करने के दो तरीके हैं।

1. ग्राफिकल इंटरफ़ेस का उपयोग करना

   ऐसा करने के लिए, इस लिंक का अनुसरण करें: http://localhost:8080/manager/html । टॉमकैट को उपयोगकर्ता नाम और पासवर्ड मांगना चाहिए।

   यदि आपने इस बिंदु तक मेरा साथ दिया है, तो उपयोगकर्ता नाम "उपयोगकर्ता" है, और पासवर्ड "पासवर्ड" है ।

   सफलतापूर्वक साइन इन करने के बाद, आप टॉमकैट वेब एप्लिकेशन मैनेजर देखेंगे। "एप्लिकेशन" खंड में पहले से ही 5 एप्लिकेशन हैं - ये टॉमकैट यूटिलिटीज हैं, जो टॉमकैट के साथ काम करना आसान बनाती हैं। उन्हें भविष्य में हटाया जा सकता है।

   नीचे "तैनाती" अनुभाग है। यहां आप तैनात करने के लिए युद्ध संग्रह का चयन कर सकते हैं। आइए मैन्युअल रूप से पथ और संदर्भ दर्ज करें:

   "तैनाती" पर क्लिक करें और हम देखते हैं कि हमारा आवेदन "अनुप्रयोग" अनुभाग में दिखाई दिया है:

   टॉमकैट के ग्राफिकल इंटरफ़ेस का उपयोग करके, हम एक सत्र को रोक सकते हैं, पुनः आरंभ कर सकते हैं और हटा सकते हैं, साथ ही सत्र की लंबाई भी निर्धारित कर सकते हैं। तैनात करते समय, हमने /डेमो संदर्भ निर्दिष्ट किया, जिसका अर्थ है कि हमारे एप्लिकेशन को http://localhost:8080/demo का उपयोग करके एक्सेस किया गया है । यह जाँचें। सब कुछ काम करना चाहिए।

2. फाइल सिस्टम के माध्यम से

   एप्लिकेशन को इस तरह से तैनात करने के लिए, आपको उस निर्देशिका को खोलना होगा जहां टॉमकैट अनज़िप किया गया था। फिर "वेबएप" फ़ोल्डर में जाएं। यहाँ आपको वे उपयोगिताएँ मिलेंगी जिनका हम पहले ही सामना कर चुके हैं:

   हमें केवल अपनी सर्वलेट.वार फ़ाइल को यहां स्थानांतरित करने की आवश्यकता है।

   हम कुछ सेकंड प्रतीक्षा करते हैं और फिर देखते हैं कि एक नया "सर्वलेट" फ़ोल्डर दिखाई दिया है। इसका मतलब है कि हमारा आवेदन तैनात है। http://localhost:8080/manager/ पर एप्लिकेशन मैनेजर इंटरफेस पर जाएं । यहां हम देखते हैं कि हमारा एप्लिकेशन/सर्वलेट संदर्भ में तैनात है:

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

   जैसा कि आप देख सकते हैं, टॉमकैट में एप्लिकेशन को तैनात करना जितना आसान लगता है, उससे कहीं ज्यादा आसान है। लेकिन इसके अन्य कार्यों का उपयोग करना भी आसान है। की जाँच करें।

HTTP के बजाय HTTPS का उपयोग करना

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

1. एक स्व-हस्ताक्षरित प्रमाण पत्र उत्पन्न करें
2. अतिरिक्त सर्वर सेटिंग करें

आइए इसे करने का अभ्यास करें।

प्रमाण पत्र बनाना

संस्करण के बावजूद, JDK में बड़ी संख्या में उपयोगिताएँ शामिल हैं। उनमें से एक keytool है । यह एन्क्रिप्शन कुंजियों को उत्पन्न करने और उनके साथ काम करने का एक उपकरण है। इसका उपयोग करने के लिए, कमांड लाइन पर, C:\\Program Files\\Java\\jdk1.8.0_181\\bin डायरेक्टरी पर जाएं और कमांड keytool -genkey -alias tomcat -keyalg RSA रन करें ।

• keytool — उपयोगिता का नाम जिसे हम कमांड लाइन विकल्पों के साथ चला रहे हैं
• -genkey - इंगित करें कि हम एक नई कुंजी उत्पन्न करना चाहते हैं
• -alias tomcat — एक प्रमुख उपनाम बनाएँ
• -कीलग आरएसए — मुख्य जनन एल्गोरिथम के रूप में आरएसए का चयन करें

कमांड निष्पादित करने के बाद, उपयोगिता हमारे साथ एक संवाद शुरू करती है: आवश्यक जानकारी दर्ज करें। अब हमने अपनी होम डायरेक्टरी में एक कीस्टोर बनाया है (विंडोज़ के लिए, यह C:\\Users\\{username}\\.keystore है) और इसमें एक टॉमकैट कुंजी है। हमने एक साधारण प्रमाणपत्र तैयार किया है जिसके बारे में अधिकांश ब्राउज़र शिकायत करेंगे। ऐसा प्रमाणपत्र व्यावसायिक अनुप्रयोगों के लिए उपयुक्त नहीं है: इसका उपयोग केवल परीक्षण उद्देश्यों के लिए किया जा सकता है। उत्पादन सर्वर पर, आपको प्रमाणन प्राधिकरण से प्रमाणपत्र का उपयोग करने की आवश्यकता होती है (उदाहरण के लिए, https://letsencrypt.org/ )।

सर्वर को कॉन्फ़िगर करना

अब जब प्रमाणपत्र तैयार हो गया है, हमें सर्वर सेटिंग्स, अर्थात् एसएसएल कनेक्टर को समायोजित करने की आवश्यकता है। यह server.xml फ़ाइल में किया जाता है, जो apache-tomcat-9.0.30/conf/ में स्थित है । इसमें हमें इस तरह के ब्लॉक मिलते हैं:

<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
               maxThreads="150" SSLEnabled="true">
        <SSLHostConfig>
            <Certificate certificateKeystoreFile="conf/localhost-rsa.jks"
                         type="RSA" />
        </SSLHostConfig>
 </Connector>

और हम अपना कॉन्फ़िगरेशन उनके आगे रखते हैं:

<Connector
       protocol="org.apache.coyote.http11.Http11NioProtocol"
       port="8443" maxThreads="200"
       scheme="https" secure="true" SSLEnabled="true"
       keystoreFile="C:\Users\user\.keystore" keystorePass="mypass"
       clientAuth="false" sslProtocol="TLS"/>

हम keystoreFile और keystorePass मापदंडों के लिए नवीनतम मान निर्दिष्ट करते हैं, फ़ाइल को सहेजते हैं, और फिर शटडाउन.बैट और स्टार्टअप.बैट फ़ाइलों का उपयोग करके टॉमकैट को पुनरारंभ करते हैं। अब सर्वर HTTPS अनुरोधों को प्रोसेस करने के लिए तैयार है। पता थोड़ा सा बदल गया है: https://localhost:8443/demo/hello । जब आप लिंक पर क्लिक करते हैं तो आपको प्रमाण पत्र की विश्वसनीयता के बारे में एक चेतावनी प्राप्त होगी, जो आश्चर्यजनक नहीं है। जैसा कि हमने कुछ पहले कहा था, सामान्य प्रमाणपत्र प्राप्त करने के लिए आपको प्रमाणन प्राधिकरणों में से किसी एक की सेवाओं का उपयोग करने की आवश्यकता है। लेकिन अभी के लिए, हमने अपना लक्ष्य प्राप्त कर लिया है: एप्लिकेशन HTTPS प्रोटोकॉल का उपयोग करके चलता है, और यह महत्वपूर्ण है!

गतिशील रूप से HTML पृष्ठ उत्पन्न करना

अब हम एक अन्य विशेषता पर विचार करके सर्वलेट कंटेनरों का अवलोकन जारी रखेंगे: HTML पृष्ठों की गतिशील पीढ़ी। एक संपूर्ण दुनिया की कल्पना करें, जहां स्थिर HTML कोड को उबाऊ करने के बजाय, आप चर, लूप, सरणियों और अन्य भाषा निर्माणों का उपयोग करके जावा कोड लिख सकते हैं। क्या आप इसकी कल्पना कर पाए थे? अच्छी खबर यह है कि कुछ ऐसा ही मौजूद है। बुरी खबर यह है कि यह पूरी तरह से इस कल्पना को हासिल नहीं करता है। यदि आपने अनुमान नहीं लगाया है, तो हम JavaServer Pages (JSP) के बारे में बात कर रहे हैं। संक्षेप में, यह एक ऐसी तकनीक है जो आपको HTML पेज में जावा कोड के टुकड़े डालने देती है। सच है, क्लाइंट को भेजे जाने से पहले यह जावा कोड अभी भी HTML में परिवर्तित हो गया है, लेकिन यह HTML विभिन्न कारकों को ध्यान में रखते हुए गतिशील रूप से उत्पन्न होगा। उदाहरण के लिए, आप सशर्त बयानों का उपयोग कर सकते हैं और कुछ शर्तों के आधार पर अलग-अलग सामग्री वापस कर सकते हैं। उदाहरण जेएसपी पेज:

<%@ page language="java"" %>
<html>
<head>
<title>JSP</title>
</head>

<body>
<%
String firstName="name";
String secondName="surname";

    if (firstName.equals("name")){
      out.print("Hello: "+firstName+"<br>");
    }

    if (firstName.equals("name") && secondName.equals("surname"))
    {
      out.print("Hello, my dear friend! <br>");
    }
    else
    {
      out.print("I don't know you. Go away! <br>");
    }
%>
</body>
</html>

आप यहां जेएसपी के बारे में अधिक पढ़ सकते हैं. दिन के अंत में, यह लेख JSP के बारे में नहीं है - हम यहाँ सर्वलेट कंटेनरों के बारे में बात करने के लिए हैं! तो हमने जेएसपी का जिक्र क्यों किया? यह सरल है: एक सर्वलेट कंटेनर वह है जो जावा कोड को JSP से HTML में परिवर्तित करता है। जब एक सर्वलेट एक प्रतिक्रिया के रूप में जेएसपी सामग्री वापस करने जा रहा है, तो कंटेनर ध्यान देता है और क्लाइंट को ऐसी सामग्री भेजने से पहले इसे ब्राउज़र-अनुकूल HTML पृष्ठ में परिवर्तित करता है। आज, जेएसपी प्रौद्योगिकी के कई अनुरूप हैं - थाइमेलीफ, फ्रीमार्केट, मूंछ और अन्य। वे सभी इसी तरह काम करते हैं। उनमें से किसे अपने काम के लिए चुनना है यह स्वाद का विषय है। यह सर्वलेट कंटेनर चुनने पर भी लागू होता है। इन उदाहरणों में, हमने सबसे आम कंटेनर टोमकैट का इस्तेमाल किया, लेकिन कुछ प्रोजेक्ट अन्य कंटेनरों का इस्तेमाल करते हैं। यह सबसे लोकप्रिय लोगों की संक्षिप्त समीक्षा करने और विचार करने के लायक है कि वे टॉमकैट से कैसे भिन्न हैं।

टॉमकैट के विकल्प

1. ग्लासफिश एक ओपन सोर्स कंटेनर है जिसका विकास ओरेकल द्वारा समर्थित है।

   टोमकैट के विपरीत, यह एक पूर्ण वेब सर्वर है, जो सर्वलेट्स के अलावा, जावाईई ढांचे से अन्य घटकों के साथ काम कर सकता है। उस ने कहा, यह बहुत अधिक RAM का उपयोग करता है। सर्वर को फ़ाइन-ट्यूनिंग करते समय अधिक लचीलापन होता है, जो इसके उपयोग को जटिल बनाता है। JavaEE ढांचे पर एप्लिकेशन विकसित करते समय इसका उपयोग किया जाना चाहिए।

2. WildFly को पहले JBoss के नाम से जाना जाता था । यह ओपन सोर्स भी है। यह रेड हैट द्वारा विकसित किया गया है। कंपनी के उत्पादों में से एक - JBoss Enterprise Application Platform के साथ भ्रम से बचने के लिए नाम बदल दिया गया था।

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

3. जेट्टी , पिछले वाले की तरह, खुला स्रोत है। इसे एक्लिप्स द्वारा विकसित किया गया है।

   टॉमकैट की तरह, यह जावाईई ढांचे के सभी घटकों के समर्थन के बिना एक सरल सर्वलेट कंटेनर है। साथ ही, यह अधिक हल्का है और इसे मोबाइल फोन पर भी चलाया जा सकता है। यह शुरू होता है और जल्दी बंद हो जाता है और अच्छी तरह से बढ़ता है। टॉमकैट के विपरीत, इसका एक छोटा समुदाय और ज्ञान का आधार है।

4. WebLogic लाइसेंस प्राप्त सॉफ़्टवेयर है जिसे उपयोग करने से पहले खरीदा जाना चाहिए। यह ओरेकल के अंतर्गत आता है।

   टॉमकैट की तुलना में इसकी थोड़ी व्यापक कार्यक्षमता है। यह FTP प्रोटोकॉल के साथ काम कर सकता है। लेकिन अनुप्रयोगों का विकास और परीक्षण करते समय यह इतना लचीला नहीं होता है।

5. WebSphere (WebSphere Application Server, सटीक होने के लिए) सशुल्क सॉफ़्टवेयर है। यह आईबीएम द्वारा विकसित किया गया है। WildFly और GlassFish के समान, यह एक पूर्ण अनुप्रयोग सर्वर है। लेकिन इसमें एक मित्रवत कॉन्फ़िगरेशन इंटरफ़ेस है, साथ ही संचालन में उच्च विश्वसनीयता है।

   इसकी कमियों में यह तथ्य शामिल है कि यह बहुत सारे संसाधनों का उपयोग करता है और शुरू और बंद होने में लंबा समय लेता है, जो छोटी परियोजनाओं को विकसित करते समय बहुत सुविधाजनक नहीं होता है।

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