பகுதி 6. சர்வ்லெட் கொள்கலன்கள்

இந்த பொருள் "நிறுவன மேம்பாட்டிற்கான அறிமுகம்" தொடரின் ஒரு பகுதியாகும். முந்தைய கட்டுரைகள்:

• நெட்வொர்க்கிங் பற்றி
• மென்பொருள் கட்டமைப்பு பற்றி
• HTTP/HTTPS பற்றி
• மேவனின் அடிப்படைகள் பற்றி
• சர்வ்லெட்டுகளைப் பற்றி (எளிய இணைய பயன்பாட்டை எழுதுதல்)

கடந்த கட்டுரையில், நாங்கள் சர்வ்லெட்டுகளுடன் பழகினோம் மற்றும் இணைய பயன்பாடுகளை உருவாக்க அவற்றை எவ்வாறு பயன்படுத்துவது என்பதைக் கற்றுக்கொண்டோம். இந்த வேடிக்கையின் இன்றியமையாத பகுதியைக் கூர்ந்து கவனிக்க வேண்டிய நேரம் வந்துவிட்டது: சர்வ்லெட் கொள்கலன்கள்.

உள்ளடக்க அட்டவணை:

• சர்வ்லெட் கொள்கலன் என்றால் என்ன?
• சர்வ்லெட் கொள்கலன்கள் எவ்வாறு பயன்படுத்தப்படுகின்றன?
• டாம்கேட்டை நிறுவுதல் மற்றும் தொடங்குதல்
• டாம்கேட்டில் ஒரு பயன்பாட்டைப் பயன்படுத்துதல்
• HTTPக்குப் பதிலாக HTTPS ஐப் பயன்படுத்துதல்
• ஒரு சான்றிதழை உருவாக்குதல்
• சேவையகத்தை கட்டமைக்கிறது
• HTML பக்கங்களை மாறும் வகையில் உருவாக்குகிறது
• Tomcat க்கு மாற்று

சர்வ்லெட் கொள்கலன் என்றால் என்ன?

இது ஒரு சர்வரில் இயங்கும் ஒரு நிரல் மற்றும் நாம் உருவாக்கிய சர்வ்லெட்டுகளுடன் தொடர்பு கொள்ள முடியும். வேறு வார்த்தைகளில் கூறுவதானால், ஒரு சர்வரில் எங்கள் வலை பயன்பாட்டை இயக்க விரும்பினால், முதலில் ஒரு சர்வ்லெட் கொள்கலனை வரிசைப்படுத்துவோம், பின்னர் அதில் சர்வ்லெட்டுகளை வைப்போம். பணிப்பாய்வு எளிதானது: கிளையன்ட் சேவையகத்தை அணுகும்போது, ​​கொள்கலன் அதன் கோரிக்கையைச் செயல்படுத்துகிறது, எந்த சர்வ்லெட் அதைச் செயல்படுத்த வேண்டும் என்பதைத் தீர்மானித்து, கோரிக்கையை அனுப்புகிறது.

சர்வ்லெட் கொள்கலன்கள் எவ்வாறு பயன்படுத்தப்படுகின்றன?

ரூட்டிங் கோரிக்கைகளுக்கு கூடுதலாக, ஒரு சர்வ்லெட் கொள்கலன் மற்ற செயல்பாடுகளை செய்கிறது:

1. இது JSP கோப்புகளிலிருந்து HTML பக்கங்களை மாறும் வகையில் உருவாக்குகிறது.
2. இது HTTPS செய்திகளை என்க்ரிப்ட்/டிக்ரிப்ட் செய்கிறது.
3. இது சர்வ்லெட் நிர்வாகத்திற்கு கட்டுப்படுத்தப்பட்ட அணுகலை வழங்குகிறது.

