แอปพลิเคชันแรกของคุณโดยใช้ Java servlets

สวัสดีทุกคน! คุณจะคุ้นเคยกับเซิร์ฟเล็ตในฐานะแนวคิดพื้นฐานของการพัฒนาเว็บ และคุณจะสามารถเขียนแอปพลิเคชันง่ายๆ ที่ใช้งานได้ เพื่อหลีกเลี่ยงการกระทำที่ไม่จำเป็น เราจะไม่เริ่มต้นจากศูนย์ เราจะดำเนินการกับแอปพลิเคชันของเราต่อจากบทความก่อนหน้าของฉันเกี่ยวกับ Hibernate แต่เนื่องจากเราเพิ่งเริ่มคุ้นเคยกับเซิร์ฟเล็ต ฉันจึงลบทุกอย่างที่เกี่ยวข้องกับคลาสอัตโนมัติออกจากแอปพลิเคชัน และเหลือไว้เฉพาะคลาสผู้ใช้และการดำเนินการที่เกี่ยวข้อง โครงการจะมีโครงสร้างดังนี้: ดังนั้น เซิร์ฟเล็ต! Wikipedia ระบุว่า: "เซิร์ฟเล็ต Java เป็นส่วนประกอบซอฟต์แวร์ Java ที่ขยายขีดความสามารถของเซิร์ฟเวอร์ แม้ว่าเซิร์ฟเล็ตจะสามารถตอบสนองคำขอได้หลายประเภท แต่โดยทั่วไปแล้วเซิร์ฟเล็ตจะใช้คอนเทนเนอร์เว็บสำหรับการโฮสต์เว็บแอปพลิเคชันบนเว็บเซิร์ฟเวอร์ ดังนั้นจึงมีคุณสมบัติเป็นเซิร์ฟเวอร์- API เว็บเซิร์ฟเล็ตด้านข้าง" นี่เป็นเรื่องจริง ที่นี่ เป็นครั้งแรกที่เราได้พบกับแนวคิดของ "สถาปัตยกรรมแอปพลิเคชันไคลเอ็นต์-เซิร์ฟเวอร์" มันค่อนข้างง่ายที่แกนกลางของมัน ไคลเอนต์เข้าถึงเซิร์ฟเวอร์โดยส่งคำขอ 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. เราต้องการคลาสฤดูใบไม้ผลิหนึ่งคลาสซึ่งเราจะพูดถึงในภายหลัง

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

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 สี่รายการ: doPost(), doGet(), doPut() และ doDelete() พวกเขาให้เราสร้าง อ่าน อัปเดต และลบผู้ใช้ เมธอดยอมรับอินสแตนซ์ของคลาส javax.servlet.http.HttpServletRequest และ javax.servlet.http.HttpServletResponse เป็นอินพุต เช่น คำขอที่ส่งไปยังเซิร์ฟเวอร์และการตอบสนองที่ไคลเอ็นต์ได้รับ ภายใน เมธอดเรียกเมธอดที่เกี่ยวข้องของคลาส UserService และการตอบสนองสำหรับลูกค้าจะถูกสร้างขึ้นและเปลี่ยนเส้นทางไปยัง /users URL ตัวอย่างเช่น ในเมธอด 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) จากนั้นการแมปของ servlet ของผู้ใช้จะเป็น "/users" (เช่น คำขอเกี่ยวกับผู้ใช้) และการแมปของ auto servlet จะเป็น "/autos" และสุดท้าย <ตัวกรอง> ภายในจะกำหนดอินสแตนซ์ขององค์กร springframework.web.filter.HiddenHttpMethodFilter คลาส บทความนี้ไม่เกี่ยวกับฤดูใบไม้ผลิ ดังนั้นฉันจะไม่อธิบายโดยละเอียด ฉันจะบอกว่ามันเชื่อมต่อกับแอปพลิเคชันของเราเป็นคุณสมบัติเพิ่มเติมเท่านั้น ประเด็นคือเราจะใช้หน้า JSP เพื่อสร้างฝั่งไคลเอ็นต์ ข้อมูลของเราจะแสดงบนหน้าเว็บเป็นตารางพร้อมรายชื่อผู้ใช้ ภายในหน้า JSP จะใช้แท็ก <form/> HTML แต่สามารถใช้ได้เฉพาะคำขอ HTTP GET และ POST ในการส่งข้อมูลจาก <form/> กล่าวอีกนัยหนึ่ง สำหรับการดำเนินการทั้งสามอย่าง — การอัปเดต การลบ และสร้างผู้ใช้ — เราจะต้องใช้คำขอ 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>

