जावा सर्वलेट्स का उपयोग करते हुए आपका पहला एप्लिकेशन

सभी को नमस्कार! आप वेब विकास की मूल अवधारणा के रूप में सर्वलेट्स से परिचित हो जाएंगे, और आप उनका उपयोग करने वाला एक सरल एप्लिकेशन लिखने में सक्षम होंगे। अनावश्यक कार्रवाइयों से बचने के लिए, हम शून्य से प्रारंभ नहीं करेंगे. हम हाइबरनेट के बारे में अपने पिछले लेख से अपने ऐप्लिकेशन पर काम करना जारी रखेंगे । लेकिन जब से हम सर्वलेट्स से परिचित होना शुरू कर रहे हैं, मैंने एप्लिकेशन से ऑटो क्लास से संबंधित सभी चीजों को हटा दिया है और केवल यूजर क्लास और इसमें शामिल क्रियाओं को छोड़ दिया है। इस तरह तैयार होगा प्रोजेक्ट: तो, सर्वलेट्स! विकिपीडिया बताता है: "एक जावा सर्वलेट एक जावा सॉफ्टवेयर घटक है जो एक सर्वर की क्षमताओं का विस्तार करता है। हालांकि सर्वलेट्स कई प्रकार के अनुरोधों का जवाब दे सकते हैं, वे वेब सर्वर पर वेब अनुप्रयोगों को होस्ट करने के लिए वेब कंटेनरों को सबसे अधिक लागू करते हैं और इस प्रकार एक सर्वर के रूप में अर्हता प्राप्त करते हैं- साइड सर्वलेट वेब एपीआई।" यह बिल्कुल सच है। यहां, पहली बार, हम "क्लाइंट-सर्वर एप्लिकेशन आर्किटेक्चर" की अवधारणा से रूबरू हुए हैं। यह अपने मूल में काफी सरल है। क्लाइंट 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. जेएसटीएल टैग लाइब्रेरी। ग्राहक पक्ष, अर्थात् JSP पृष्ठ बनाने के लिए इसकी आवश्यकता होगी
3. स्प्रिंग-वेबएमवीसी। हमें एक स्प्रिंग क्लास की आवश्यकता होगी, जिसके बारे में हम थोड़ी देर बाद बात करेंगे।

सर्वलेट प्रबंधन सर्वलेट कंटेनर द्वारा नियंत्रित किया जाता है। हमारे मामले में, हम 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 कक्षाओं के उदाहरणों को इनपुट के रूप में स्वीकार करती हैं, यानी सर्वर को भेजे गए अनुरोध और क्लाइंट द्वारा प्राप्त प्रतिक्रियाएँ। आंतरिक रूप से, विधियाँ UserService वर्ग के प्रासंगिक तरीकों को कॉल करती हैं, और क्लाइंट के लिए एक प्रतिक्रिया उत्पन्न होती है और / उपयोगकर्ता URL पर पुनर्निर्देशित की जाती है। उदाहरण के लिए, doGet () पद्धति में, हमें सभी उपयोगकर्ताओं की एक सूची मिलती है। अगला, हम एक RequestDispatcher ऑब्जेक्ट बनाते हैं, जो हमें HTTP रिक्वेस्ट में ऑब्जेक्ट्स को शामिल करने देता है और इसे एक विशिष्ट संसाधन (उदाहरण के लिए, क्लाइंट JSP पेज पर) पर रीडायरेक्ट करता है। doPut() विधि (जो उपयोगकर्ता डेटा को अपडेट करती है) में, हम एक HTTP अनुरोध को संसाधित करते हैं, आईडी, नाम और आयु पैरामीटर निकालते हैं, उपयोगकर्ता को निर्दिष्ट आईडी के साथ ढूंढते हैं, उसे अनुरोध में नाम और उम्र निर्दिष्ट करते हैं, और वापस करते हैं /उपयोगकर्ता पृष्ठ पर। लेकिन इन सभी विधियों के सही ढंग से काम करने के लिए, हमें सर्वलेट को कॉन्फ़िगर करने की आवश्यकता है। ऐसा करने के लिए, हम 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>
 

