పార్ట్ 6. సర్వ్లెట్ కంటైనర్లు

ఈ మెటీరియల్ "ఇంట్రడక్షన్ టు ఎంటర్‌ప్రైజ్ డెవలప్‌మెంట్" సిరీస్‌లో భాగం. మునుపటి కథనాలు:

• నెట్‌వర్కింగ్ గురించి
• సాఫ్ట్‌వేర్ ఆర్కిటెక్చర్ గురించి
• HTTP/HTTPS గురించి
• మావెన్ యొక్క ప్రాథమిక విషయాల గురించి
• సర్వ్లెట్ల గురించి (ఒక సాధారణ వెబ్ అప్లికేషన్ రాయడం)

గత వ్యాసంలో, మేము సర్వ్‌లెట్‌లతో పరిచయం పొందాము మరియు వెబ్ అప్లికేషన్‌లను రూపొందించడానికి వాటిని ఎలా ఉపయోగించాలో నేర్చుకున్నాము. ఈ సరదాలో ముఖ్యమైన భాగాన్ని నిశితంగా పరిశీలించాల్సిన సమయం ఆసన్నమైంది: సర్వ్‌లెట్ కంటైనర్‌లు.

విషయ సూచిక:

• సర్వ్లెట్ కంటైనర్ అంటే ఏమిటి?
• సర్వ్లెట్ కంటైనర్లు ఎలా ఉపయోగించబడతాయి?
• టామ్‌క్యాట్‌ని ఇన్‌స్టాల్ చేయడం మరియు ప్రారంభించడం
• టామ్‌క్యాట్‌లో అప్లికేషన్‌ని అమలు చేస్తోంది
• HTTPకి బదులుగా HTTPSని ఉపయోగించడం
• సర్టిఫికేట్‌ను రూపొందిస్తోంది
• సర్వర్‌ని కాన్ఫిగర్ చేస్తోంది
• డైనమిక్‌గా HTML పేజీలను రూపొందించడం
• టామ్‌క్యాట్‌కి ప్రత్యామ్నాయాలు

సర్వ్లెట్ కంటైనర్ అంటే ఏమిటి?

ఇది సర్వర్‌లో రన్ అయ్యే ప్రోగ్రామ్ మరియు మేము సృష్టించిన సర్వ్‌లెట్‌లతో పరస్పర చర్య చేయగలదు. మరో మాటలో చెప్పాలంటే, మేము మా వెబ్ అప్లికేషన్‌ను సర్వర్‌లో అమలు చేయాలనుకుంటే, మేము మొదట సర్వర్‌లెట్ కంటైనర్‌ను అమలు చేసి, ఆపై అందులో సర్వ్‌లెట్‌లను ఉంచుతాము. వర్క్‌ఫ్లో సులభం: క్లయింట్ సర్వర్‌ని యాక్సెస్ చేసినప్పుడు, కంటైనర్ దాని అభ్యర్థనను ప్రాసెస్ చేస్తుంది, ఏ సర్వ్‌లెట్‌ని ప్రాసెస్ చేయాలో నిర్ణయిస్తుంది, ఆపై అభ్యర్థనను పాస్ చేస్తుంది.

సర్వ్లెట్ కంటైనర్లు ఎలా ఉపయోగించబడతాయి?

రూటింగ్ అభ్యర్థనలతో పాటు, సర్వ్లెట్ కంటైనర్ ఇతర విధులను నిర్వహిస్తుంది:

1. ఇది డైనమిక్‌గా JSP ఫైల్‌ల నుండి HTML పేజీలను ఉత్పత్తి చేస్తుంది.
2. ఇది HTTPS సందేశాలను గుప్తీకరిస్తుంది/డీక్రిప్ట్ చేస్తుంది.
3. ఇది సర్వ్లెట్ అడ్మినిస్ట్రేషన్ కోసం పరిమితం చేయబడిన యాక్సెస్‌ను అందిస్తుంది.

