జావా సర్వ్‌లెట్‌లను ఉపయోగిస్తున్న మీ మొదటి అప్లికేషన్

అందరికీ నమస్కారం! మీరు వెబ్ డెవలప్‌మెంట్ యొక్క ప్రాథమిక భావనగా సర్వ్‌లెట్‌లతో సుపరిచితులు అవుతారు మరియు మీరు వాటిని ఉపయోగించే ఒక సాధారణ అప్లికేషన్‌ను వ్రాయగలరు. అనవసరమైన చర్యలను నివారించడానికి, మేము మొదటి నుండి ప్రారంభించము. మేము హైబర్నేట్ గురించి నా మునుపటి కథనం నుండి మా అప్లికేషన్‌పై పని చేస్తూనే ఉంటాము . కానీ మేము ఇప్పుడే సర్వ్‌లెట్‌లతో పరిచయం పొందడం ప్రారంభించినందున, నేను అప్లికేషన్ నుండి ఆటో క్లాస్‌కు సంబంధించిన అన్నింటినీ తీసివేసాను మరియు వినియోగదారు తరగతి మరియు దానితో కూడిన చర్యలను మాత్రమే వదిలివేసాను. ప్రాజెక్ట్ ఈ విధంగా నిర్మించబడుతుంది: కాబట్టి, సర్వ్లెట్స్! వికీపీడియా ఇలా పేర్కొంది: "జావా సర్వర్‌లెట్ అనేది సర్వర్ యొక్క సామర్థ్యాలను విస్తరించే ఒక జావా సాఫ్ట్‌వేర్ భాగం. సర్వర్‌లు అనేక రకాల అభ్యర్థనలకు ప్రతిస్పందించగలిగినప్పటికీ, అవి సాధారణంగా వెబ్ సర్వర్‌లలో వెబ్ అప్లికేషన్‌లను హోస్ట్ చేయడానికి వెబ్ కంటైనర్‌లను అమలు చేస్తాయి మరియు తద్వారా సర్వర్‌గా అర్హత పొందుతాయి- సైడ్ సర్వ్లెట్ వెబ్ API." ఇది ఖచ్చితంగా నిజం. ఇక్కడ, మొదటిసారిగా, మేము "క్లయింట్-సర్వర్ అప్లికేషన్ ఆర్కిటెక్చర్" భావనను చూస్తున్నాము. ఇది దాని ప్రధాన భాగంలో చాలా సులభం. క్లయింట్ HTTP అభ్యర్థనను పంపడం ద్వారా సర్వర్‌ను యాక్సెస్ చేస్తుంది. సర్వర్ అవసరమైన డేటాను ఉత్పత్తి చేస్తుంది (ఉదాహరణకు, దానిని డేటాబేస్ నుండి పొందుతుంది) మరియు దానిని క్లయింట్‌కు తిరిగి ఇస్తుంది. మీరు ఒక నిర్దిష్ట సోషల్ నెట్‌వర్క్‌లోని "స్నేహితులు" బటన్‌ను క్లిక్ చేసినప్పుడు, తద్వారా సర్వర్‌కు అభ్యర్థనను పంపడం సరళమైన ఉదాహరణ. సర్వర్ డేటాబేస్‌లోని మీ స్నేహితుల జాబితాను అప్‌డేట్ చేస్తుంది మరియు దానిని మీకు (క్లయింట్) తిరిగి ఇస్తుంది. HTTP అభ్యర్థనల జాబితా చాలా పెద్దది, కాబట్టి మీరు ఇంతకు ముందెన్నడూ వాటిని ఎదుర్కొని ఉండకపోతే, మీరు వాటి గురించి మరెక్కడా చదవడం ఉత్తమం, ఉదాహరణకు,ఇక్కడ . మా లక్ష్యం: సర్వ్‌లెట్‌లను ఉపయోగించి CRUD అప్లికేషన్‌ను రూపొందించడం. అప్లికేషన్ తప్పనిసరిగా HTTP అభ్యర్థనలను ప్రాసెస్ చేసే సర్వ్‌లెట్‌ని ఉపయోగించి డేటాబేస్ నుండి వినియోగదారులను సృష్టించగలదు, చదవగలదు, నవీకరించగలదు మరియు తొలగించగలదు. హైబర్నేట్ కథనం నుండి మా అప్లికేషన్ ఇప్పటికే దీన్ని చేయగలదు, అయితే ఇది నేరుగా జావా కోడ్ నుండి, మరింత ఖచ్చితంగా, మెయిన్() పద్ధతి నుండి నియంత్రించబడుతుంది. ఈసారి, అభ్యర్థనలను పంపేది క్లయింట్, అంటే మీరు :) మేము చేయవలసిన మొదటి పని మా pom.xml ఫైల్‌కి కొత్త డిపెండెన్సీలను జోడించడం.

 <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>com.itis4</groupId>
     <artifactId>UsersDaoProject</artifactId>
     <version>1.0-SNAPSHOT</version>
 
     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-war-plugin</artifactId>
                 <version>2.6</version>
             </plugin>
         </plugins>
     </build>
 
     <dependencies>
         <!-- PostgreSQL  -->
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
             <version>9.4.1212.jre7</version>
         </dependency>
 
         <!-- Hibernate 5.2.6 Final -->
         <dependency>
             <groupId>org.hibernate</groupId>
             <artifactId>hibernate-core</artifactId>
             <version>5.2.6.Final</version>
         </dependency>
 
         <dependency>
             <groupId>jstl</groupId>
             <artifactId>jstl</artifactId>
             <version>1.2</version>
         </dependency>
         <dependency>
             <groupId>javax.servlet</groupId>
             <artifactId>javax.servlet-api</artifactId>
             <version>3.1.0</version>
         </dependency>
 
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
             <version>4.3.4.RELEASE</version>
         </dependency>
 
     </dependencies>
 
 </project>
 

