Java servlets वापरून तुमचा पहिला अनुप्रयोग

हॅलो, प्रत्येकजण! वेब डेव्हलपमेंटची मूलभूत संकल्पना म्हणून तुम्ही सर्व्हलेट्सशी परिचित व्हाल आणि तुम्ही त्यांचा वापर करणारा एक साधा अनुप्रयोग लिहू शकाल. अनावश्यक कृती टाळण्यासाठी, आम्ही सुरवातीपासून सुरुवात करणार नाही. हायबरनेट बद्दलच्या माझ्या मागील लेखावरून आम्ही आमच्या अर्जावर काम करत राहू . परंतु आम्‍ही नुकतेच सर्वलेटशी परिचित होण्‍यास सुरुवात करत असल्‍यामुळे, मी अॅप्लिकेशनमधून ऑटो क्‍लासशी संबंधित सर्व काही काढून टाकले आहे आणि केवळ वापरकर्ता वर्ग आणि त्यात समाविष्ट असलेल्या कृती सोडल्या आहेत. प्रकल्पाची रचना याप्रमाणे केली जाईल: तर, सर्व्हलेट्स! विकिपीडिया म्हणते: "जावा सर्व्हलेट हा जावा सॉफ्टवेअर घटक आहे जो सर्व्हरच्या क्षमतेचा विस्तार करतो. जरी सर्व्हलेट्स अनेक प्रकारच्या विनंत्यांना प्रतिसाद देऊ शकतात, तरीही ते वेब सर्व्हरवर वेब अनुप्रयोग होस्ट करण्यासाठी वेब कंटेनरची अंमलबजावणी करतात आणि अशा प्रकारे सर्व्हर म्हणून पात्र होतात- साइड सर्व्हलेट वेब API." हे अगदी खरे आहे. येथे, प्रथमच, आम्ही "क्लायंट-सर्व्हर ऍप्लिकेशन आर्किटेक्चर" ची संकल्पना पाहत आहोत. हे त्याच्या मुळाशी अगदी सोपे आहे. क्लायंट HTTP विनंती पाठवून सर्व्हरवर प्रवेश करतो. सर्व्हर आवश्यक डेटा व्युत्पन्न करतो (उदाहरणार्थ, तो डेटाबेसमधून आणतो) आणि क्लायंटला परत करतो. सर्वात सोपा उदाहरण म्हणजे जेव्हा तुम्ही विशिष्ट सोशल नेटवर्कवरील "मित्र" बटणावर क्लिक करता, त्याद्वारे सर्व्हरला विनंती पाठविली जाते. सर्व्हर डेटाबेसमधील तुमच्या मित्रांची यादी अपडेट करतो आणि ती तुम्हाला (क्लायंट) परत करतो. HTTP विनंत्यांची यादी खूप मोठी आहे, म्हणून जर तुम्हाला त्या आधी कधीच भेटल्या नसतील, तर तुम्ही त्यांच्याबद्दल इतरत्र वाचणे चांगले होईल, उदाहरणार्थ,येथे _ आमचे उद्दिष्ट आहे: सर्व्हलेट्स वापरून CRUD ऍप्लिकेशन तयार करणे. HTTP विनंत्यांवर प्रक्रिया करणार्‍या सर्व्हलेटचा वापर करून डेटाबेसमधून वापरकर्ते तयार करण्यास, वाचण्यास, अद्यतनित करण्यास आणि हटविण्यास अनुप्रयोग सक्षम असणे आवश्यक आहे. हायबरनेट लेखातील आमचा अनुप्रयोग हे आधीच करू शकतो, परंतु ते थेट Java कोडवरून नियंत्रित केले गेले, अधिक अचूकपणे, main() पद्धतीवरून. या वेळी, क्लायंटच विनंत्या पाठवेल, म्हणजे तुम्हाला :) पहिली गोष्ट म्हणजे आमच्या 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. स्प्रिंग-वेबएमव्हीसी. आम्हाला एका स्प्रिंग क्लासची आवश्यकता असेल, ज्याबद्दल आम्ही थोड्या वेळाने बोलू.