సాధారణంగా, ఇదంతా బాగానే ఉంది. ఇప్పుడు మనం అన్నింటినీ ఎలా ఆచరణలో పెట్టాలో గుర్తించాలి. బాగా, ఏదైనా ఎలా ఉపయోగించాలో తెలుసుకోవడానికి, డైవ్ చేసి, దాన్ని ఉపయోగించడానికి ప్రయత్నించండి :) కాబట్టి, ఈ రోజు మనం ప్రాక్టీస్ చేయబోతున్నాం! అత్యంత ప్రజాదరణ పొందిన సర్వ్లెట్ కంటైనర్ అపాచీ టామ్‌క్యాట్ . ఇది ఓపెన్ సోర్స్ మరియు ఉచితంగా ఉపయోగించవచ్చు. మీ ఆపరేటింగ్ సిస్టమ్ కోసం టామ్‌క్యాట్‌ని ఇక్కడ డౌన్‌లోడ్ చేసుకోండి మరియు మేము "యాక్షన్‌లో" కంటైనర్‌లతో పని చేయడం గురించి అన్వేషిస్తాము.

టామ్‌క్యాట్‌ని ఇన్‌స్టాల్ చేయడం మరియు ప్రారంభించడం

1. టామ్‌క్యాట్‌ను ఇన్‌స్టాల్ చేయడానికి, డౌన్‌లోడ్ చేసిన ఆర్కైవ్‌ను కావలసిన డైరెక్టరీలోకి అన్జిప్ చేయండి.

2. ప్రారంభించడానికి మరియు అమలు చేయడానికి టామ్‌క్యాట్‌కి జావా వెర్షన్ 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 ఫైల్‌ను అమలు చేయండి (Linuxలో startup.sh).

5. కొన్ని సెకన్ల తర్వాత, మీ బ్రౌజర్‌లో http://localhost:8080/ లింక్‌ని తెరవండి. మీరు గ్రాఫికల్ డాష్‌బోర్డ్‌ని చూస్తారు:

   మీకు ఇలాంటి మెనూ కనిపిస్తే, టామ్‌క్యాట్ రన్ అవుతుంది.

6. ఇది అమలులో లేకుంటే, JAVA_HOME మరియు CATALINA_HOME ఎన్విరాన్మెంట్ వేరియబుల్స్‌ను మాన్యువల్‌గా తనిఖీ చేయండి:

   • JAVA_HOME — ఇది తప్పనిసరిగా జావా 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();
   }
}

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

అమలు చేయడానికి ముందు, మేము మా సర్వ్‌లెట్‌లను వార్ ఫైల్‌లో ప్యాక్ చేయాలి. 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 . టామ్‌క్యాట్ వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌ను అడగాలి.

   మీరు ఈ సమయం వరకు నాతో పాటు అనుసరించినట్లయితే, వినియోగదారు పేరు "యూజర్" మరియు పాస్‌వర్డ్ "పాస్‌వర్డ్" .

   విజయవంతంగా సైన్ ఇన్ చేసిన తర్వాత, మీరు టామ్‌క్యాట్ వెబ్ అప్లికేషన్ మేనేజర్‌ని చూస్తారు. "అప్లికేషన్స్" విభాగంలో ఇప్పటికే 5 అప్లికేషన్‌లు ఉన్నాయి - ఇవి టామ్‌క్యాట్ యుటిలిటీలు, ఇవి టామ్‌క్యాట్‌తో పని చేయడం సులభతరం చేస్తాయి. భవిష్యత్తులో వాటిని తొలగించవచ్చు.

   క్రింద "డిప్లాయ్" విభాగం ఉంది. ఇక్కడ మీరు విస్తరించడానికి WAR ఆర్కైవ్‌ను ఎంచుకోవచ్చు. మార్గం మరియు సందర్భాన్ని మాన్యువల్‌గా నమోదు చేద్దాం:

   "నియోగించు" క్లిక్ చేయండి మరియు మా అప్లికేషన్ "అప్లికేషన్స్" విభాగంలో కనిపించినట్లు మేము చూస్తాము:

   టామ్‌క్యాట్ గ్రాఫికల్ ఇంటర్‌ఫేస్‌ని ఉపయోగించి, మేము సెషన్‌ను ఆపివేయవచ్చు, పునఃప్రారంభించవచ్చు మరియు తొలగించవచ్చు, అలాగే సెషన్ పొడవును సెట్ చేయవచ్చు. అమలు చేస్తున్నప్పుడు, మేము /డెమో సందర్భాన్ని పేర్కొన్నాము, అంటే మా అప్లికేషన్ http://localhost:8080/demo ఉపయోగించి ప్రాప్తి చేయబడుతుంది . దాన్ని తనిఖీ చేయండి. ప్రతిదీ పని చేయాలి.