பொதுவாக, இவை அனைத்தும் நன்றாக இருக்கும். இதையெல்லாம் எப்படி நடைமுறைப்படுத்துவது என்பதை இப்போது நாம் கண்டுபிடிக்க வேண்டும். சரி, எதையாவது எப்படிப் பயன்படுத்துவது என்பதை அறிய, உள்ளே நுழைந்து அதைப் பயன்படுத்த முயற்சிக்கவும் :) எனவே, இன்று நாம் பயிற்சி செய்யப் போகிறோம்! மிகவும் பிரபலமான சர்வ்லெட் கொள்கலன் Apache Tomcat ஆகும் . இது திறந்த மூலமானது மற்றும் இலவசமாகப் பயன்படுத்தப்படலாம். உங்கள் ஆப்பரேட்டிங் சிஸ்டத்திற்கான டாம்கேட்டை இங்கே பதிவிறக்கவும் , "செயல்பாட்டில்" உள்ள கொள்கலன்களுடன் பணிபுரிவதை நாங்கள் ஆராய்வோம்.

டாம்கேட்டை நிறுவுதல் மற்றும் தொடங்குதல்

1. டாம்கேட்டை நிறுவ, பதிவிறக்கம் செய்யப்பட்ட காப்பகத்தை விரும்பிய கோப்பகத்தில் அன்சிப் செய்யவும்.

2. Tomcat க்கு Java பதிப்பு 8 அல்லது அதற்குப் பிந்தைய பதிப்பு தேவை என்பதை நினைவில் கொள்ளவும். JAVA_HOME சூழல் மாறி JDK இன் தற்போதைய பதிப்பைக் குறிப்பிடுகிறது என்பதைச் சரிபார்க்கவும்.

3. அடுத்து, நீங்கள் Tomcat க்கு பயனர் அணுகலை உள்ளமைக்க வேண்டும் . இது conf கோப்புறையில் அமைந்துள்ள tomcat-users.xml கோப்பில் செய்யப்படுகிறது.

   டாம்கேட்டில் நான்கு முன்னமைக்கப்பட்ட பாத்திரங்கள் உள்ளன:

   • manager-gui — வரைகலை இடைமுகம் மற்றும் நிலைப் பக்கத்திற்கான அணுகல்
   • manager-script — உரை இடைமுகம் மற்றும் நிலைப் பக்கத்திற்கான அணுகல்
   • manager-jmx — JMX மற்றும் நிலைப் பக்கத்திற்கான அணுகல்
   • மேலாளர்-நிலை - நிலைப் பக்கத்திற்கு மட்டுமே அணுகல்

   <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. பின் கோப்புறையில், startup.bat கோப்பை (லினக்ஸில் startup.sh) இயக்கவும்.

5. சில வினாடிகளுக்குப் பிறகு, உங்கள் உலாவியில் http://localhost:8080/ இணைப்பைத் திறக்கவும் . நீங்கள் ஒரு வரைகலை டாஷ்போர்டைக் காண்பீர்கள்:

   இது போன்ற மெனுவைப் பார்த்தால், டாம்கேட் இயங்குகிறது.

6. இது இயங்கவில்லை என்றால், JAVA_HOME மற்றும் CATALINA_HOME சூழல் மாறிகளை கைமுறையாகச் சரிபார்க்கவும்:

   • JAVA_HOME — இது ஜாவா 8+ இன் தற்போதைய பதிப்பைக் குறிப்பிட வேண்டும்.
   • CATALINA_BASE — இது Tomcat ஐக் குறிப்பிட வேண்டும் அல்லது இல்லாமல் இருக்க வேண்டும் (Tomcat இன் மற்றொரு பதிப்பைக் குறிப்பிடக்கூடாது).

டாம்கேட்டில் ஒரு பயன்பாட்டைப் பயன்படுத்துதல்

நாங்கள் டாம்கேட்டைத் தொடங்க முடிந்தது, எனவே அதில் சில திட்டத்தைப் பயன்படுத்துவதற்கான நேரம் இது. முந்தைய கட்டுரையில் உள்ள சர்வ்லெட்டுகளைப் பயன்படுத்துவோம் . முதன்மை சேவையகம்:

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();
   }
}

