แอปพลิเคชันแรกของคุณที่ใช้เซิร์ฟเล็ต Java

สวัสดีทุกคน! ในบทความนี้ คุณจะคุ้นเคยกับแนวคิดการพัฒนาเว็บขั้นพื้นฐานของเซิร์ฟเล็ต และสามารถเขียนแอปพลิเคชันง่ายๆ โดยใช้สิ่งเหล่านี้ได้ เพื่อหลีกเลี่ยงขั้นตอนที่ไม่จำเป็น เราจะไม่เริ่มต้นใหม่ทั้งหมด และจะดำเนินการกับแอปพลิเคชันของเราต่อไปจากบทความก่อนหน้าของฉันเกี่ยวกับ Hibernate อย่างไรก็ตาม เนื่องจากเราเพิ่งเริ่มต้นใช้งานเซิร์ฟเล็ต ฉันจึงลบทุกอย่างที่เกี่ยวข้องกับคลาส Auto ออกจากแอปพลิเคชัน และเหลือเพียงคลาส User และการดำเนินการเท่านั้น โครงสร้างโปรเจ็กต์จะมีลักษณะดังนี้: ดังนั้น เซิร์ฟเล็ต! วิกิพีเดียกล่าวว่า: "เซิร์ฟเล็ตเป็นอินเทอร์เฟซจาวาที่มีการนำไปใช้ขยายฟังก์ชันการทำงานของเซิร์ฟเวอร์ เซิร์ฟเล็ตโต้ตอบกับไคลเอนต์ผ่านหลักการตอบสนองต่อคำขอ" และก็เป็นเช่นนั้นจริงๆ ที่นี่เราจะพบกับแนวคิดของ "สถาปัตยกรรมแอปพลิเคชันไคลเอนต์-เซิร์ฟเวอร์" ก่อน สาระสำคัญของมันค่อนข้างเรียบง่ายและลงตัวเป็นภาพเดียว (นำมาจาก ที่นี่ ) ไคลเอนต์ติดต่อกับเซิร์ฟเวอร์โดยการส่งคำขอ HTTP เซิร์ฟเวอร์จะสร้างข้อมูลที่จำเป็น (เช่น ได้รับจากฐานข้อมูล) และส่งคืนไปยังไคลเอนต์ ตัวอย่างที่ง่ายที่สุด: บนเครือข่ายโซเชียลบางแห่งคุณคลิกที่ปุ่ม "เพื่อน" แล้วจึงส่งคำขอไปยังเซิร์ฟเวอร์ เซิร์ฟเวอร์จะตรวจสอบรายชื่อเพื่อนของคุณในฐานข้อมูลและส่งคืนให้คุณ (ลูกค้า) รายการคำขอ HTTP มีขนาดค่อนข้างใหญ่ แต่ถ้าคุณไม่เคยพบมาก่อน ดังนั้นเพื่อความเข้าใจที่ดีขึ้น ควรอ่านเกี่ยวกับพวกเขา เช่น ที่นี่ . งานของเราคือ: สร้างแอปพลิเคชัน CRUD โดยใช้เซิร์ฟเล็ต แอปพลิเคชันจะต้องสามารถสร้าง แก้ไข และลบผู้ใช้ออกจากฐานข้อมูลโดยใช้เซิร์ฟเล็ตที่ประมวลผลคำขอ HTTP แอปพลิเคชันของเราจากบทความเกี่ยวกับ Hibernate รู้วิธีการทำเช่นนี้แล้ว แต่มันถูกควบคุมโดยตรงจากโค้ด 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. Spring-WebMVC. เราจำเป็นต้องมีคลาส Spring หนึ่งคลาส ซึ่งเราจะพูดถึงในภายหลัง

การทำงานของเซิร์ฟเล็ตได้รับการจัดการโดยคอนเทนเนอร์เซิร์ฟเล็ต ในกรณีของเรา เราจะใช้ Apache Tomcat ค่อนข้างเป็นที่นิยม และคุณคงเคยได้ยินเรื่องนี้มาแล้ว :) วงจรชีวิตของเซิร์ฟเล็ตประกอบด้วยขั้นตอนต่อไปนี้:

1. หากไม่มีเซิร์ฟเล็ตในคอนเทนเนอร์
   
   • คลาสเซิร์ฟเล็ตถูกโหลดโดยคอนเทนเนอร์
   • คอนเทนเนอร์สร้างอินสแตนซ์ของคลาสเซิร์ฟเล็ต
   • คอนเทนเนอร์เรียกเมธอด init() เมธอดนี้จะเตรียมข้อมูลเบื้องต้นให้กับเซิร์ฟเล็ตและถูกเรียกก่อนก่อนที่เซิร์ฟเล็ตจะสามารถรองรับการร้องขอได้ เมธอด init() ถูกเรียกเพียงครั้งเดียวตลอดวงจรการใช้งาน
2. ให้บริการตามคำขอของลูกค้า คำขอแต่ละรายการได้รับการประมวลผลในเธรดแยกของตัวเอง คอนเทนเนอร์เรียกใช้เมธอด service() สำหรับแต่ละคำขอ วิธีนี้จะกำหนดประเภทของคำขอที่เข้ามาและกระจายไปยังวิธีที่สอดคล้องกับประเภทนี้เพื่อประมวลผลคำขอ ผู้พัฒนาเซิร์ฟเล็ตต้องจัดเตรียมการใช้งานสำหรับวิธีการเหล่านี้ หากได้รับการร้องขอโดยที่ไม่ได้ใช้เมธอด เมธอดของคลาสพาเรนต์จะถูกเรียกและมักจะจบลงด้วยข้อผิดพลาดที่ส่งคืนไปยังผู้ร้องขอ
3. ในกรณีที่คอนเทนเนอร์จำเป็นต้องลบเซิร์ฟเล็ต จะเรียกใช้เมธอด destroy() ซึ่งจะลบเซิร์ฟเล็ตออกจากบริการ เช่นเดียวกับเมธอด 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() ดังที่อธิบายไว้ข้างต้น และใช้ 4 วิธีที่ตรงกับคำขอ HTTP สี่คำขอ - doGet(), doPost(), doPut() และ doDelete() แต่ละรายการจะอนุญาตให้เรารับ สร้าง แก้ไข และลบผู้ใช้ตามลำดับ วิธีการดังกล่าวใช้เป็นอ็อบเจ็กต์อินพุตของคลาส javax.servlet.http.HttpServletRequest และ javax.servlet.http.HttpServletResponse นั่นคือ คำขอที่ส่งไปยังเซิร์ฟเวอร์และการตอบกลับที่ไคลเอ็นต์ได้รับ ภายในวิธีการดังกล่าว จะมีการดำเนินการวิธีการที่จำเป็นของคลาส UserService สร้างการตอบกลับสำหรับลูกค้า จากนั้นจึงเปลี่ยนเส้นทางไปยังที่อยู่ /users ตัวอย่างเช่น ในเมธอด doGet() เราจะได้รายชื่อผู้ใช้ทั้งหมด ต่อไป เราสร้างอ็อบเจ็กต์ของคลาส RequestDispatcher ซึ่งอนุญาตให้เรารวมอ็อบเจ็กต์ในคำขอ Http รวมทั้งเปลี่ยนเส้นทางไปยังทรัพยากรเฉพาะ (เช่น เพจ JSP ไคลเอ็นต์) ในเมธอด doPut() (การอัปเดตข้อมูลผู้ใช้) เราประมวลผลคำขอ HTTP แยกพารามิเตอร์ id ชื่อและอายุจากนั้นค้นหาผู้ใช้ด้วย id ที่ระบุ กำหนดชื่อและอายุที่มาพร้อมกับเขาใน ร้องขอและกลับสู่หน้า /users อย่างไรก็ตาม เพื่อให้วิธีการทั้งหมดนี้ทำงานได้อย่างถูกต้อง เราจำเป็นต้องกำหนดค่าเซิร์ฟเล็ต สำหรับสิ่งนี้ เราใช้ไฟล์ web.xml ในโฟลเดอร์ WEB-INF