इस फ़ाइल के सभी टैग काफी सहज ज्ञान युक्त हैं, लेकिन आइए उनके क्रम में चलते हैं। <स्वागत-फ़ाइल-सूची> - जेएसपी प्रारंभ पृष्ठ इंगित किया गया है, जो आवेदन शुरू होने पर सबसे पहले खोला जाएगा। हमारे मामले में, यह index.jsp है। <सर्वलेट> - सर्वलेट के रूप में हमारे UserSimpleServlet वर्ग का पंजीकरण। <सर्वलेट-मैपिंग> - एक बहुत ही महत्वपूर्ण टैग। यह सर्वलेट द्वारा संसाधित किए जाने वाले URL को परिभाषित करता है। हमारे मामले में, ये सभी URL हैं, इसलिए हम केवल "/" इंगित करते हैं। लेकिन अगर हमारे पास उपयोगकर्ताओं और उनकी कारों (ऑटो) से जुड़ा कोई एप्लिकेशन है, तो हम दूसरा सर्वलेट (SimpleAutoServlet) बना सकते हैं। तब उपयोगकर्ता सर्वलेट की मैपिंग "/ उपयोगकर्ता" (यानी उपयोगकर्ताओं के बारे में अनुरोध) होगी, और ऑटो सर्वलेट की मैपिंग "/ ऑटो" होगी। और अंत में, <फ़िल्टर>। आंतरिक रूप से, यह संगठन के एक उदाहरण को परिभाषित करता है। 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>
 
 

डिलीटयूजर.जेएसपी

 <%@ 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>