IndexServlet:

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 கோப்பில் தொகுக்க வேண்டும். Maven பொதுவாக இதைச் செய்யப் பயன்படுகிறது, ஆனால் ஒரு WAR கோப்பை உருவாக்க உங்களுக்கு web.xml கோப்பு தேவை, அதில் அனைத்து சர்வ்லெட்டுகளுக்கும் மேப்பிங் உள்ளது. சர்வ்லெட்டுகளை எழுத புதிய @WebServlet சிறுகுறிப்பைப் பயன்படுத்தினோம், எனவே எங்களிடம் web.xml கோப்பு இல்லை. அதிர்ஷ்டவசமாக, IDEA எங்களுக்காக மோசமான வேலையைச் செய்ய முடியும், எங்கள் திட்டத்தை ஒரு WAR கோப்பில் மூடுகிறது. இதைச் செய்ய, திட்ட கட்டமைப்பைத் திறக்கவும் (Ctrl+Shift+Alt+S) -> கலைப்பொருட்கள் -> விரும்பிய WAR கோப்பைத் தேர்ந்தெடுக்கவும் -> "திட்டக் கட்டமைப்பில் சேர்" என்பதற்கு அடுத்துள்ள தேர்வுப்பெட்டியைத் தேர்ந்தெடுக்கவும் -> "சரி" என்பதைக் கிளிக் செய்யவும். Ctrl+F9 விசை கலவையைப் பயன்படுத்தி திட்டத்தை உருவாக்குவோம். இப்போது எங்கள் WAR கோப்பு இலக்கு கோப்பகத்தில் உள்ளது, கோப்பை எளிமையானதாக மாற்றலாம், எ.கா. servlet.war, மேலும் வசதியான இடத்திற்கு நகர்த்தலாம், எ.கா. C:\\my\\.நாங்கள் அதை ஒரு கொள்கலனில் வைப்போம் . இதற்கு இரண்டு வழிகள் உள்ளன.

1. வரைகலை இடைமுகத்தைப் பயன்படுத்துதல்

   இதைச் செய்ய, இந்த இணைப்பைப் பின்தொடரவும்: http://localhost:8080/manager/html . Tomcat ஒரு பயனர் பெயர் மற்றும் கடவுச்சொல்லை கேட்க வேண்டும்.

   இது வரை என்னுடன் நீங்கள் பின்தொடர்ந்திருந்தால், பயனர் பெயர் "பயனர்" மற்றும் கடவுச்சொல் "கடவுச்சொல்" ஆகும் .

   வெற்றிகரமாக உள்நுழைந்த பிறகு, Tomcat Web Application Managerஐப் பார்ப்பீர்கள். "பயன்பாடுகள்" பிரிவில் ஏற்கனவே 5 பயன்பாடுகள் உள்ளன - இவை Tomcat பயன்பாடுகள், இது Tomcat உடன் வேலை செய்வதை எளிதாக்குகிறது. அவை எதிர்காலத்தில் நீக்கப்படலாம்.

   கீழே "வரிசைப்படுத்து" பகுதி உள்ளது. வரிசைப்படுத்துவதற்கு இங்கே நீங்கள் WAR காப்பகத்தைத் தேர்ந்தெடுக்கலாம். பாதை மற்றும் சூழலை கைமுறையாக உள்ளிடுவோம்:

   "வரிசைப்படுத்து" என்பதைக் கிளிக் செய்யவும், எங்கள் பயன்பாடு "பயன்பாடுகள்" பிரிவில் தோன்றியிருப்பதைக் காண்கிறோம்:

   Tomcat இன் வரைகலை இடைமுகத்தைப் பயன்படுத்தி, அமர்வை நிறுத்தலாம், மறுதொடக்கம் செய்யலாம் மற்றும் நீக்கலாம், அத்துடன் அமர்வு நீளத்தை அமைக்கலாம். வரிசைப்படுத்தும் போது, ​​நாங்கள் /டெமோ சூழலைக் குறிப்பிட்டோம், அதாவது எங்கள் பயன்பாடு http://localhost:8080/demo ஐப் பயன்படுத்தி அணுகப்படுகிறது . பரிசோதித்து பார். எல்லாம் வேலை செய்ய வேண்டும்.