మేము 3 డిపెండెన్సీలను జోడించాము:

1. javax.servlet-api లైబ్రరీ కూడా
2. JSTL ట్యాగ్ లైబ్రరీ. క్లయింట్ వైపు, అంటే JSP పేజీలను సృష్టించడానికి ఇది అవసరం
3. స్ప్రింగ్-WebMVC. మాకు ఒక స్ప్రింగ్ క్లాస్ అవసరం, దాని గురించి కొంచెం తరువాత మాట్లాడుతాము.

సర్వ్లెట్ నిర్వహణ సర్వ్లెట్ కంటైనర్ ద్వారా నిర్వహించబడుతుంది. మా విషయంలో, మేము Apache Tomcatని ఉపయోగిస్తాము. ఇది చాలా ప్రజాదరణ పొందింది — మీరు బహుశా దీని గురించి ఇప్పటికే విని ఉంటారు :) సర్వ్లెట్ జీవిత చక్రం క్రింది దశలను కలిగి ఉంటుంది:

1. కంటైనర్‌లో సర్వ్‌లెట్ లేకపోతే:
   
   • సర్వ్లెట్ క్లాస్ కంటైనర్ ద్వారా లోడ్ చేయబడింది.
   • కంటైనర్ సర్వ్లెట్ క్లాస్ యొక్క ఉదాహరణను సృష్టిస్తుంది.
   • కంటైనర్ init() పద్ధతిని పిలుస్తుంది. ఈ పద్ధతి సర్వ్‌లెట్‌ను ప్రారంభిస్తుంది మరియు సర్వ్‌లెట్ అభ్యర్థనలను అందించడానికి ముందు మొదటగా పిలువబడుతుంది. మొత్తం జీవిత చక్రంలో, init() పద్ధతిని ఒకసారి మాత్రమే అంటారు.
2. క్లయింట్ అభ్యర్థనకు సేవ చేయండి. ప్రతి అభ్యర్థన దాని స్వంత ప్రత్యేక థ్రెడ్‌లో ప్రాసెస్ చేయబడుతుంది. కంటైనర్ ప్రతి అభ్యర్థన కోసం సర్వీస్() పద్ధతిని పిలుస్తుంది. ఈ పద్ధతి ఇన్‌కమింగ్ అభ్యర్థన రకాన్ని నిర్ణయిస్తుంది మరియు ప్రాసెసింగ్ కోసం తగిన పద్ధతికి పంపుతుంది. సర్వ్లెట్ డెవలపర్ తప్పనిసరిగా ఈ పద్ధతుల కోసం అమలులను అందించాలి. అమలు చేయని హ్యాండ్లర్ కోసం అభ్యర్థన వస్తే, పేరెంట్ క్లాస్ పద్ధతిని పిలుస్తారు మరియు సాధారణంగా అభ్యర్థికి లోపాన్ని అందించడం ముగుస్తుంది.