2. ఫైల్ సిస్టమ్ ద్వారా

   ఈ విధంగా అప్లికేషన్‌ను అమలు చేయడానికి, మీరు టామ్‌క్యాట్ అన్‌జిప్ చేయబడిన డైరెక్టరీని తెరవాలి. ఆపై "webapps" ఫోల్డర్‌కి వెళ్లండి. మేము ఇప్పటికే ఎదుర్కొన్న యుటిలిటీలను ఇక్కడ మీరు కనుగొంటారు:

   మన servlet.war ఫైల్‌ని ఇక్కడకు తరలించడం మాత్రమే అవసరం.

   మేము కొన్ని సెకన్లపాటు వేచి ఉండి, ఆపై కొత్త "సర్వ్లెట్" ఫోల్డర్ కనిపించిందని చూస్తాము. మా అప్లికేషన్ అమలు చేయబడిందని దీని అర్థం. http://localhost:8080/manager/ వద్ద అప్లికేషన్ మేనేజర్ ఇంటర్‌ఫేస్‌కి వెళ్లండి . మా అప్లికేషన్ /servlet సందర్భంలో అమలు చేయబడిందని ఇక్కడ మనం చూస్తాము:

   ఈ విధంగా అమలు చేసినప్పుడు, అమలు చేయబడిన WAR ఫైల్ పేరు ఆధారంగా సందర్భం స్వయంచాలకంగా కేటాయించబడుతుంది. సందర్భాన్ని మార్చడానికి, మీరు అప్లికేషన్‌ను కలిగి ఉన్న కొత్తగా సృష్టించిన ఫోల్డర్‌కు పేరు మార్చవచ్చు, కానీ అలా చేయడానికి ముందు మీరు WAR ఫైల్‌ను తీసివేయాలి. లేకపోతే, టామ్‌క్యాట్ ఆర్కైవ్ పేరుతో అప్లికేషన్‌ను మళ్లీ అమర్చుతుంది.

   మీరు చూడగలిగినట్లుగా, టామ్‌క్యాట్‌లో అప్లికేషన్‌లను అమలు చేయడం అనిపించే దానికంటే చాలా సులభం. కానీ దాని ఇతర విధులు కూడా ఉపయోగించడానికి సులభమైనవి. తనిఖీ చేద్దాం.

HTTPకి బదులుగా HTTPSని ఉపయోగించడం

మీకు గుర్తు ఉంటే, మేము ప్రత్యేక కథనంలో HTTP మరియు HTTPS మధ్య వ్యత్యాసాన్ని పరిశీలించాము . HTTPS అనేది HTTP వలె అదే ప్రోటోకాల్, కానీ ఇది ప్రసారం చేయబడే డేటాను గుప్తీకరిస్తుంది. క్లయింట్ వైపు, బ్రౌజర్ ఎన్‌క్రిప్షన్‌కు బాధ్యత వహిస్తుంది, అయితే మేము తప్పనిసరిగా సర్వర్ వైపు ఎన్‌క్రిప్షన్‌ను అందించాలి. టామ్‌క్యాట్ HTTP అభ్యర్థనలను అంగీకరిస్తుంది మరియు రూట్ చేస్తుంది కాబట్టి, దానికి ఎన్‌క్రిప్షన్‌ను అప్పగించడం అర్ధమే. దీన్ని చేయడానికి, మనం తప్పక:

1. స్వీయ సంతకం చేసిన ప్రమాణపత్రాన్ని రూపొందించండి
2. అదనపు సర్వర్ సెట్టింగ్‌లను చేయండి

ఇలా చేయడం సాధన చేద్దాం.

సర్టిఫికేట్‌ను రూపొందిస్తోంది

సంస్కరణతో సంబంధం లేకుండా, JDK పెద్ద సంఖ్యలో యుటిలిటీలను కలిగి ఉంటుంది. వాటిలో ఒకటి కీటూల్ . ఇది ఎన్క్రిప్షన్ కీలను రూపొందించడానికి మరియు పని చేయడానికి ఒక సాధనం. దీన్ని ఉపయోగించడానికి, కమాండ్ లైన్‌లో, C:\\Program Files\\Java\\jdk1.8.0_181\\bin డైరెక్టరీకి వెళ్లి, కమాండ్ కీటూల్ -genkey -alias tomcat -keyalg RSAని అమలు చేయండి .