अद्यतन उपयोगकर्ता.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 Page) पृष्ठ में दो प्रकार के पाठ होते हैं: स्थैतिक स्रोत डेटा जिसे पाठ (HTML, SVG, WML, या XML) के रूप में स्वरूपित किया जा सकता है, और JSP तत्वों का उपयोग गतिशील सामग्री के निर्माण के लिए किया जाता है। JSP पेज क्या है, इसे समझने में आपकी मदद करने के लिए, मैंने एक बहुत अच्छे लेख से एक पैसेज कॉपी किया है। "असल में, जब पहली बार किसी JSP से अनुरोध किया जाता है, तो वह सर्वलेट में बदल जाता है और सर्वलेट के रूप में काम करता है। यह समझना बहुत महत्वपूर्ण है। एक JSP पेज HTML पेज की तरह नहीं है - एक शुरुआती प्रोग्रामर को स्पष्ट रूप से समझना चाहिए कि यह एक और सर्वलेट है। — बस इतना है कि आपको लिखने की ज़रूरत नहीं है कि यह कैसे प्रदर्शित होता है इसे प्रोग्राम करना है। इसे आसानी से खींचा जा सकता है। और जहां आवश्यक हो वहां डेटा जोड़ें। लेकिन क्योंकि एक जेएसपी पेज एचटीएमएल की याद दिलाता है, एक डिजाइनर स्पष्ट रूप से इसे आसान बना देगा। और एक बार फिर नौसिखियों पर जोर दें,एक जेएसपी पेज एक सर्वलेट है. यह सर्वर पर सभी डेटा को जोड़ने सहित उत्पन्न होता है। यहीं पर सारा डेटा डाला जाता है। और ब्राउज़र में, उपयोगकर्ता को समाप्त HTML पेज मिलता है, जिसमें जावा के संकेत नहीं होते हैं। .jsp इंगित करता है कि जब आप "डेटाबेस के साथ काम करना प्रारंभ करें" बटन पर क्लिक करते हैं, तो प्राप्त विधि निष्पादित की जाएगी (विधि = "प्राप्त करें")। AddUser.jsp पृष्ठ, जो नए उपयोगकर्ता बनाने के लिए ज़िम्मेदार है, पोस्ट विधि निष्पादित करता है (विधि = "पोस्ट") जब आप सेव बटन पर क्लिक करते हैं। शेष JSP पृष्ठ नियमित स्थिर HTML मार्कअप से बना होता है, इसलिए हम इस पर ध्यान नहीं देंगे। यह एक अन्य लेख के लिए एक विषय है और इस पर बहुत कुछ है इंटरनेट पर विषय। तो, हम' हमने अपना आवेदन बनाया है! अब हमें इसे कार्रवाई में परखने की जरूरत है! ऐसा करने के लिए, हमें ऊपर बताए गए Apache Tomcat सर्वलेट कंटेनर की आवश्यकता है। आप कंटेनर डाउनलोड कर सकते हैंआधिकारिक वेबसाइट से (मैं संस्करण 8 का उपयोग करता हूं)। अगला, हमें अपने एप्लिकेशन को टॉमकैट के माध्यम से चलाने के लिए आईडीईए में एक कॉन्फ़िगरेशन बनाने की आवश्यकता है। ऐसा करने के लिए, "कॉन्फ़िगरेशन संपादित करें" टैब खोलें, एक नया कॉन्फ़िगरेशन बनाएं और "टॉमकैट सर्वर लोकल" चुनें। "एप्लिकेशन सर्वर" टैब पर, टॉमकैट फ़ोल्डर का पथ निर्दिष्ट करें अगला, "परिनियोजन" टैब पर जाएं। यहां, हम स्थानीय सर्वर पर अपने एप्लिकेशन की तैनाती को कॉन्फ़िगर करते हैं। "+" दबाएं, "विरूपण साक्ष्य" चुनें -> YourProjectName:war (हम एप्लिकेशन को युद्ध फ़ाइल में बनाएंगे)। और वह इसके बारे में बताता है! "सर्वर" पेज पर, आप देख सकते हैं कि हमारा एप्लिकेशन http://localhost:8080/ पर चलेगा। कॉन्फ़िगरेशन सहेजें और इसे एक नाम दें (मैं अपने कॉन्फ़िगरेशन को "टॉमी" कहता हूं)। अगला, आईडिया में मावेन टैब पर (दाईं ओर), हम अपनी परियोजना को एक युद्ध फ़ाइल (प्लगइन्स -> युद्ध -> युद्ध: युद्ध) में बनाने के लिए युद्ध प्लगइन का उपयोग करेंगे। बिल्ड पूर्ण होने के बाद, एप्लिकेशन चलाएँ और प्रतीक्षा करें। सफलता! प्रारंभ पृष्ठ लॉन्च किया गया था। अब हम "डेटाबेस के साथ काम करना शुरू करें" बटन पर क्लिक करें। हमारा index.jsp एक GET अनुरोध उत्पन्न करेगा जिसे सर्वर द्वारा संसाधित किया जाएगा। सर्वर एक प्रतिक्रिया उत्पन्न करेगा और इसे सभी मौजूदा उपयोगकर्ताओं की सूची के रूप में हमें लौटाएगा (यह मानते हुए कि डेटाबेस में उपयोगकर्ता हैं, निश्चित रूप से)। और वे वहाँ हैं! वहां आपके पास है! आपने जावा सर्वलेट्स का उपयोग करते हुए अपना पहला एप्लिकेशन लिखा था। यह इतना बुरा नहीं था, है ना? :) होमवर्क के लिए, आप पिछले लेख से कार की कार्यक्षमता को पुनर्स्थापित कर सकते हैं. दूसरे शब्दों में, कारों के लिए एक अलग सर्वलेट और JSP पृष्ठ बनाएँ, और एप्लिकेशन को उपयोगकर्ता की कारों को सूचीबद्ध करने, उपयोगकर्ता में नई कारों को जोड़ने और उन्हें संपादित करने और हटाने का तरीका सिखाएँ। PS सर्वलेट्स और JavaServer पेज बल्कि प्राचीन प्रौद्योगिकियां हैं। इंटरनेट पर, आप अक्सर "इस पुराने कबाड़ की जरूरत किसे है?" जैसी टिप्पणियां पा सकते हैं। उत्तर काफी सरल है: मुख्य रूप से वे लोग जो वास्तविक परियोजनाओं पर काम करेंगे, जहाँ वे संभवतः बहुत सारे कोड का सामना कर सकते हैं जो इन तकनीकों का उपयोग करते हैं। और यहां तक ​​​​कि यह समझे बिना कि यह कैसे काम करता है, "पुराने जंक" को कुछ नए में काटना अभी भी मज़ेदार है :) JSP और सर्वलेट्स के अधिक गहन अध्ययन के लिए, आप "हेड फ़र्स्ट सर्वलेट्स और JSP" पुस्तक का उल्लेख कर सकते हैं।. यह उन्हीं लेखकों द्वारा प्रसिद्ध सुपर बुक "हेड फर्स्ट जावा" के रूप में लिखा गया था, जिसे कई लोग गुणवत्ता की गारंटी के रूप में लेंगे :) मुझे उम्मीद है कि यह लेख मददगार रहा है! आपका ध्यान के लिए धन्यवाद, और सीखने में शुभकामनाएँ!