3. కంటైనర్ సర్వ్‌లెట్‌ను తీసివేయవలసి వస్తే, అది డిస్ట్రాస్ట్ () పద్ధతిని పిలుస్తుంది, ఇది సర్వ్‌లెట్‌ను ఆపరేషన్ నుండి తీసివేస్తుంది. init() పద్ధతి వలె, ఈ పద్ధతిని మొత్తం సర్వ్లెట్ చక్రంలో కూడా ఒకసారి అంటారు.

మా సర్వ్లెట్ చాలా సరళంగా కనిపిస్తుంది:

 package servlets;
 
 import models.User;
 import services.UserService;
 import javax.servlet.RequestDispatcher;
 import javax.servlet.ServletConfig;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
 
 public class UserSimpleServlet extends HttpServlet {
 
     private UserService service = new UserService();
 
     public void init(ServletConfig servletConfig) {
         try {
             super.init(servletConfig);
         } catch (ServletException e) {
             e.printStackTrace();
         }
     }
 
     @Override
     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
         List<User> users = service.findAllUsers();
         req.setAttribute("users", users);
         RequestDispatcher dispatcher = req.getRequestDispatcher("/showUsers.jsp");
         dispatcher.forward(req, resp);
 
     }
 
     @Override
     protected void doPost(HttpServletRequest req, HttpServletResponse resp)
             throws ServletException, IOException {
 
         String name = req.getParameter("name");
         int age = Integer.parseInt(req.getParameter("age"));
         User user = new User(name, age);
         service.saveUser(user);
         resp.sendRedirect("/users");
 
     }
 
     @Override
     protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         int id = Integer.parseInt(req.getParameter("id"));
         User user = service.findUser(id);
         user.setName(req.getParameter("name"));
         user.setAge(Integer.parseInt(req.getParameter("age")));
         service.updateUser(user);
         resp.sendRedirect("/users");
     }
 
     @Override
     protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws IOException {
         int id = Integer.parseInt(req.getParameter("id"));
         service.deleteUser(service.findUser(id));
         resp.sendRedirect("/users");
     }
 }
 

మీరు చూడగలిగినట్లుగా, ఇది పైన వివరించిన init() పద్ధతిని కలిగి ఉంది మరియు నాలుగు HTTP అభ్యర్థనలతో సమానంగా ఉండే 4 పద్ధతులను అమలు చేస్తుంది: doPost(), doGet(), doPut() మరియు doDelete(). వారు వినియోగదారులను సృష్టించడానికి, చదవడానికి, నవీకరించడానికి మరియు తొలగించడానికి మాకు అనుమతిస్తారు. పద్ధతులు javax.servlet.http.HttpServletRequest మరియు javax.servlet.http.HttpServletResponse క్లాస్‌లను ఇన్‌పుట్‌గా అంగీకరిస్తాయి, అనగా సర్వర్‌కి పంపబడిన అభ్యర్థనలు మరియు క్లయింట్ స్వీకరించిన ప్రతిస్పందనలు. అంతర్గతంగా, పద్ధతులు యూజర్ సర్వీస్ క్లాస్ యొక్క సంబంధిత పద్ధతులను పిలుస్తాయి మరియు క్లయింట్ కోసం ప్రతిస్పందన ఉత్పత్తి చేయబడుతుంది మరియు /యూజర్స్ URLకి మళ్లించబడుతుంది. ఉదాహరణకు, doGet() పద్ధతిలో, మేము వినియోగదారులందరి జాబితాను పొందుతాము. తరువాత, మేము రిక్వెస్ట్‌డిస్పాచర్ ఆబ్జెక్ట్‌ను సృష్టిస్తాము, ఇది HTTP అభ్యర్థనలో ఆబ్జెక్ట్‌లను చేర్చడానికి మరియు దానిని నిర్దిష్ట వనరుకి (ఉదాహరణకు, క్లయింట్ JSP పేజీకి) మళ్లించడానికి అనుమతిస్తుంది. doPut() పద్ధతిలో (ఇది వినియోగదారు డేటాను నవీకరిస్తుంది), మేము HTTP అభ్యర్థనను ప్రాసెస్ చేస్తాము, id, పేరు మరియు వయస్సు పారామితులను సంగ్రహిస్తాము, పేర్కొన్న idతో వినియోగదారుని కనుగొని, అభ్యర్థనలో పేరు మరియు వయస్సును కేటాయించి, తిరిగి అందిస్తాము. / వినియోగదారుల పేజీకి. కానీ ఈ పద్ధతులన్నీ సరిగ్గా పనిచేయాలంటే, మనం సర్వ్లెట్‌ను కాన్ఫిగర్ చేయాలి. దీన్ని చేయడానికి, మేము WeB-INF ఫోల్డర్‌లో web.xml ఫైల్‌ని ఉపయోగిస్తాము.

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app version="3.1"
          xmlns="http://xmlns.jcp.org/xml/ns/javaee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
 
     <welcome-file-list>
         <welcome-file>index.jsp</welcome-file>
     </welcome-file-list>
 
     <servlet>
         <servlet-name>UserSimpleServlet</servlet-name>
         <servlet-class>servlets.UserSimpleServlet</servlet-class>
     </servlet>
 
     <servlet-mapping>
         <servlet-name>UserSimpleServlet</servlet-name>
         <url-pattern>/</url-pattern>
     </servlet-mapping>
 
     <filter>
         <filter-name>hiddenHttpMethodFilter</filter-name>
         <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
     </filter>
 
     <filter-mapping>
         <filter-name>hiddenHttpMethodFilter</filter-name>
         <servlet-name>UserSimpleServlet</servlet-name>
     </filter-mapping>
 
 </web-app>
 

