పార్ట్ 5. సర్వ్లెట్స్ మరియు జావా సర్వ్లెట్ API. ఒక సాధారణ వెబ్ అప్లికేషన్ రాయడం

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

• నెట్‌వర్కింగ్ గురించి
• సాఫ్ట్‌వేర్ ఆర్కిటెక్చర్ గురించి
• HTTP/HTTPS గురించి
• మావెన్ యొక్క ప్రాథమిక విషయాల గురించి

కన్సోల్‌లో వచనాన్ని ప్రదర్శించే జావా అప్లికేషన్‌లను ఎలా వ్రాయాలో మీకు ఇప్పటికే తెలుసా, అయితే మీ మొదటి వెబ్ అప్లికేషన్‌ను ఎలా సృష్టించాలో మీకు ఇంకా తెలియదా? గ్రేట్, మిమ్మల్ని మీరు సౌకర్యవంతంగా చేసుకోండి. ఈ కథనంలో, మేము సర్వ్‌లెట్‌లతో పరిచయం పొందుతాము మరియు మీరు మీ స్నేహితులకు JAR ఫైల్‌ను పంపకుండా మరియు Javaని డౌన్‌లోడ్ చేయమని బలవంతం చేయకుండా వారి గురించి గొప్పగా చెప్పుకునే అప్లికేషన్‌ను వ్రాస్తాము. ఒక సాధారణ వెబ్ అప్లికేషన్ వ్రాద్దాం . వెబ్ డెవలప్‌మెంట్‌లో ఉపయోగించే విధానాల గురించి మీకు ఇప్పటికే తెలియకపోతే, " ఇంట్రడక్షన్ టు ఎంటర్‌ప్రైజ్ డెవలప్‌మెంట్ " సిరీస్‌లోని మొదటి కథనాన్ని చదవడం ద్వారా ప్రారంభించాలని నేను సిఫార్సు చేస్తున్నాను.

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

ముందుగా, సర్వ్‌లెట్‌లు అంటే ఏమిటో మరియు వాటి గురించి మీరు ఎందుకు తరచుగా వింటున్నారో తెలుసుకుందాం. Java Servlet API అనేది సర్వర్‌లో అమలు చేయడానికి ఉద్దేశించిన ప్రామాణిక API. ఇది అభ్యర్థన-ప్రతిస్పందన పథకం ప్రకారం క్లయింట్‌లతో పరస్పర చర్య చేస్తుంది. సర్వ్‌లెట్ అనేది క్లయింట్ నుండి అభ్యర్థనలను స్వీకరించగల మరియు క్లయింట్‌కు ప్రతిస్పందనలను అందించగల తరగతి. వాస్తవానికి, సర్వ్‌లెట్‌లు అనేది జావాలో క్లయింట్-సర్వర్ ఆర్కిటెక్చర్‌ను రూపొందించడానికి మేము ఉపయోగించే బిల్డింగ్ బ్లాక్‌లు. ఆ ఆర్కిటెక్చర్ గురించి మేము ఇప్పటికే సిరీస్‌లోని మరొక కథనంలో మాట్లాడినట్లు మీకు గుర్తు ఉండవచ్చు. మేము బుష్ చుట్టూ కొట్టడానికి వెళ్ళడం లేదు: వెంటనే కొన్ని కోడ్ వ్రాస్దాం.

మీరు వెబ్ అప్లికేషన్‌ను సృష్టించడానికి ఏమి కావాలి

జావా సర్వ్‌లెట్‌లతో పని చేస్తున్నప్పుడు గొప్ప సౌలభ్యం కోసం, మీకు IntelliJ IDEA అల్టిమేట్ ఎడిషన్ అవసరం. ఇది చెల్లింపు ఉత్పత్తి, కానీ మీరు 30-రోజుల ట్రయల్‌ని సక్రియం చేయవచ్చు లేదా ప్రారంభ యాక్సెస్ వెర్షన్‌ని ఉపయోగించవచ్చు, ఇది ఎల్లప్పుడూ ఉచితం. అలాగే, Apache Tomcatని ఇన్‌స్టాల్ చేయండి — మా అప్లికేషన్ సర్వర్. టామ్‌క్యాట్ అనేది సర్వ్‌లెట్ కంటైనర్: ఇది ఇన్‌కమింగ్ అభ్యర్థనలను ప్రాసెస్ చేస్తుంది మరియు వాటిని మా అప్లికేషన్‌కు పంపుతుంది. టామ్‌క్యాట్‌ని ఇక్కడ డౌన్‌లోడ్ చేసుకోండి .