2. கோப்பு முறைமை மூலம்

   இந்த வழியில் பயன்பாட்டை வரிசைப்படுத்த, நீங்கள் டாம்கேட் அன்ஜிப் செய்யப்பட்ட கோப்பகத்தைத் திறக்க வேண்டும். பின்னர் "webapps" கோப்புறைக்குச் செல்லவும். நாங்கள் ஏற்கனவே சந்தித்த பயன்பாடுகளை இங்கே காணலாம்:

   நமது servlet.war கோப்பை இங்கு நகர்த்துவது மட்டுமே தேவை.

   நாங்கள் சில வினாடிகள் காத்திருந்து, ஒரு புதிய "servlet" கோப்புறை தோன்றியதைக் காண்கிறோம். இதன் பொருள் எங்கள் பயன்பாடு பயன்படுத்தப்பட்டது. http://localhost:8080/manager/ இல் உள்ள பயன்பாட்டு மேலாளர் இடைமுகத்திற்குச் செல்லவும் . எங்கள் பயன்பாடு /servlet சூழலில் பயன்படுத்தப்படுவதை இங்கே காண்கிறோம்:

   இந்த வழியில் பயன்படுத்தப்படும்போது, ​​பயன்படுத்தப்பட்ட WAR கோப்பின் பெயரின் அடிப்படையில் சூழல் தானாகவே ஒதுக்கப்படும். சூழலை மாற்ற, பயன்பாட்டைக் கொண்ட புதிதாக உருவாக்கப்பட்ட கோப்புறையை மறுபெயரிடலாம், ஆனால் அதைச் செய்வதற்கு முன் நீங்கள் WAR கோப்பை அகற்ற வேண்டும். இல்லையெனில், Tomcat காப்பகப் பெயருடன் விண்ணப்பத்தை மீண்டும் வரிசைப்படுத்தும்.

   நீங்கள் பார்க்க முடியும் என, டாம்கேட்டில் பயன்பாடுகளை வரிசைப்படுத்துவது தோன்றுவதை விட மிகவும் எளிதானது. ஆனால் அதன் மற்ற செயல்பாடுகளும் பயன்படுத்த எளிதானது. சரிபார்ப்போம்.

HTTPக்குப் பதிலாக HTTPS ஐப் பயன்படுத்துதல்

உங்களுக்கு நினைவிருந்தால், HTTP மற்றும் HTTPS இடையே உள்ள வித்தியாசத்தை ஒரு தனி கட்டுரையில் பார்த்தோம் . HTTPS என்பது HTTP போன்ற அதே நெறிமுறையாகும், ஆனால் இது அனுப்பப்படும் தரவை குறியாக்குகிறது. கிளையன்ட் பக்கத்தில், குறியாக்கத்திற்கு உலாவி பொறுப்பாகும், ஆனால் நாங்கள் சர்வர் பக்கத்தில் குறியாக்கத்தை வழங்க வேண்டும். Tomcat HTTP கோரிக்கைகளை ஏற்று வழியமைப்பதால், அதற்கு குறியாக்கத்தை வழங்குவது அர்த்தமுள்ளதாக இருக்கும். இதைச் செய்ய, நாம் கண்டிப்பாக:

1. சுய கையொப்பமிடப்பட்ட சான்றிதழை உருவாக்கவும்
2. கூடுதல் சேவையக அமைப்புகளை உருவாக்கவும்

இதை செய்து பழகுவோம்.

ஒரு சான்றிதழை உருவாக்குதல்

பதிப்பைப் பொருட்படுத்தாமல், JDK அதிக எண்ணிக்கையிலான பயன்பாடுகளை உள்ளடக்கியது. அவற்றில் ஒன்று கீடூல் . இது குறியாக்க விசைகளை உருவாக்குவதற்கும் வேலை செய்வதற்கும் ஒரு கருவியாகும். இதைப் பயன்படுத்த, கட்டளை வரியில், C:\\Program Files\\Java\\jdk1.8.0_181\\bin கோப்பகத்திற்குச் சென்று, keytool -genkey -alias tomcat -keyalg RSA கட்டளையை இயக்கவும் .

• keytool — கட்டளை வரி விருப்பங்களுடன் நாம் இயங்கும் பயன்பாட்டின் பெயர்
• -genkey — நாம் ஒரு புதிய விசையை உருவாக்க விரும்புகிறோம் என்பதைக் குறிக்கவும்
• -alias tomcat — ஒரு முக்கிய மாற்றுப்பெயரை உருவாக்கவும்
• -keyalg RSA — முக்கிய தலைமுறை வழிமுறையாக RSA ஐ தேர்ந்தெடுக்கவும்