ఈ ఫైల్‌లోని అన్ని ట్యాగ్‌లు చాలా స్పష్టంగా ఉన్నాయి, అయితే వాటిని క్రమంలో చూద్దాం. <welcome-file-list> - JSP ప్రారంభ పేజీ సూచించబడింది, ఇది అప్లికేషన్ ప్రారంభమైనప్పుడు మొదట తెరవబడుతుంది. మా విషయంలో, ఇది index.jsp. <servlet> - మా UserSimpleServlet తరగతిని సర్వ్‌లెట్‌గా నమోదు చేయడం. <servlet-mapping> - చాలా ముఖ్యమైన ట్యాగ్. ఇది సర్వ్లెట్ ద్వారా ప్రాసెస్ చేయబడే URLలను నిర్వచిస్తుంది. మా విషయంలో, ఇది అన్ని URLలు, కాబట్టి మేము కేవలం "/"ని సూచిస్తాము. అయితే వినియోగదారులు మరియు వారి కార్లు (ఆటోలు)తో కూడిన అప్లికేషన్‌ను కలిగి ఉన్నట్లయితే, మేము రెండవ సర్వ్‌లెట్ (సింపుల్‌ఆటోసర్వ్‌లెట్)ని సృష్టించవచ్చు. అప్పుడు వినియోగదారు సర్వ్‌లెట్ యొక్క మ్యాపింగ్ "/యూజర్‌లు" (అంటే వినియోగదారుల గురించిన అభ్యర్థనలు), మరియు ఆటో సర్వ్‌లెట్ యొక్క మ్యాపింగ్ "/autos" అవుతుంది. చివరకు, <ఫిల్టర్>. అంతర్గతంగా, ఇది org యొక్క ఉదాహరణను నిర్వచిస్తుంది. springframework.web.filter.HiddenHttpMethodFilter తరగతి. ఈ వ్యాసం వసంతకాలం గురించి కాదు, కాబట్టి నేను దానిని వివరంగా వివరించను. ఇది అదనపు ఫీచర్‌గా మాత్రమే మా అప్లికేషన్‌లో బోల్ట్ చేయబడిందని నేను చెప్తాను. విషయం ఏమిటంటే, మేము క్లయింట్ వైపు సృష్టించడానికి JSP పేజీలను ఉపయోగించబోతున్నాము. మా డేటా వినియోగదారుల జాబితాతో పేజీలో పట్టికగా ప్రదర్శించబడుతుంది. JSP పేజీల లోపల, <form/> HTML ట్యాగ్‌లు ఉపయోగించబడతాయి. కానీ <form/> నుండి డేటాను పంపడానికి HTTP GET మరియు POST అభ్యర్థనలు మాత్రమే ఉపయోగించబడతాయి. మరో మాటలో చెప్పాలంటే, మూడు కార్యకలాపాల కోసం - నవీకరించడం, తొలగించడం మరియు వినియోగదారుని సృష్టించడం - మేము POST అభ్యర్థనలను మాత్రమే ఉపయోగించాలి. PUT మరియు DELETE అభ్యర్థనలను ఉపయోగించడం మాకు ఎంపిక కాదు. సూత్రప్రాయంగా, ఇది చాలా సాధారణమైనది మరియు అమలు చేయడం సులభం, కానీ HiddenHttpMethodFilter తరగతి వాటిని ఉపయోగించడానికి అనుమతిస్తుంది. ఈ విధంగా, అప్లికేషన్‌లోని కార్యకలాపాల మధ్య వ్యత్యాసాన్ని రీడర్ మరింత స్పష్టంగా చూస్తారు. చివరగా, క్లయింట్ వైపు వెళ్దాం. ఇది ఐదు JSP పేజీల ద్వారా సూచించబడుతుంది. index.jsp.

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Hello!</title>
 </head>
 <body>
 If you want to start working with the user database,<br>
 click the button below:
 
 <form action = "users" method="get">
     <input type="submit" value="Start working with database">
 </form>
 </body>
 </html>
 