सर्व्हलेट व्यवस्थापन सर्व्हलेट कंटेनरद्वारे हाताळले जाते. आमच्या बाबतीत, आम्ही Apache Tomcat वापरू. हे खूपच लोकप्रिय आहे — तुम्ही कदाचित त्याबद्दल आधीच ऐकले असेल :) सर्व्हलेट जीवन चक्रात खालील चरण असतात:

1. कंटेनरमध्ये सर्व्हलेट नसल्यास:
   
   • सर्व्हलेट क्लास कंटेनरद्वारे लोड केला जातो.
   • कंटेनर सर्व्हलेट क्लासचे उदाहरण तयार करतो.
   • कंटेनर init() पद्धतीला कॉल करतो. ही पद्धत सर्व्हलेटला आरंभ करते आणि सर्व्हलेट विनंत्या पूर्ण करण्यापूर्वी प्रथम कॉल केले जाते. संपूर्ण जीवनचक्रात, init() पद्धत फक्त एकदाच कॉल केली जाते.
2. क्लायंटच्या विनंतीची सेवा करा. प्रत्येक विनंतीवर त्याच्या स्वतंत्र थ्रेडवर प्रक्रिया केली जाते. कंटेनर प्रत्येक विनंतीसाठी service() पद्धत कॉल करतो. ही पद्धत येणार्‍या विनंतीचा प्रकार निर्धारित करते आणि प्रक्रियेसाठी योग्य पद्धतीकडे पाठवते. सर्व्हलेट डेव्हलपरने या पद्धतींसाठी अंमलबजावणी प्रदान करणे आवश्यक आहे. अंमलबजावणी न केलेल्या हँडलरसाठी विनंती आल्यास, पालक वर्गाची पद्धत कॉल केली जाते आणि सहसा विनंतीकर्त्याला त्रुटी परत करते.


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 वर्गांची उदाहरणे इनपुट म्हणून स्वीकारतात, म्हणजे सर्व्हरला पाठवलेल्या विनंत्या आणि क्लायंटला मिळालेले प्रतिसाद. अंतर्गत, पद्धती वापरकर्ता सेवा वर्गाच्या संबंधित पद्धतींना कॉल करतात आणि क्लायंटसाठी प्रतिसाद तयार केला जातो आणि /users 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>