• keytool — కమాండ్ లైన్ ఎంపికలతో మనం రన్ చేస్తున్న యుటిలిటీ పేరు
• -genkey — మేము ఒక కొత్త కీని రూపొందించాలనుకుంటున్నామని సూచించండి
• -అలియాస్ టామ్‌క్యాట్ — కీ మారుపేరును సృష్టించండి
• -keyalg RSA — కీ జనరేషన్ అల్గారిథమ్‌గా RSAని ఎంచుకోండి

ఆదేశాన్ని అమలు చేసిన తర్వాత, యుటిలిటీ మాతో సంభాషణను ప్రారంభిస్తుంది: అవసరమైన సమాచారాన్ని నమోదు చేయండి. ఇప్పుడు మేము మా హోమ్ డైరెక్టరీలో ఒక కీస్టోర్‌ను సృష్టించాము (Windows కోసం, ఇది 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 పేజీల (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 గురించి కాదు — మేము సర్వ్లెట్ కంటైనర్ల గురించి మాట్లాడటానికి ఇక్కడ ఉన్నాము! కాబట్టి మనం JSPని ఎందుకు ప్రస్తావించాము? ఇది చాలా సులభం: సర్వ్లెట్ కంటైనర్ అనేది జావా కోడ్‌ను JSP నుండి HTMLకి మారుస్తుంది. ఒక సర్వ్‌లెట్ JSP కంటెంట్‌ను ప్రతిస్పందనగా తిరిగి ఇవ్వబోతున్నప్పుడు, కంటైనర్ గమనిక తీసుకుంటుంది మరియు క్లయింట్‌కు అటువంటి కంటెంట్‌ను పంపే ముందు దానిని బ్రౌజర్-స్నేహపూర్వక HTML పేజీగా మారుస్తుంది. నేడు, JSP సాంకేతికతకు అనేక సారూప్యాలు ఉన్నాయి - Thymeleaf, FreeMarket, Mustache మరియు ఇతరులు. అవన్నీ ఒకే పద్ధతిలో పనిచేస్తాయి. వాటిలో ఏది మీ పని కోసం ఎంచుకోవాలి అనేది రుచికి సంబంధించిన విషయం. ఇది సర్వ్లెట్ కంటైనర్‌ను ఎంచుకోవడానికి కూడా వర్తిస్తుంది. ఈ ఉదాహరణలలో, మేము అత్యంత సాధారణ కంటైనర్ అయిన టామ్‌క్యాట్‌ని ఉపయోగించాము, కానీ కొన్ని ప్రాజెక్ట్‌లు ఇతర కంటైనర్‌లను ఉపయోగిస్తాయి. అత్యంత జనాదరణ పొందిన వాటిని క్లుప్తంగా సమీక్షించడం మరియు అవి టామ్‌క్యాట్ నుండి ఎలా విభిన్నంగా ఉన్నాయో పరిశీలించడం విలువైనదే.

టామ్‌క్యాట్‌కి ప్రత్యామ్నాయాలు

1. గ్లాస్ ఫిష్ అనేది ఓపెన్ సోర్స్ కంటైనర్, దీని అభివృద్ధికి ఒరాకిల్ మద్దతు ఇస్తుంది.

   టామ్‌క్యాట్ వలె కాకుండా, ఇది పూర్తి స్థాయి వెబ్ సర్వర్, ఇది సర్వ్‌లెట్‌లతో పాటు, JavaEE ఫ్రేమ్‌వర్క్ నుండి ఇతర భాగాలతో పనిచేయగలదు. ఇది చాలా ఎక్కువ ర్యామ్‌ను ఉపయోగిస్తుందని పేర్కొంది. సర్వర్‌ను చక్కగా ట్యూన్ చేసేటప్పుడు ఎక్కువ సౌలభ్యం ఉంటుంది, ఇది దాని వినియోగాన్ని క్లిష్టతరం చేస్తుంది. JavaEE ఫ్రేమ్‌వర్క్‌లో అప్లికేషన్‌లను అభివృద్ధి చేస్తున్నప్పుడు దీనిని ఉపయోగించాలి.

2. వైల్డ్‌ఫ్లైని గతంలో JBoss అని పిలిచేవారు . ఇది కూడా ఓపెన్ సోర్స్. ఇది Red Hat ద్వారా అభివృద్ధి చేయబడింది. కంపెనీ యొక్క మరొక ఉత్పత్తులతో గందరగోళాన్ని నివారించడానికి పేరు మార్చబడింది — JBoss Enterprise అప్లికేషన్ ప్లాట్‌ఫారమ్.

   GlassFish వలె, WildFly అనేది పూర్తి స్థాయి వెబ్ సర్వర్. యాదృచ్ఛికంగా, హుడ్ కింద, వైల్డ్‌ఫ్లై టామ్‌క్యాట్‌ను సర్వ్‌లెట్ కంటైనర్‌గా ఉపయోగిస్తుంది. GlassFish కాకుండా, WildFly మరింత తేలికైనది మరియు కాన్ఫిగర్ చేయడం సులభం.

3. జెట్టీ , మునుపటి వాటిలాగే, ఓపెన్ సోర్స్. ఇది ఎక్లిప్స్ ద్వారా అభివృద్ధి చేయబడింది.

   టామ్‌క్యాట్ వలె, ఇది JavaEE ఫ్రేమ్‌వర్క్‌లోని అన్ని భాగాలకు మద్దతు లేకుండా ఒక సాధారణ సర్వ్‌లెట్ కంటైనర్. అదే సమయంలో, ఇది మరింత తేలికైనది మరియు మొబైల్ ఫోన్‌లో కూడా అమలు చేయబడుతుంది. ఇది త్వరగా ప్రారంభమవుతుంది మరియు ఆగిపోతుంది మరియు బాగా స్కేల్ అవుతుంది. టామ్‌క్యాట్ వలె కాకుండా, ఇది ఒక చిన్న సంఘం మరియు నాలెడ్జ్ బేస్ కలిగి ఉంది.

4. WebLogic అనేది లైసెన్స్ పొందిన సాఫ్ట్‌వేర్, దీనిని ఉపయోగించే ముందు తప్పనిసరిగా కొనుగోలు చేయాలి. ఇది ఒరాకిల్‌కు చెందినది.

   ఇది టామ్‌క్యాట్ కంటే కొంచెం విస్తృతమైన కార్యాచరణను కలిగి ఉంది. ఇది FTP ప్రోటోకాల్‌తో పని చేయగలదు. కానీ అప్లికేషన్‌లను డెవలప్ చేసేటప్పుడు మరియు టెస్టింగ్ చేసేటప్పుడు ఇది అంత ఫ్లెక్సిబుల్ కాదు.

5. వెబ్‌స్పియర్ (వెబ్‌స్పియర్ అప్లికేషన్ సర్వర్, ఖచ్చితంగా చెప్పాలంటే) చెల్లింపు సాఫ్ట్‌వేర్. దీనిని IBM అభివృద్ధి చేసింది. WildFly మరియు GlassFish లాగానే, ఇది పూర్తి అప్లికేషన్ సర్వర్. కానీ ఇది స్నేహపూర్వక కాన్ఫిగరేషన్ ఇంటర్‌ఫేస్‌తో పాటు ఆపరేషన్‌లో అధిక విశ్వసనీయతను కలిగి ఉంది.

   దాని లోపాలు చాలా వనరులను ఉపయోగిస్తాయి మరియు ప్రారంభించడానికి మరియు ఆపడానికి చాలా సమయం పడుతుంది, ఇది చిన్న ప్రాజెక్టులను అభివృద్ధి చేసేటప్పుడు చాలా సౌకర్యవంతంగా ఉండదు.

సరైన సర్వ్లెట్ కంటైనర్ లేదా అప్లికేషన్ సర్వర్ ఎంపిక నిర్దిష్ట ప్రాజెక్ట్‌పై ఆధారపడి ఉంటుంది. స్పష్టమైన అండర్‌డాగ్ కూడా అద్భుతమైన ఎంపికగా నిరూపించబడే ప్రాజెక్ట్‌లు ఉన్నాయి, అయితే మొదట ఒక సర్వ్‌లెట్ కంటైనర్‌ను లోతుగా అధ్యయనం చేయడం ఉత్తమం. టామ్‌క్యాట్ బహుశా ఈ అధ్యయనానికి సరైన అభ్యర్థి. మరియు మేము దీన్ని అధ్యయనం చేయడంలో ఇప్పటికే మొదటి దశలను తీసుకున్నాము, కానీ ఇక్కడ నుండి అది మీ ఇష్టం! "ఇంట్రడక్షన్ టు ఎంటర్‌ప్రైజ్ డెవలప్‌మెంట్" సిరీస్ యొక్క చివరి కథనాలలో, మేము MVC నమూనాను తెలుసుకుంటాము. పార్ట్ 7. MVC (మోడల్-వ్యూ-కంట్రోలర్) నమూనాను పరిచయం చేస్తోంది