addUser.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Add new user</title>
 </head>
 <body>
 <form action = "/users" method="post">
     <input required type="text" name="name" placeholder="Name">
     <input required type="text" name="age" placeholder="Age">
     <input type="submit" value="Save">
 </form>
 </body>
 </html>
 
 

deleteUser.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Delete user</title>
 </head>
 <body>
 
 Are you sure you want to delete the user ${param.id}?
 
 &lform action="/users/${param.id}" method="post">
     <input type="hidden" name="id" value="${param.id}">
     <input type="hidden" name="_method" value="delete">
     <input type="submit" value="Delete">
 </form>
 
 </body>
 </html>
 
 

showUsers.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 <html>
 <head>
     <title>User list</title>
 </head>
 <body>
 <table border="2">
     <tr>
         <td>ID</td>
         <td>Name</td>
         <td>Age</td>
         <td>Actions</td>
     </tr>
     <c:forEach items="${users}" var = "user">
         <tr>
             <td>${user.getId()}</td>
             <td>${user.getName()}</td>
             <td>${user.getAge()}</td>
             <td>
                 <form action = "updateUser.jsp" method="post">
                     <input type="hidden" name="id" value="${user.getId()}">
                     <input type="hidden" name="name" value="${user.getName()}">
                     <input type="hidden" name="age" value="${user.getAge()}">
                     <input type="submit" value="Modify" style="float:left">
                 </form>
                 <form action="deleteUser.jsp" method="post">
                     <input type="hidden" name="id" value="${user.getId()}">
                     <input type="submit" value="Delete" style="float:left">
                 </form></td>
         </tr>
     </c:forEach>
 </table>
 
 <form action = "addUser.jsp">
     <input type="submit" value="Add new user">
 </form>
 </body>
 </html>

updateUser.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Modify user data</title>
 </head>
 <body>
 
 Edit user
 
 <form action="/users/${param.id}" method="post">
     <input type="hidden" name = "id" value="${param.id}">
     <input type="text" name="name" value="${param.name}" placeholder=${param.name}>
     <input type="text" name="age" value="${param.age}" placeholder=${param.age}>
     <input type="hidden" name="_method" value="put">
     <input type="submit" value="Update">
 </form>
 
 </body>
 </html>
 