మన మొదటి వెబ్ అప్లికేషన్‌ని క్రియేట్ చేద్దాం

ప్రతిదీ సిద్ధంగా ఉంటే, మావెన్ ప్రాజెక్ట్‌ను సృష్టించండి. మీకు మావెన్ గురించి తెలియకపోతే, మునుపటి కథనాన్ని పరిశీలించండి . ప్రారంభిద్దాం!

1. pom.xmlలో, javax.servlet-api డిపెండెన్సీని జోడించి, WAR ప్యాకేజింగ్‌ను పేర్కొనండి:

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
   
      <groupId>org.example</groupId>
      <artifactId>servlets</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
   
      <dependencies>
          <dependency>
              <groupId>javax.servlet</groupId>
              <artifactId>javax.servlet-api</artifactId>
              <version>4.0.1</version>
          </dependency>
      </dependencies>
   </project>

   సాధారణ సర్వ్లెట్ క్లాస్:

   import javax.servlet.ServletException;
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.IOException;
   import java.io.PrintWriter;
   
   @WebServlet("/hello")
   public class MainServlet extends HttpServlet {
   
      @Override
      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          resp.setContentType("text/html");
          PrintWriter printWriter = resp.getWriter();
          printWriter.write("Hello!");
          printWriter.close();
      }
   }

2. అప్లికేషన్‌ను అమలు చేయడానికి, మీరు టామ్‌క్యాట్ కాన్ఫిగరేషన్‌ను సృష్టించాలి:

3. తరువాత, మేము టామ్‌క్యాట్ యొక్క ఏ వెర్షన్‌ని ఉపయోగిస్తాము మరియు సర్వర్‌తో కమ్యూనికేట్ చేయడానికి URL మరియు పోర్ట్‌ను సూచిస్తాము. మీరు ఇలాంటివి కలిగి ఉండాలి:

4. ఇప్పుడు మనం కంటైనర్‌లో అమర్చబడే కళాఖండాన్ని (JAR ఆర్కైవ్‌లో అసెంబుల్ చేసిన ప్రాజెక్ట్) పేర్కొనాలి. మీరు ఫిక్స్ బటన్‌ను క్లిక్ చేసి, వార్ ఎక్స్‌ప్లోడెడ్‌ని ఎంచుకోవచ్చు : ప్రాజెక్ట్ పునర్నిర్మించిన తర్వాత, ఆర్టిఫ్యాక్ట్ స్వయంచాలకంగా సర్వ్‌లెట్ కంటైనర్‌లో ఉంచబడుతుంది.

5. అప్లికేషన్ సందర్భం కోసం డిఫాల్ట్ విలువ servlets_war_exploded . దీని అర్థం మేము అప్లికేషన్‌ను ఇక్కడ యాక్సెస్ చేస్తాము: http://localhost:8080/servlets_war_exploded .

   మనకు అదనపు వచనం ఎందుకు కావాలి? అనవసరమైన వాటిని తొలగిస్తాం. ఇప్పుడు మన వెబ్ అప్లికేషన్ యొక్క చిరునామా: http://localhost:8080 .

6. సరే క్లిక్ చేయండి. మేము ఇప్పుడు అప్లికేషన్‌ను ప్రారంభించవచ్చని చూస్తున్నాము:

   ఇప్పుడు మీరు మీ బ్రౌజర్‌లో అప్లికేషన్‌ను తెరిచినప్పుడు, మీకు 404 ఎర్రర్ వస్తుంది. ఇది అర్ధమే, ఎందుకంటే http://localhost:8080/ చిరునామాకు "/"కి మ్యాప్ చేసే సర్వ్‌లెట్ అవసరం, కానీ మా ఏకైక సర్వ్‌లెట్ మ్యాప్‌లు "/hello" .

7. మేము దీన్ని http://localhost:8080/hello వద్ద యాక్సెస్ చేయవచ్చు . ఒకసారి మనం అలా చేస్తే, మనకు ఊహించిన సమాధానం వస్తుంది — స్ట్రింగ్ "హలో"!