<?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 ทั้งหมด ดังนั้นเราจึงระบุเพียง "/" แต่ ตัวอย่างเช่น หากเรามีแอปพลิเคชันที่มีผู้ใช้และเครื่องของพวกเขา เราก็สามารถสร้างเซิร์ฟเล็ตที่สอง - SimpleAutoServlet จากนั้นการแมปสำหรับเซิร์ฟเล็ตผู้ใช้จะเป็น “/users” (นั่นคือ คำขอที่เกี่ยวข้องกับการประมวลผลผู้ใช้) และสำหรับเซิร์ฟเล็ตอัตโนมัติ มันจะเป็น “/autos” และสุดท้าย <ตัวกรอง> มันกำหนดภายในวัตถุของคลาส org.springframework.web.filter.HiddenHttpMethodFilter บทความนี้ไม่เกี่ยวกับ Spring ดังนั้นฉันจะไม่พูดถึงรายละเอียด ฉันขอบอกว่ามันแนบมากับแอปพลิเคชันของเราเป็นคุณสมบัติเพิ่มเติมเท่านั้น ประเด็นก็คือเราจะใช้เพจ JSP เพื่อสร้างฝั่งไคลเอ็นต์ ข้อมูลของเราจะแสดงบนหน้าเป็นตารางพร้อมรายชื่อผู้ใช้ ภายในหน้า JSP จะมีการใช้แท็ก HTML <form/> และมีเพียงคำขอ HTTP GET และ POST เท่านั้นที่สามารถใช้เพื่อส่งข้อมูลจาก <form/> นั่นคือสำหรับการดำเนินการทั้งสามอย่าง - อัปเดต การลบ และการสร้างผู้ใช้ - เราจะต้องใช้เฉพาะคำขอ POST เท่านั้น เราไม่สามารถใช้คำขอ PUT และ DELETE ได้ และตามหลักการแล้ว นี่เป็นเรื่องปกติและง่ายต่อการนำไปใช้ แต่คลาส HiddenHttpMethodFilter ช่วยให้เราสามารถใช้งานได้ สิ่งนี้จะทำให้ผู้อ่านเห็นความแตกต่างระหว่างการดำเนินการในแอปพลิเคชันชัดเจนยิ่งขึ้น สุดท้าย เรามาดูฝั่งไคลเอ็นต์กันดีกว่า มันถูกแสดงด้วยเพจ JSP ห้าเพจ ดัชนี.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Здравствуйте!</title>
</head>
<body>
Если вы хотите начать работу с базой данных пользователей - <br>
нажмите кнопку ниже:

<form action = "users" method="get">
    <input type="submit" value="Начать работу с базой данных">
</form>
</body>
</html>

addUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Добавить нового пользователя</title>
</head>
<body>
<form action = "/users" method="post">
    <input required type="text" name="name" placeholder="Name">
    <input required type="text" name="age" placeholder="Возраст">
    <input type="submit" value="Сохранить">
</form>
</body>
</html>

ลบUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Удалить пользователя</title>
</head>
<body>