อัปเดต User.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 — โปรแกรมเมอร์มือใหม่ต้องเข้าใจอย่างชัดเจนว่านี่คือเซิร์ฟเล็ตอื่น — แค่คุณไม่ต้องเขียนโปรแกรมว่าจะแสดงอย่างไร วาดได้ง่ายๆ และเพิ่มข้อมูลเมื่อจำเป็น แต่เนื่องจากหน้า JSP ชวนให้นึกถึง HTML นักออกแบบจะพบว่าง่ายขึ้นอย่างเห็นได้ชัด และอีกครั้ง เน้นอย่างยิ่งสำหรับผู้เริ่มต้นหน้า JSP คือ SERVLET. มันถูกสร้างขึ้นรวมถึงการเพิ่มข้อมูลทั้งหมดบนเซิร์ฟเวอร์ นี่คือที่ที่ข้อมูลทั้งหมดถูกแทรก และในเบราว์เซอร์ ผู้ใช้จะได้รับหน้า HTML ที่เสร็จสมบูรณ์ซึ่งไม่มีสัญญาณของ Java" คุณสามารถมั่นใจได้ว่าหน้า JSP เป็นเซิร์ฟเล็ตจริงๆ เพราะแต่ละหน้ามีเมธอดที่ต้องดำเนินการ ตัวอย่างเช่น ดัชนี .jsp ระบุว่าเมื่อคุณคลิกที่ปุ่ม "เริ่มทำงานกับฐานข้อมูล" เมธอด get จะถูกดำเนินการ (เมธอด = "get") หน้า addUser.jsp ซึ่งมีหน้าที่สร้างผู้ใช้ใหม่จะดำเนินการเมธอดโพสต์ (method = "post") เมื่อคุณคลิกปุ่มบันทึก ส่วนที่เหลือของหน้า JSP นั้นประกอบด้วยมาร์กอัป HTML แบบสแตติกทั่วไป ดังนั้นเราจะไม่พูดถึงมัน นั่นเป็นหัวข้อสำหรับบทความอื่น และยังมีอีกมากมายเกี่ยวกับเรื่องนี้ หัวข้อบนอินเทอร์เน็ต ดังนั้น เราได้สร้างแอปพลิเคชันของเราแล้ว! ตอนนี้เราต้องทดสอบการใช้งานจริง! ในการทำเช่นนี้ เราจำเป็นต้องมีคอนเทนเนอร์เซิร์ฟเล็ต Apache Tomcat ที่กล่าวถึงข้างต้น คุณสามารถดาวน์โหลดคอนเทนเนอร์จากเว็บไซต์อย่างเป็นทางการ (ฉันใช้เวอร์ชัน 8) ต่อไป เราต้องสร้างการกำหนดค่าใน IDEA เพื่อเรียกใช้แอปพลิเคชันของเราผ่าน Tomcat ในการทำเช่นนี้ ให้เปิดแท็บ "แก้ไขการกำหนดค่า" สร้างการกำหนดค่าใหม่ และเลือก "Tomcat Server Local" บนแท็บ "Application Server" ให้ระบุพาธไปยังโฟลเดอร์ Tomcat จากนั้นไปที่แท็บ "Deployment" ที่นี่ เรากำหนดค่าการปรับใช้แอปพลิเคชันของเราบนเซิร์ฟเวอร์ภายในเครื่อง กด "+" เลือก "Artifact" -> YourProjectName:war (เราจะสร้างแอปพลิเคชันเป็นไฟล์ war) และนั่นก็เป็นบทสรุป! ในหน้า "เซิร์ฟเวอร์" คุณจะเห็นว่าแอปพลิเคชันของเราจะทำงานที่ http://localhost:8080/ บันทึกการกำหนดค่าและตั้งชื่อ (ฉันเรียกการกำหนดค่าของฉันว่า "ทอมมี่") ต่อไป บนแท็บ Maven ใน IDEA (ทางด้านขวา) เราจะใช้ปลั๊กอินสงครามเพื่อสร้างโครงการของเราเป็นไฟล์สงคราม (ปลั๊กอิน -> สงคราม -> สงคราม: สงคราม) หลังจากสร้างเสร็จแล้ว ให้รันแอปพลิเคชันและรอ ความสำเร็จ! หน้าเริ่มต้นเปิดตัว ตอนนี้คลิกปุ่ม "เริ่มทำงานกับฐานข้อมูล" index.jsp ของเราจะสร้างคำขอ GET ที่เซิร์ฟเวอร์จะดำเนินการ เซิร์ฟเวอร์จะสร้างการตอบกลับและส่งกลับมาให้เราในรูปแบบของรายชื่อผู้ใช้ที่มีอยู่ทั้งหมด (โดยสมมติว่ามีผู้ใช้อยู่ในฐานข้อมูล) และพวกเขาอยู่ที่นั่น! ที่คุณมีมัน! คุณเขียนแอปพลิเคชันแรกของคุณโดยใช้ Java servlets นั่นไม่เลวร้ายนักใช่ไหม :) สำหรับการบ้าน คุณสามารถคืนค่าการทำงานของรถได้จากบทความที่แล้ว. กล่าวอีกนัยหนึ่ง สร้างเซิร์ฟเล็ตและหน้า JSP แยกต่างหากสำหรับรถยนต์ และสอนแอปพลิเคชันถึงวิธีการแสดงรายการรถยนต์ของผู้ใช้ เพิ่มรถยนต์ใหม่ให้กับผู้ใช้ ตลอดจนแก้ไขและลบรถยนต์เหล่านั้น PS Servlets และ JavaServer Pages เป็นเทคโนโลยีที่ค่อนข้างโบราณ บนอินเทอร์เน็ต คุณมักจะพบความคิดเห็นเช่น "ใครต้องการขยะเก่านี้" คำตอบนั้นค่อนข้างง่าย: ส่วนใหญ่แล้วคือคนที่จะทำงานในโครงการจริง ซึ่งพวกเขาอาจต้องเผชิญกับโค้ดจำนวนมากที่ใช้เทคโนโลยีเหล่านี้ และแม้จะไม่เข้าใจวิธีการทำงาน มันก็ยังสนุกที่จะตัด "ขยะเก่า" เป็นสิ่งใหม่ :) สำหรับการศึกษา JSP และ servlets อย่างละเอียดยิ่งขึ้น คุณสามารถอ้างอิงจากหนังสือ "Head First Servlets and JSP ". เขียนโดยผู้เขียนคนเดียวกับหนังสือชื่อดัง "Head First Java" ซึ่งหลายคนรับประกันคุณภาพ :) ฉันหวังว่าบทความนี้จะเป็นประโยชน์! ขอบคุณสำหรับความสนใจของคุณ ขอให้โชคดีในการเรียนรู้!