ప్రతిదీ పనిచేస్తుంటే, కోడ్‌ను విశ్లేషిద్దాం. సాధారణ తరగతి నుండి HTTP-సర్వ్‌లెట్‌ని తయారు చేయడానికి , అది తప్పనిసరిగా HttpServlet తరగతిని పొందాలి. క్లాస్ డిక్లరేషన్ పైన, మేము ఉల్లేఖనాన్ని సూచిస్తాము @WebServlet(). ఇక్కడే మనం సర్వ్‌లెట్‌ను ఒక నిర్దిష్ట మార్గానికి ("/హలో") బంధిస్తాము (లేదా మ్యాప్) చేస్తాము. ఈ ఉల్లేఖనం Java Servlet API 3.0లో మాత్రమే కనిపించింది, కాబట్టి XML ఫైల్ ద్వారా సర్వ్లెట్ మ్యాపింగ్ జరిగే అనేక ఉదాహరణలు ఇంటర్నెట్‌లో ఉన్నాయి. ఇది ఇకపై అవసరం లేదు. GET అభ్యర్థనలను నిర్వహించడానికి , మేము doGet()పద్ధతిని భర్తీ చేస్తాము. పద్ధతి యొక్క పారామితులకు శ్రద్ధ వహించండి: HttpServletRequestమరియు HttpServletResponse. HttpServletRequestఅభ్యర్థన గురించి అవసరమైన మొత్తం సమాచారాన్ని ఆబ్జెక్ట్ మాకు అందిస్తుంది . లో HttpServletResponse, మేము మా ప్రతిస్పందనను వ్రాసి, అవసరమైన శీర్షికలను సెట్ చేస్తాము.

పారామితులు మరియు సెషన్‌తో పని చేయడం

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

import javax.servlet.ServletException;
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 ServletException, 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" + "<br>");
       } else {
           printWriter.write("Hello, " + username + "<br>");
       }
       printWriter.write("Page was visited " + visitCounter + " times.");
       printWriter.close();
   }
}

visitCounterఇప్పుడు సర్వ్లెట్ సెషన్‌తో పని చేస్తుంది, పేజీని సందర్శించిన ప్రతిసారీ విలువ పెరుగుతుంది . లక్షణం visitCounterఇంకా సృష్టించబడనట్లయితే (పేజీకి మొదటి సందర్శన తర్వాత), పద్ధతి getAttribute()శూన్యతను అందిస్తుంది, కాబట్టి మనం శూన్యతను తనిఖీ చేయాలి. అభ్యర్థన పారామితులకు కూడా ఇది వర్తిస్తుంది. వినియోగదారు వినియోగదారు పేరు పరామితిని పాస్ చేయకపోతే, దాని విలువ శూన్యం అవుతుంది. ఈ సందర్భంలో, మేము వినియోగదారుని అనామక సందర్శకునిగా అభినందిస్తున్నాము. GET అభ్యర్థనలో పరామితిని పాస్ చేయడానికి, ప్రశ్న స్ట్రింగ్ ఉపయోగించబడుతుంది, ఉదాహరణకు, మేము ఈ క్రింది URLని ఉపయోగించవచ్చు: http:// localhost:8080/hello? వినియోగదారు పేరు=పాల్. మీరు మునుపటి కథనంలో HTTP అభ్యర్థనల గురించి మరింత చదవవచ్చుసిరీస్‌లో. మా అప్లికేషన్ ప్రస్తుతం చాలా లాజిక్‌ను కలిగి లేదు, కానీ రూట్ పాత్‌లో 404 ఎర్రర్‌ని పొందడం కొంచెం బాధించేది. దీన్ని పరిష్కరించడానికి, మేము మరొక సర్వ్‌లెట్‌ని సృష్టించి, ప్రారంభ పేజీకి మ్యాప్ చేస్తాము: @WebServlet("/"). ఈ సర్వ్‌లెట్ యొక్క ఉద్దేశ్యం అభ్యర్థనలను "/హలో" మార్గానికి దారి మళ్లించడం. దీన్ని చేయడానికి రెండు మార్గాలు ఉన్నాయి: "ఫార్వర్డ్" లేదా "రీడైరెక్ట్" ఉపయోగించి. బహుశా వాటి మధ్య వ్యత్యాసాన్ని అర్థం చేసుకోవడం విలువైనదే. సర్వర్‌లోని మరొక సర్వ్‌లెట్‌కు ఫార్వర్డ్ డెలిగేట్‌లు అభ్యర్థనను ప్రాసెస్ చేస్తున్నారు. క్లయింట్ ప్రమేయం లేదు. దీన్ని చేయడానికి, కొత్త సర్వ్లెట్ యొక్క doGet() పద్ధతికి క్రింది కోడ్‌ను జోడించండి:

getServletContext().getRequestDispatcher("/hello").forward(req, resp);

ఈ కోడ్‌లో, మేము సర్వ్‌లెట్ సందర్భాన్ని యాక్సెస్ చేస్తాము, సంబంధిత సర్వ్‌లెట్ కోసం రిక్వెస్ట్ డిస్‌పాచర్‌ని పొందుతాము మరియు పేర్కొన్న ఆర్గ్యుమెంట్‌లతో (req, resp) నిర్దిష్ట అభ్యర్థనను ప్రాసెస్ చేయమని అడుగుతాము. క్లయింట్ తన అభ్యర్థనను ప్రాసెస్ చేయడానికి ఉపయోగించాల్సిన చిరునామాను మళ్లింపు క్లయింట్‌కు అందిస్తుంది. చాలా బ్రౌజర్‌లు స్వయంచాలకంగా తిరిగి వచ్చిన URLకి నావిగేట్ చేస్తాయి. దారి మళ్లింపును అమలు చేయడానికి, మీరు ఈ కోడ్‌ని జోడించాలి:

resp.sendRedirect(req.getContextPath() + "/hello");

redirect()మేము పరామితిపై పద్ధతిని పిలుస్తాము HttpServletResponseమరియు క్లయింట్ ఉపయోగించాల్సిన చిరునామాను పాస్ చేస్తాము. ఇక్కడ ఒక ముఖ్యమైన వివరాలు ఉన్నాయి: HTTP పారామితులు కూడా పూర్తి దారి మళ్లింపు మార్గం చివరిలో జోడించబడాలి, ఇది చాలా సౌకర్యవంతంగా లేదు. మా పరిస్థితిలో, ఉపయోగించడం ఉత్తమం forward, కానీ కొన్నిసార్లు ఉపయోగించడం redirectమంచిది. అవి పని చేసే విధానంలోని వ్యత్యాసాన్ని మీరు అర్థం చేసుకుంటే, మీరు తప్పు ఎంపిక చేయరు. కొత్త సర్వ్లెట్ కోడ్ ఇలా కనిపిస్తుంది:

import javax.servlet.ServletException;
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 ServletException, IOException {
//        getServletContext().getRequestDispatcher("/hello").forward(req, resp);
       resp.sendRedirect(req.getContextPath() + "/hello");
   }
}

సారాంశం

మీ మొదటి వెబ్ అప్లికేషన్ పూర్తయింది. తర్వాతి కథనంలో, IntelliJ IDEAని ఉపయోగించకుండా దీన్ని ఎలా అమలు చేయాలో మీరు నేర్చుకుంటారు. మేము GET అభ్యర్థనలను మాత్రమే ప్రాసెస్ చేసే అప్లికేషన్‌ను వ్రాసాము. మిగిలిన HTTP పద్ధతులు ఇదే విధంగా నిర్వహించబడతాయి - పేరెంట్ క్లాస్ యొక్క సంబంధిత పద్ధతులను భర్తీ చేయడం ద్వారా. అధునాతన బహుముఖ వెబ్ అప్లికేషన్‌లను రూపొందించడానికి మీరు ఇలాంటి సాధారణ సర్వ్‌లెట్‌లను ఉపయోగించవచ్చు. వాస్తవానికి, స్ప్రింగ్ వంటి పెద్ద ఫ్రేమ్‌వర్క్‌లను ఉపయోగించడం దీన్ని చాలా సులభతరం చేస్తుంది. మీరు నిజంగా సర్వ్లెట్ల యొక్క అన్ని సామర్థ్యాలను లోతుగా పరిశోధించాలనుకుంటే, మీరు అధికారిక వివరణను చదవవచ్చు . పార్ట్ 6. సర్వ్లెట్ కంటైనర్లు పార్ట్ 7. MVC (మోడల్-వ్యూ-కంట్రోలర్) నమూనాను పరిచయం చేస్తోంది