கட்டளையை இயக்கிய பிறகு, பயன்பாடு எங்களுடன் ஒரு உரையாடலைத் தொடங்குகிறது: தேவையான தகவலை உள்ளிடவும். இப்போது எங்கள் ஹோம் டைரக்டரியில் ஒரு கீஸ்டோரையும் (விண்டோஸுக்கு, இது C:\\Users\\{username}\\.keystore) மற்றும் அதில் ஒரு டாம்கேட் கீயையும் உருவாக்கியுள்ளோம். பெரும்பாலான உலாவிகள் புகார் செய்யும் எளிய சான்றிதழை நாங்கள் உருவாக்கியுள்ளோம். அத்தகைய சான்றிதழ் வணிக பயன்பாடுகளுக்கு ஏற்றது அல்ல: இது சோதனை நோக்கங்களுக்காக மட்டுமே பயன்படுத்தப்படும். உற்பத்திச் சேவையகத்தில், நீங்கள் ஒரு சான்றிதழின் சான்றிதழைப் பயன்படுத்த வேண்டும் (எடுத்துக்காட்டாக, https://letsencrypt.org/ ).

சேவையகத்தை கட்டமைக்கிறது

இப்போது சான்றிதழ் தயாராக உள்ளது, நாங்கள் சேவையக அமைப்புகளை சரிசெய்ய வேண்டும், அதாவது SSL இணைப்பான். இது apache-tomcat-9.0.30/conf/ இல் அமைந்துள்ள server.xml கோப்பில் செய்யப்படுகிறது . அதில், இது போன்ற தொகுதிகளைக் காண்கிறோம்:

<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 அளவுருக்களுக்கு ஒதுக்கி, கோப்பைச் சேமித்து, பின்னர் shutdown.bat மற்றும் startup.bat கோப்புகளைப் பயன்படுத்தி Tomcat ஐ மறுதொடக்கம் செய்கிறோம். இப்போது சேவையகம் HTTPS கோரிக்கைகளைச் செயல்படுத்த தயாராக உள்ளது. முகவரி சிறிது மாறிவிட்டது: https://localhost:8443/demo/hello . நீங்கள் இணைப்பைக் கிளிக் செய்தால், சான்றிதழின் நம்பகத்தன்மை பற்றிய எச்சரிக்கையைப் பெறுவீர்கள், இது ஆச்சரியமல்ல. நாங்கள் சற்று முன்பு கூறியது போல், சாதாரண சான்றிதழைப் பெற நீங்கள் சான்றிதழ் அதிகாரிகளில் ஒருவரின் சேவைகளைப் பயன்படுத்த வேண்டும். ஆனால் இப்போதைக்கு, நாங்கள் எங்கள் இலக்கை அடைந்துவிட்டோம்: பயன்பாடு HTTPS நெறிமுறையைப் பயன்படுத்தி இயங்குகிறது, அது முக்கியமானது!

HTML பக்கங்களை மாறும் வகையில் உருவாக்குகிறது

இப்போது மற்றொரு அம்சத்தைக் கருத்தில் கொண்டு சர்வ்லெட் கொள்கலன்களின் மேலோட்டப் பார்வையைத் தொடர்வோம்: HTML பக்கங்களின் மாறும் தலைமுறை. சலிப்பான நிலையான HTML குறியீட்டிற்குப் பதிலாக, மாறிகள், சுழல்கள், அணிவரிசைகள் மற்றும் பிற மொழிக் கட்டமைப்பைப் பயன்படுத்தி ஜாவா குறியீட்டை எழுதக்கூடிய சரியான உலகத்தை கற்பனை செய்து பாருங்கள். உங்களால் கற்பனை செய்ய முடிந்ததா? நல்ல செய்தி என்னவென்றால், இதே போன்ற ஒன்று உள்ளது. மோசமான செய்தி என்னவென்றால், இது இந்த கற்பனையை முழுமையாக அடையவில்லை. நீங்கள் யூகிக்கவில்லை என்றால், நாங்கள் JavaServer Pages (JSP) பற்றி பேசுகிறோம். சுருக்கமாக, இது ஒரு HTML பக்கத்தில் ஜாவா குறியீட்டின் துண்டுகளைச் செருக அனுமதிக்கும் தொழில்நுட்பமாகும். உண்மை, இந்த ஜாவா குறியீடு கிளையண்டிற்கு அனுப்பப்படுவதற்கு முன்பே HTML ஆக மாற்றப்படுகிறது, ஆனால் அந்த HTML பல்வேறு காரணிகளை கணக்கில் எடுத்துக்கொண்டு மாறும் வகையில் உருவாக்கப்படும். உதாரணத்திற்கு, நீங்கள் நிபந்தனை அறிக்கைகளைப் பயன்படுத்தலாம் மற்றும் சில நிபந்தனைகளைப் பொறுத்து வெவ்வேறு உள்ளடக்கத்தை வழங்கலாம். எடுத்துக்காட்டு JSP பக்கம்:

<%@ 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 ஆக மாற்றுகிறது. ஒரு சர்வ்லெட் JSP உள்ளடக்கத்தை பதிலளிப்பதாக மாற்றப் போகும் போது, ​​கொள்கலன் குறிப்பு எடுத்து, கிளையண்டிற்கு அத்தகைய உள்ளடக்கத்தை அனுப்பும் முன் அதை உலாவிக்கு ஏற்ற HTML பக்கமாக மாற்றும். இன்று, JSP தொழில்நுட்பத்திற்கு பல ஒப்புமைகள் உள்ளன - Thymeleaf, FreeMarket, மீசை மற்றும் பிற. அவர்கள் அனைவரும் ஒரே மாதிரியாக வேலை செய்கிறார்கள். அவற்றில் எது உங்கள் வேலைக்குத் தேர்வு செய்வது என்பது ரசனைக்குரிய விஷயம். சர்வ்லெட் கொள்கலனைத் தேர்ந்தெடுப்பதற்கும் இது பொருந்தும். இந்த எடுத்துக்காட்டுகளில், நாங்கள் மிகவும் பொதுவான கொள்கலனான Tomcat ஐப் பயன்படுத்தினோம், ஆனால் சில திட்டங்கள் மற்ற கொள்கலன்களைப் பயன்படுத்துகின்றன. மிகவும் பிரபலமானவற்றை சுருக்கமாக மதிப்பாய்வு செய்து அவை டாம்காட்டிலிருந்து எவ்வாறு வேறுபடுகின்றன என்பதைக் கருத்தில் கொள்வது பயனுள்ளது.

Tomcat க்கு மாற்று

1. கிளாஸ்ஃபிஷ் என்பது ஒரு திறந்த மூல கொள்கலன் ஆகும், அதன் வளர்ச்சியை ஆரக்கிள் ஆதரிக்கிறது.

   Tomcat போலல்லாமல், இது ஒரு முழு அளவிலான இணைய சேவையகம், இது servlets தவிர, JavaEE கட்டமைப்பிலிருந்து பிற கூறுகளுடன் செயல்பட முடியும். இது அதிக ரேம் பயன்படுத்துகிறது என்று கூறினார். சேவையகத்தை நன்றாகச் சரிசெய்யும்போது அதிக நெகிழ்வுத்தன்மை உள்ளது, இது அதன் பயன்பாட்டை சிக்கலாக்குகிறது. JavaEE கட்டமைப்பில் பயன்பாடுகளை உருவாக்கும்போது இது பயன்படுத்தப்பட வேண்டும்.

2. WildFly முன்பு JBoss என்று அழைக்கப்பட்டது . இது திறந்த மூலமாகவும் உள்ளது. இது Red Hat ஆல் உருவாக்கப்பட்டது. நிறுவனத்தின் தயாரிப்புகளில் ஒன்றான JBoss Enterprise அப்ளிகேஷன் பிளாட்ஃபார்முடன் குழப்பத்தைத் தவிர்க்க பெயர் மாற்றப்பட்டது.

   GlassFish ஐப் போலவே, WildFly ஒரு முழு அளவிலான இணைய சேவையகம். தற்செயலாக, ஹூட்டின் கீழ், வைல்ட்ஃபிளை டாம்கேட்டை சர்வ்லெட் கொள்கலனாகப் பயன்படுத்துகிறது. GlassFish போலல்லாமல், WildFly மிகவும் இலகுவானது மற்றும் கட்டமைக்க எளிதானது.

3. ஜெட்டி , முந்தையதைப் போலவே, திறந்த மூலமாகும். இது கிரகணத்தால் உருவாக்கப்பட்டது.

   டாம்கேட்டைப் போலவே, இது ஒரு எளிய சர்வ்லெட் கொள்கலன் ஆகும், இது JavaEE கட்டமைப்பின் அனைத்து கூறுகளுக்கும் ஆதரவு இல்லாமல் உள்ளது. அதே நேரத்தில், இது மிகவும் இலகுவானது மற்றும் மொபைல் போனில் கூட இயக்க முடியும். இது விரைவாகத் தொடங்குகிறது மற்றும் நிறுத்துகிறது மற்றும் நன்றாக அளவிடுகிறது. டாம்கேட் போலல்லாமல், இது ஒரு சிறிய சமூகம் மற்றும் அறிவுத் தளத்தைக் கொண்டுள்ளது.

4. WebLogic என்பது உரிமம் பெற்ற மென்பொருளாகும், அதைப் பயன்படுத்துவதற்கு முன்பு வாங்க வேண்டும். இது ஆரக்கிளுக்கு சொந்தமானது.

   இது Tomcat ஐ விட சற்று பரந்த செயல்பாட்டைக் கொண்டுள்ளது. இது FTP நெறிமுறையுடன் வேலை செய்ய முடியும். ஆனால் அப்ளிகேஷன்களை உருவாக்கி சோதனை செய்யும் போது அது அவ்வளவு நெகிழ்வாக இருக்காது.

5. வெப்ஸ்பியர் (வெப்ஸ்பியர் அப்ளிகேஷன் சர்வர், துல்லியமாகச் சொல்வதானால்) கட்டண மென்பொருளாகும். இது ஐபிஎம் நிறுவனத்தால் உருவாக்கப்பட்டது. WildFly மற்றும் GlassFish ஐப் போலவே, இது ஒரு முழுமையான பயன்பாட்டு சேவையகம். ஆனால் இது ஒரு நட்பு கட்டமைப்பு இடைமுகம் மற்றும் செயல்பாட்டில் அதிக நம்பகத்தன்மை கொண்டது.

   அதன் குறைபாடுகளில் இது நிறைய வளங்களைப் பயன்படுத்துகிறது மற்றும் தொடங்குவதற்கும் நிறுத்துவதற்கும் நீண்ட நேரம் எடுக்கும், இது சிறிய திட்டங்களை உருவாக்கும் போது மிகவும் வசதியாக இல்லை.

சரியான சர்வ்லெட் கொள்கலன் அல்லது பயன்பாட்டு சேவையகத்தின் தேர்வு குறிப்பிட்ட திட்டத்தைப் பொறுத்தது. ஒரு தெளிவான பின்தங்கிய நிலை கூட ஒரு சிறந்த தேர்வாக நிரூபிக்கப்படும் திட்டங்கள் உள்ளன, ஆனால் முதலில் ஒரு சர்வ்லெட் கொள்கலனை ஆழமாக ஆய்வு செய்வது சிறந்தது. இந்த ஆய்வுக்கு டாம்கேட் சரியான வேட்பாளர். அதைப் படிப்பதில் நாங்கள் ஏற்கனவே முதல் படிகளை எடுத்துவிட்டோம், ஆனால் இங்கிருந்து அது உங்களுடையது! "எண்டர்பிரைஸ் மேம்பாட்டிற்கான அறிமுகம்" தொடரின் இறுதிக் கட்டுரைகளில், MVC வடிவத்தை நாம் அறிந்து கொள்வோம். பகுதி 7. MVC (மாடல்-வியூ-கண்ட்ரோலர்) வடிவத்தை அறிமுகப்படுத்துதல்