या फाईलमधील सर्व टॅग बर्‍यापैकी अंतर्ज्ञानी आहेत, परंतु चला त्या क्रमाने पाहू. <welcome-file-list> - JSP प्रारंभ पृष्ठ सूचित केले आहे, जे अनुप्रयोग सुरू झाल्यावर प्रथम उघडले जाईल. आमच्या बाबतीत, हे index.jsp आहे. <servlet> - आमच्या UserSimpleServlet वर्गाची सर्व्हलेट म्हणून नोंदणी. <servlet-mapping> - एक अतिशय महत्त्वाचा टॅग. हे सर्व्हलेटद्वारे प्रक्रिया केलेल्या URLs परिभाषित करते. आमच्या बाबतीत, हे सर्व URL आहेत, म्हणून आम्ही फक्त "/" सूचित करतो. परंतु जर आमच्याकडे वापरकर्ते आणि त्यांच्या कार (ऑटो) चा समावेश असलेला अनुप्रयोग असेल तर आम्ही दुसरे सर्व्हलेट (सिंपलऑटोसर्व्हलेट) तयार करू शकतो. मग वापरकर्ता सर्व्हलेटचे मॅपिंग "/users" (म्हणजे वापरकर्त्यांबद्दलच्या विनंत्या) असेल आणि ऑटो सर्व्हलेटचे मॅपिंग "/autos" असेल. आणि शेवटी, <filter>. अंतर्गत, ते org चे उदाहरण परिभाषित करते. springframework.web.filter.HiddenHttpMethodFilter वर्ग. हा लेख वसंत ऋतु बद्दल नाही, म्हणून मी त्याचे तपशीलवार वर्णन करणार नाही. मी फक्त असे म्हणेन की ते आमच्या ऍप्लिकेशनवर फक्त अतिरिक्त वैशिष्ट्य म्हणून बोल्ड केले आहे. गोष्ट अशी आहे की क्लायंट साइड तयार करण्यासाठी आम्ही JSP पृष्ठे वापरणार आहोत. आमचा डेटा पृष्ठावर वापरकर्त्यांच्या सूचीसह टेबलच्या रूपात प्रदर्शित केला जाईल. JSP पृष्ठांच्या आत, <form/> HTML टॅग वापरले जातील. परंतु <फॉर्म/> वरून डेटा पाठवण्यासाठी फक्त 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 पृष्ठासारखे नसते - सुरुवातीच्या प्रोग्रामरला हे स्पष्टपणे समजले पाहिजे की हे दुसरे सर्व्हलेट आहे. — तुम्ही लिहू नका की ते कसे प्रदर्शित केले जाते ते प्रोग्राम करावे लागेल. ते फक्त काढले जाऊ शकते. आणि आवश्यक असेल तेथे डेटा जोडा. परंतु जेएसपी पृष्ठ HTML ची आठवण करून देणारे असल्यामुळे, डिझाइनरला ते सोपे होईल. आणि पुन्हा एकदा नवशिक्यांवर जोरदार जोर द्या,JSP पृष्ठ एक सर्व्हलेट आहे. सर्व्हरवर सर्व डेटा जोडण्यासह ते व्युत्पन्न केले जाते. येथे सर्व डेटा समाविष्ट केला जातो. आणि ब्राउझरमध्ये, वापरकर्त्याला पूर्ण झालेले एचटीएमएल पृष्ठ मिळते, ज्यामध्ये जावाची चिन्हे नाहीत." तुम्ही खात्री बाळगू शकता की जेएसपी पृष्ठ खरोखरच एक सर्व्हलेट आहे, कारण प्रत्येक पृष्ठावर एक पद्धत आहे जी कार्यान्वित करणे आवश्यक आहे. उदाहरणार्थ, अनुक्रमणिका .jsp सूचित करते की जेव्हा तुम्ही "डेटाबेससह कार्य करण्यास प्रारंभ करा" बटणावर क्लिक कराल, तेव्हा गेट पद्धत कार्यान्वित केली जाईल (पद्धत = "मिळवा"). addUser.jsp पृष्ठ, जे नवीन वापरकर्ते तयार करण्यासाठी जबाबदार आहे, पोस्ट पद्धत कार्यान्वित करते. (पद्धत = "पोस्ट") जेव्हा तुम्ही सेव्ह बटणावर क्लिक करता. बाकीचे JSP पेज नियमित स्टॅटिक एचटीएमएल मार्कअपने बनलेले असते, त्यामुळे आम्ही त्यावर विचार करणार नाही. हा दुसर्‍या लेखाचा विषय आहे आणि त्यावर बरेच काही आहेत. इंटरनेटवरील विषय. म्हणून, आम्ही' आमचा अर्ज तयार केला आहे! आता आपण कृतीत चाचणी करणे आवश्यक आहे! हे करण्यासाठी, आम्हाला वर नमूद केलेल्या Apache Tomcat सर्व्हलेट कंटेनरची आवश्यकता आहे. आपण कंटेनर डाउनलोड करू शकताअधिकृत वेबसाइटवरून (मी आवृत्ती 8 वापरतो). पुढे, Tomcat द्वारे आमचा अनुप्रयोग चालवण्यासाठी आम्हाला IDEA मध्ये एक कॉन्फिगरेशन तयार करावे लागेल. हे करण्यासाठी, "कॉन्फिगरेशन संपादित करा" टॅब उघडा, नवीन कॉन्फिगरेशन तयार करा आणि "टॉमकॅट सर्व्हर लोकल" निवडा. "ऍप्लिकेशन सर्व्हर" टॅबवर, टॉमकॅट फोल्डरचा मार्ग निर्दिष्ट करा पुढे, "डिप्लॉयमेंट" टॅबवर जा. येथे, आम्ही स्थानिक सर्व्हरवर आमच्या अनुप्रयोगाची तैनाती कॉन्फिगर करतो. "+" दाबा, "आर्टिफॅक्ट" निवडा -> YourProjectName:war (आम्ही अॅप्लिकेशन वॉर फाइलमध्ये तयार करू). आणि ते बेरीज करते! "सर्व्हर" पृष्ठावर, आपण पाहू शकता की आमचा अनुप्रयोग http://localhost:8080/ वर चालेल. कॉन्फिगरेशन सेव्ह करा आणि त्याला एक नाव द्या (मी माझ्या कॉन्फिगरेशनला "टॉमी" म्हणतो). पुढे, IDEA मधील मावेन टॅबवर (उजवीकडे), आम्ही वॉर प्लगइनचा वापर वॉर फाइलमध्ये (प्लगइन्स -> वॉर -> वॉर: वॉर) आमचा प्रोजेक्ट तयार करण्यासाठी करू. बिल्ड पूर्ण झाल्यानंतर, अनुप्रयोग चालवा आणि प्रतीक्षा करा. यश! प्रारंभ पृष्ठ सुरू केले. आता आम्ही "डेटाबेससह कार्य करणे प्रारंभ करा" बटणावर क्लिक करा. आमची index.jsp एक GET विनंती व्युत्पन्न करेल ज्यावर सर्व्हरद्वारे प्रक्रिया केली जाईल. सर्व्हर प्रतिसाद व्युत्पन्न करेल आणि सर्व विद्यमान वापरकर्त्यांच्या सूचीच्या स्वरूपात आम्हाला परत करेल (अर्थात डेटाबेसमध्ये वापरकर्ते आहेत असे गृहीत धरून). आणि ते तिथे आहेत! की तिथे तुमच्याकडे आहे! तुम्ही तुमचा पहिला अर्ज Java servlets वापरून लिहिला. ते इतके वाईट नव्हते ना? :) गृहपाठासाठी, तुम्ही मागील लेखातील कारची कार्यक्षमता पुनर्संचयित करू शकता. दुसऱ्या शब्दांत, कारसाठी स्वतंत्र सर्व्हलेट आणि JSP पृष्ठे तयार करा आणि वापरकर्त्याच्या कारची यादी कशी करायची, वापरकर्त्याला नवीन कार कशी जोडायची आणि ती संपादित करून हटवायची हे अॅप्लिकेशनला शिकवा. PS सर्व्हलेट्स आणि JavaServer पेज हे त्याऐवजी प्राचीन तंत्रज्ञान आहेत. इंटरनेटवर, तुम्हाला अनेकदा "या जुन्या रद्दीची कोणाला गरज आहे?" उत्तर अगदी सोपे आहे: मुख्यतः जे लोक वास्तविक प्रकल्पांवर काम करतील, जेथे त्यांना कदाचित या तंत्रज्ञानाचा वापर करणारे बरेच कोड येऊ शकतात. आणि ते कसे कार्य करते हे समजल्याशिवाय, "जुन्या जंक" मध्ये नवीन काहीतरी कापून टाकणे अद्याप मजेदार आहे :) JSP आणि सर्व्हलेट्सच्या अधिक सखोल अभ्यासासाठी, आपण " हेड फर्स्ट सर्व्हलेट्स आणि जेएसपी" पुस्तकाचा संदर्भ घेऊ शकता.. हे प्रसिद्ध सुपर बुक "हेड फर्स्ट जावा" सारख्याच लेखकांनी लिहिले होते, जे अनेकजण गुणवत्तेची हमी म्हणून घेतील :) मला आशा आहे की हा लेख उपयुक्त ठरला आहे! तुमचे लक्ष दिल्याबद्दल धन्यवाद, आणि शिकण्यात शुभेच्छा!