JSP (JavaServer పేజీ) పేజీ రెండు రకాల టెక్స్ట్‌లను కలిగి ఉంటుంది: టెక్స్ట్ (HTML, SVG, WML, లేదా XML) వలె ఫార్మాట్ చేయగల స్టాటిక్ సోర్స్ డేటా మరియు డైనమిక్ కంటెంట్‌ను రూపొందించడానికి ఉపయోగించే JSP మూలకాలు. JSP పేజీ అంటే ఏమిటో అర్థం చేసుకోవడంలో మీకు సహాయపడటానికి, నేను చాలా మంచి వ్యాసం నుండి ఒక భాగాన్ని కాపీ చేసాను. "ప్రాథమికంగా, JSPని మొదటిసారి అభ్యర్థించినప్పుడు, అది సర్వ్‌లెట్‌గా మారుతుంది మరియు సర్వ్‌లెట్‌గా పనిచేస్తుంది. ఇది అర్థం చేసుకోవడం చాలా ముఖ్యం. JSP పేజీ HTML పేజీ లాంటిది కాదు - ఒక ప్రారంభ ప్రోగ్రామర్ ఇది మరొక సర్వ్‌లెట్ అని స్పష్టంగా అర్థం చేసుకోవాలి. — ఇది ఎలా ప్రదర్శించబడుతుందో మీరు వ్రాయనవసరం లేదు, అది ఎలా ప్రదర్శించబడుతుందో ప్రోగ్రామ్ చేయవలసి ఉంటుంది. ఇది కేవలం డ్రా చేయబడుతుంది. మరియు అవసరమైన చోట డేటాను జోడించండి. కానీ JSP పేజీ HTMLని గుర్తుకు తెస్తుంది కాబట్టి, డిజైనర్ దానిని సులభంగా కనుగొంటారు. మరియు మరోసారి ప్రారంభకులకు గట్టిగా నొక్కి చెప్పండి,JSP పేజీ ఒక SERVLET. ఇది సర్వర్‌లో మొత్తం డేటాను జోడించడంతో సహా ఉత్పత్తి చేయబడుతుంది. ఇక్కడే మొత్తం డేటా చొప్పించబడింది. మరియు బ్రౌజర్‌లో, వినియోగదారు పూర్తి చేసిన HTML పేజీని పొందుతాడు, అందులో జావా సంకేతాలు లేవు." JSP పేజీ నిజంగా సర్వ్‌లెట్ అని మీరు ఖచ్చితంగా అనుకోవచ్చు, ఎందుకంటే ప్రతి పేజీకి అమలు చేయవలసిన పద్ధతి ఉంటుంది. ఉదాహరణకు, సూచిక .jsp మీరు "డేటాబేస్‌తో పని చేయడాన్ని ప్రారంభించండి" బటన్‌పై క్లిక్ చేసినప్పుడు, పొందే పద్ధతి అమలు చేయబడుతుందని సూచిస్తుంది (పద్ధతి = "గెట్"). కొత్త వినియోగదారులను సృష్టించడానికి బాధ్యత వహించే addUser.jsp పేజీ పోస్ట్ పద్ధతిని అమలు చేస్తుంది. (పద్ధతి = "పోస్ట్") మీరు సేవ్ బటన్‌ను క్లిక్ చేసినప్పుడు. మిగిలిన JSP పేజీ సాధారణ స్టాటిక్ HTML మార్కప్‌తో రూపొందించబడింది, కాబట్టి మేము దానిపై నివసించము. ఇది మరొక కథనానికి సంబంధించిన అంశం మరియు దీనిపై పుష్కలంగా ఉన్నాయి ఇంటర్నెట్‌లో టాపిక్. కాబట్టి, మేము' మేము మా అప్లికేషన్‌ను సృష్టించాము! ఇప్పుడు మనం దానిని చర్యలో పరీక్షించాలి! దీన్ని చేయడానికి, మనకు పైన పేర్కొన్న Apache Tomcat సర్వ్లెట్ కంటైనర్ అవసరం. మీరు కంటైనర్‌ను డౌన్‌లోడ్ చేసుకోవచ్చుఅధికారిక వెబ్‌సైట్ నుండి (నేను వెర్షన్ 8ని ఉపయోగిస్తాను). తరువాత, మేము టామ్‌క్యాట్ ద్వారా మా అప్లికేషన్‌ను అమలు చేయడానికి IDEAలో కాన్ఫిగరేషన్‌ను సృష్టించాలి. దీన్ని చేయడానికి, "కాన్ఫిగరేషన్‌లను సవరించు" ట్యాబ్‌ను తెరిచి, కొత్త కాన్ఫిగరేషన్‌ను సృష్టించి, "టామ్‌క్యాట్ సర్వర్ లోకల్" ఎంచుకోండి. "అప్లికేషన్ సర్వర్" ట్యాబ్‌లో, టామ్‌క్యాట్ ఫోల్డర్‌కు మార్గాన్ని పేర్కొనండి తదుపరి, "డిప్లాయ్‌మెంట్" ట్యాబ్‌కు వెళ్లండి. ఇక్కడ, మేము స్థానిక సర్వర్‌లో మా అప్లికేషన్ యొక్క విస్తరణను కాన్ఫిగర్ చేస్తాము. "+"ని నొక్కండి, "ఆర్టిఫ్యాక్ట్" -> YourProjectName:war ఎంచుకోండి (మేము అప్లికేషన్‌ను వార్ ఫైల్‌గా రూపొందిస్తాము). మరియు దాని గురించి సంక్షిప్తంగా! "సర్వర్" పేజీలో, మా అప్లికేషన్ http://localhost:8080/లో రన్ అవుతుందని మీరు చూడవచ్చు. కాన్ఫిగరేషన్‌ని సేవ్ చేసి, దానికి పేరు పెట్టండి (నేను నా కాన్ఫిగరేషన్‌ని "టామీ" అని పిలుస్తాను). తర్వాత, IDEAలోని మావెన్ ట్యాబ్‌లో (కుడి వైపున), మేము మా ప్రాజెక్ట్‌ను వార్ ఫైల్‌గా రూపొందించడానికి వార్ ప్లగిన్‌ని ఉపయోగిస్తాము (ప్లగిన్‌లు -> వార్ -> వార్: వార్). బిల్డ్ పూర్తయిన తర్వాత, అప్లికేషన్‌ను అమలు చేసి, వేచి ఉండండి. విజయం! ప్రారంభ పేజీ ప్రారంభించబడింది. ఇప్పుడు మనం "డేటాబేస్తో పనిచేయడం ప్రారంభించండి" బటన్ను క్లిక్ చేయండి. మా index.jsp సర్వర్ ద్వారా ప్రాసెస్ చేయబడే GET అభ్యర్థనను రూపొందిస్తుంది. సర్వర్ ప్రతిస్పందనను రూపొందిస్తుంది మరియు ఇప్పటికే ఉన్న వినియోగదారులందరి జాబితా రూపంలో దానిని మాకు అందిస్తుంది (డేటాబేస్‌లో వినియోగదారులు ఉన్నారని ఊహిస్తే). మరియు అక్కడ వారు ఉన్నారు! మీ దగ్గర ఉంది! మీరు జావా సర్వ్‌లెట్‌లను ఉపయోగించి మీ మొదటి అప్లికేషన్‌ను వ్రాసారు. అది అంత చెడ్డది కాదు, అవునా? :) హోంవర్క్ కోసం, మీరు మునుపటి కథనం నుండి కారు కార్యాచరణను పునరుద్ధరించవచ్చు. మరో మాటలో చెప్పాలంటే, కార్ల కోసం ప్రత్యేక సర్వ్‌లెట్ మరియు JSP పేజీలను సృష్టించండి మరియు వినియోగదారు కార్లను జాబితా చేయడం, వినియోగదారుకు కొత్త కార్లను జోడించడం మరియు వాటిని సవరించడం మరియు తొలగించడం ఎలాగో అప్లికేషన్‌కు నేర్పండి. PS సర్వల్‌లు మరియు జావాసర్వర్ పేజీలు పురాతన సాంకేతికతలు. ఇంటర్నెట్‌లో, మీరు తరచుగా "ఈ పాత వ్యర్థం ఎవరికి కావాలి?" వంటి వ్యాఖ్యలను కనుగొనవచ్చు. సమాధానం చాలా సులభం: ప్రధానంగా నిజమైన ప్రాజెక్ట్‌లలో పనిచేసే వ్యక్తులు, ఈ సాంకేతికతలను ఉపయోగించే చాలా కోడ్‌లను వారు ఎదుర్కొనే అవకాశం ఉంది. మరియు ఇది ఎలా పని చేస్తుందో అర్థం చేసుకోకుండా, "పాత జంక్"ని కొత్తదిగా కత్తిరించడం ఇప్పటికీ సరదాగా ఉంటుంది :) JSP మరియు సర్వ్‌లెట్‌ల గురించి మరింత క్షుణ్ణంగా అధ్యయనం చేయడానికి, మీరు "హెడ్ ఫస్ట్ సర్వల్‌లు మరియు JSP" పుస్తకాన్ని చూడవచ్చు.. ఇది ప్రసిద్ధ సూపర్ పుస్తకం "హెడ్ ఫస్ట్ జావా" వలె అదే రచయితలచే వ్రాయబడింది, ఇది చాలా మంది నాణ్యతకు హామీగా తీసుకుంటారు :) ఈ వ్యాసం ఉపయోగకరంగా ఉందని నేను ఆశిస్తున్నాను! మీ శ్రద్ధకు ధన్యవాదాలు మరియు నేర్చుకోవడంలో అదృష్టం!