Вы действительно хотите удалить пользователя ${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="Удалить">
</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>Список пользователей</title>
</head>
<body>
<table border="2">
    <tr>
        <td>ID</td>
        <td>Name</td>
        <td>Возраст</td>
        <td>Действия</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="Изменить" style="float:left">
                </form>
                <form action="deleteUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="submit" value="Удалить" style="float:left">
                </form></td>
        </tr>
    </c:forEach>
</table>

<form action = "addUser.jsp">
    <input type="submit" value="Добавить нового пользователя">
</form>
</body>
</html>

updateUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Изменить данные пользователя</title>
</head>
<body>

Редактировать пользователя

<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="Обновить">
</form>

</body>
</html>

หน้า JSP (หน้าเซิร์ฟเวอร์ Java) มีข้อความสองประเภท: ข้อมูลต้นฉบับคงที่ ซึ่งสามารถอยู่ในรูปแบบข้อความรูปแบบใดรูปแบบหนึ่ง (HTML, SVG, WML หรือ XML) และองค์ประกอบ JSP ซึ่งสร้างเนื้อหาแบบไดนามิก เพื่อทำความเข้าใจว่า JSP คืออะไร ฉันจะอนุญาตให้ตัวเองคัดลอกและวางบทความที่ดีมากโดยผู้เขียนคนหนึ่ง ( จากที่นี่ ) "โดยพื้นฐานแล้ว JSP จะถูกแปลงเป็นเซิร์ฟเล็ตในครั้งแรกที่มีการเข้าถึงและทำงานเป็นเซิร์ฟเล็ต สิ่งนี้สำคัญมากที่จะเข้าใจJSP ไม่ใช่เพจเหมือนเพจ HTML - เป็นสิ่งสำคัญสำหรับโปรแกรมเมอร์มือใหม่ที่จะเข้าใจอย่างชัดเจนว่าสิ่งนี้ เป็นเซิร์ฟเล็ตอื่น - คุณเพียงแค่ไม่จำเป็นต้องเขียนโปรแกรมเอาต์พุต คุณสามารถวาด และแทนที่ข้อมูลในตำแหน่งที่ถูกต้อง แต่เนื่องจากหน้า JSP อย่างน้อยก็มีลักษณะคล้ายกับ HTML มันจึงจะง่ายกว่าสำหรับนักออกแบบอย่างเห็นได้ชัด และฉันขอบอกผู้เริ่มต้นอีกครั้งอย่างจริงจัง - JSP คือ SERVLETมันถูกจัดเตรียมด้วยข้อมูลทั้งหมดบนเซิร์ฟเวอร์ นี่คือที่ที่ข้อมูลทั้งหมดถูกแทรก และผู้ใช้จะได้รับหน้า HTML สำเร็จรูปในเบราว์เซอร์ซึ่งไม่ได้ มีสัญญาณของ Java" คุณสามารถเห็นได้ด้วยตัวเองว่าเพจ JSP นั้นเป็นเซิร์ฟเล็ตจริงๆ เนื่องจากแต่ละเพจมีเมธอดที่ต้องดำเนินการ ตัวอย่างเช่น หน้าเริ่มต้น index.jsp ระบุว่าเมื่อคุณคลิกที่ปุ่ม "เริ่มทำงานกับฐานข้อมูล" method="get" จะถูกดำเนินการ ในหน้า addUser.jsp ซึ่งมีหน้าที่สร้างผู้ใช้ใหม่ เมื่อคุณคลิกที่ปุ่มบันทึก method="post" จะถูกดำเนินการ JSP ที่เหลือประกอบด้วยมาร์กอัป HTML แบบคงที่ทั่วไปดังนั้นเราจะไม่เจาะลึกรายละเอียดเหล่านี้ - นี่คือหัวข้อของบทความแยกต่างหากซึ่งมีอยู่มากมายบนอินเทอร์เน็ต ดังนั้นเราจึงสร้างแอปพลิเคชันของเรา สิ่งที่เหลืออยู่คือการทดสอบการใช้งานจริง! ในการดำเนินการนี้ เราจำเป็นต้องมีคอนเทนเนอร์เซิร์ฟเล็ต Apache Tomcat ที่กล่าวถึงข้างต้น คุณสามารถดาวน์โหลด cat ได้จากเว็บไซต์อย่างเป็นทางการ (ฉันใช้เวอร์ชัน 8) ต่อไป เราต้องสร้างการกำหนดค่าใน IDEA เพื่อรันแอปพลิเคชันของเราผ่าน Tomcat ในการดำเนินการนี้ ให้เปิดแท็บ "แก้ไขการกำหนดค่า" สร้างการกำหนดค่าใหม่ และเลือก Tomcat Server Local ในแท็บ Application Server ระบุเส้นทางไปยังโฟลเดอร์ที่ Tomcat ตั้งอยู่ จากนั้นไปที่แท็บ Deployment ที่นี่เรากำหนดค่าการปรับใช้แอปพลิเคชันของเราบนเซิร์ฟเวอร์ภายในเครื่อง คลิก "+" เลือก "สิ่งประดิษฐ์" -> ชื่อโครงการของคุณ: war (เราจะรวบรวมแอปพลิเคชันเป็นไฟล์ war) โดยพื้นฐานแล้วมันเป็น! ในหน้า "เซิร์ฟเวอร์" คุณจะเห็นว่าแอปพลิเคชันเดียวกันจะทำงานที่ "http://localhost:8080/" บันทึกการกำหนดค่านี้และตั้งชื่อบางอย่าง (ชื่อการกำหนดค่าของฉันคือ “Tommy”) ถัดไป บนแท็บ Maven ใน IDEA (ทางด้านขวา) เราจะใช้ปลั๊กอิน war เพื่อสร้างโปรเจ็กต์ของเราให้เป็นไฟล์ war (ปลั๊กอิน -> war -> war:war) ความสำเร็จ! หน้าเริ่มต้นได้เปิดตัวแล้ว ตอนนี้คลิกที่ปุ่ม "เริ่มทำงานกับฐานข้อมูล" หน้า JSP ของเรา index.jsp จะสร้างคำขอ GET ที่เซิร์ฟเวอร์จะประมวลผล เซิร์ฟเวอร์จะสร้างการตอบกลับและส่งคืนให้เราในรูปแบบของรายการผู้ใช้ที่มีอยู่ทั้งหมด (หากแน่นอนว่าพวกเขาอยู่ในฐานข้อมูล) และนี่คือ! ลองลบผู้ใช้รายหนึ่งออก: มันก็ใช้ได้เช่นกัน! ดังนั้นเราจึงเขียนแอปพลิเคชันแรกของเราโดยใช้เซิร์ฟเล็ต อย่างที่คุณเห็นทุกอย่างกลายเป็นเรื่องง่าย :) ในการบ้านคุณสามารถคืนฟังก์ชันการทำงานกับรถยนต์จากบทความก่อนหน้าไปยังแอปพลิเคชันได้ เหล่านั้น. สร้างเซิร์ฟเล็ตและหน้า jsp แยกต่างหากสำหรับรถยนต์ และสอนแอปพลิเคชันของเราให้แสดงรายการรถยนต์ของผู้ใช้ เพิ่มรถยนต์ใหม่ให้กับเขา รวมถึงแก้ไขและลบรถยนต์เหล่านั้น PS Servlets และ JSP เป็นเทคโนโลยีที่ค่อนข้างโบราณ และบนอินเทอร์เน็ต คุณมักจะพบความคิดเห็นในจิตวิญญาณของ "ใครต้องการขยะนี้" คำตอบนั้นค่อนข้างง่าย - จำเป็นสำหรับผู้ที่จะทำงานในโครงการจริงเป็นหลักซึ่งค่อนข้างเป็นไปได้ที่จะมีการเขียนโค้ดจำนวนมากโดยใช้สิ่งเหล่านี้ และการนำ "ของเก่า" ไปสู่สิ่งใหม่โดยไม่ต้องเข้าใจว่ามันทำงานอย่างไร แต่ก็ยังน่ายินดี :) สำหรับการศึกษาหัวข้อของ JSP และเซิร์ฟเล็ตอย่างละเอียดยิ่งขึ้น คุณสามารถใช้หนังสือ " Head First Servlets และ JSP" (ใน ภาษาอังกฤษเท่านั้น). เขียนโดยผู้เขียนคนเดียวกันกับซุปเปอร์บุคชื่อดัง "Head First Java" ซึ่งสำหรับหลาย ๆ คนสามารถรับประกันคุณภาพได้ :) ฉันหวังว่าบทความนี้จะเป็นประโยชน์กับผู้อ่าน! หากต้องการดูบทความใหม่ๆ อย่าลืมสนับสนุนผู้เขียนในการแข่งขันด้วยการกด "Like" เขา หรือดีกว่า - "ฉันชอบมันมาก" :) ขอบคุณสำหรับความสนใจและขอให้โชคดีในการเรียน!