Aplikasi pertama anda menggunakan servlet Java

Hai semua! Anda akan menjadi biasa dengan servlet sebagai konsep asas pembangunan web, dan anda akan dapat menulis aplikasi mudah yang menggunakannya. Untuk mengelakkan tindakan yang tidak perlu, kami tidak akan bermula dari awal. Kami akan terus mengusahakan aplikasi kami dari artikel terdahulu saya tentang Hibernate . Tetapi oleh kerana kita baru mula berkenalan dengan servlet, saya telah mengalih keluar semua yang berkaitan dengan kelas Auto daripada aplikasi dan meninggalkan hanya kelas Pengguna dan tindakan yang melibatkannya. Projek ini akan disusun seperti ini: Jadi, servlets! Wikipedia menyatakan: "Servlet Java ialah komponen perisian Java yang memanjangkan keupayaan pelayan. Walaupun servlet boleh bertindak balas kepada banyak jenis permintaan, mereka biasanya melaksanakan bekas web untuk mengehos aplikasi web pada pelayan web dan dengan itu layak sebagai pelayan- API web servlet sisi." Ini betul-betul betul. Di sini, buat pertama kalinya, kami menemui konsep "seni bina aplikasi pelayan-klien." Ia agak mudah pada terasnya. Pelanggan mengakses pelayan dengan menghantar permintaan HTTP. Pelayan menjana data yang diperlukan (contohnya, mengambilnya daripada pangkalan data) dan mengembalikannya kepada klien. Contoh paling mudah ialah apabila anda mengklik butang "Rakan" pada rangkaian sosial tertentu, dengan itu menghantar permintaan ke pelayan. Pelayan mengemas kini senarai rakan anda dalam pangkalan data dan mengembalikannya kepada anda (pelanggan). Senarai permintaan HTTP agak besar, jadi jika anda tidak pernah menemuinya sebelum ini, sebaiknya anda membaca tentangnya di tempat lain, contohnya,di sini . Objektif kami adalah untuk: Mencipta aplikasi CRUD menggunakan servlets. Aplikasi mesti boleh mencipta, membaca, mengemas kini dan memadam pengguna daripada pangkalan data menggunakan servlet yang memproses permintaan HTTP. Aplikasi kami daripada artikel Hibernate sudah boleh melakukan ini, tetapi ia dikawal terus daripada kod Java, lebih tepat lagi, daripada kaedah main(). Kali ini, pelangganlah yang akan menghantar permintaan, iaitu anda :) Perkara pertama yang perlu kami lakukan ialah menambah kebergantungan baharu pada fail pom.xml kami.

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

Kami menambah 3 kebergantungan:

1. Pustaka javax.servlet-api itu sendiri
2. Pustaka tag JSTL. Ia akan diperlukan untuk mencipta bahagian pelanggan, iaitu halaman JSP
3. Spring-WebMVC. Kami memerlukan satu kelas Spring, yang akan kami bincangkan sedikit kemudian.

Pengurusan servlet dikendalikan oleh bekas servlet. Dalam kes kami, kami akan menggunakan Apache Tomcat. Ia agak popular — anda mungkin pernah mendengar tentangnya :) Kitaran hayat servlet terdiri daripada langkah berikut:

1. Jika tiada servlet dalam bekas:
   
   • Kelas servlet dimuatkan oleh bekas.
   • Bekas mencipta contoh kelas servlet.
   • Bekas memanggil kaedah init(). Kaedah ini memulakan servlet dan dipanggil terlebih dahulu, sebelum servlet boleh menyampaikan permintaan. Sepanjang keseluruhan kitaran hayat, kaedah init() dipanggil sekali sahaja.
2. Layan permintaan pelanggan. Setiap permintaan diproses pada urutan tersendiri. Bekas memanggil kaedah service() untuk setiap permintaan. Kaedah ini menentukan jenis permintaan masuk dan menghantarnya ke kaedah yang sesuai untuk pemprosesan. Pembangun servlet mesti menyediakan pelaksanaan untuk kaedah ini. Jika permintaan tiba untuk pengendali yang tidak dilaksanakan, kaedah kelas induk dipanggil dan biasanya akhirnya mengembalikan ralat kepada peminta.


3. Jika bekas perlu mengalih keluar servlet, ia memanggil kaedah destroy(), yang mengeluarkan servlet daripada operasi. Seperti kaedah init(), kaedah ini juga dipanggil sekali semasa keseluruhan kitaran servlet.

Servis kami kelihatan agak mudah:

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");
    }
}

Seperti yang anda lihat, ia mengandungi kaedah init(), yang diterangkan di atas, dan melaksanakan 4 kaedah yang bertepatan dengan empat permintaan HTTP: doPost(), doGet(), doPut() dan doDelete(). Mereka membenarkan kami membuat, membaca, mengemas kini dan memadam pengguna. Kaedah menerima contoh kelas javax.servlet.http.HttpServletRequest dan javax.servlet.http.HttpServletResponse sebagai input, iaitu permintaan yang dihantar ke pelayan dan respons yang diterima oleh klien. Secara dalaman, kaedah memanggil kaedah berkaitan kelas UserService, dan respons untuk klien dijana dan diubah hala ke URL /users. Contohnya, dalam kaedah doGet(), kami mendapat senarai semua pengguna. Seterusnya, kami mencipta objek RequestDispatcher, yang membolehkan kami memasukkan objek dalam permintaan HTTP dan mengubah halanya ke sumber tertentu (contohnya, ke halaman JSP pelanggan). Dalam kaedah doPut() (yang mengemas kini data pengguna), kami memproses permintaan HTTP, mengekstrak id, nama dan parameter umur, mencari pengguna dengan id yang ditentukan, memberikannya nama dan umur yang dalam permintaan, dan mengembalikan ke halaman /users. Tetapi untuk semua kaedah ini berfungsi dengan betul, kita perlu mengkonfigurasi servlet. Untuk melakukan ini, kami menggunakan fail web.xml dalam folder 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>

Semua teg dalam fail ini agak intuitif, tetapi mari kita semaknya mengikut urutan. <welcome-file-list> - Halaman permulaan JSP ditunjukkan, yang akan dibuka dahulu apabila aplikasi bermula. Dalam kes kami, ini ialah index.jsp. <servlet> - Pendaftaran kelas UserSimpleServlet kami sebagai servlet. <servlet-mapping> - teg yang sangat penting. Ia mentakrifkan URL yang akan diproses oleh servlet. Dalam kes kami, ini semua URL, jadi kami hanya menunjukkan "/". Tetapi jika kami mempunyai aplikasi yang melibatkan pengguna dan kereta mereka (autos), maka kami boleh mencipta servlet kedua (SimpleAutoServlet). Kemudian pemetaan servlet pengguna ialah "/users" (iaitu permintaan tentang pengguna), dan pemetaan servlet auto ialah "/autos". Dan akhirnya, <penapis>. Secara dalaman, ia mentakrifkan contoh org. springframework.web.filter.HiddenHttpMethodFilter kelas. Artikel ini bukan mengenai Spring, jadi saya tidak akan menerangkannya secara terperinci. Saya hanya akan mengatakan bahawa ia dipasang pada aplikasi kami hanya sebagai ciri tambahan. Masalahnya ialah kami akan menggunakan halaman JSP untuk mencipta bahagian pelanggan. Data kami akan dipaparkan pada halaman sebagai jadual dengan senarai pengguna. Di dalam halaman JSP, tag HTML <form/> akan digunakan. Tetapi hanya permintaan HTTP GET dan POST boleh digunakan untuk menghantar data daripada <form/>. Dalam erti kata lain, untuk ketiga-tiga operasi — mengemas kini, memadam dan mencipta pengguna — kami hanya perlu menggunakan permintaan POST. Menggunakan permintaan PUT dan DELETE tidak akan menjadi pilihan untuk kami. Pada dasarnya, ini adalah perkara biasa dan mudah untuk dilaksanakan, tetapi kelas HiddenHttpMethodFilter membolehkan kami menggunakannya. Dengan cara ini, pembaca akan lebih jelas melihat perbezaan antara operasi dalam aplikasi. Akhirnya, mari kita teruskan ke bahagian pelanggan. Ia diwakili oleh lima halaman 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>

Halaman JSP (Halaman JavaServer) mengandungi dua jenis teks: data sumber statik yang boleh diformatkan sebagai teks (HTML, SVG, WML atau XML) dan elemen JSP yang digunakan untuk membina kandungan dinamik. Untuk membantu anda memahami maksud halaman JSP, saya telah menyalin petikan daripada artikel yang sangat bagus. "Pada asasnya, kali pertama JSP diminta, ia bertukar menjadi servlet dan beroperasi sebagai servlet. Ini sangat penting untuk difahami. Halaman JSP BUKAN seperti halaman HTML — pengaturcara permulaan mesti memahami dengan jelas bahawa ini adalah servlet lain — cuma anda tidak perlu menulis untuk memprogramkan cara ia dipaparkan. Ia hanya boleh dilukis. Dan tambah data jika perlu. Tetapi kerana halaman JSP mengingatkan HTML, seorang pereka bentuk jelas akan mendapatinya lebih mudah. ​​Dan sekali lagi SANGAT TEKANKAN kepada pemula,halaman JSP ialah SERVLET. Ia dijana, termasuk menambah semua data, pada pelayan. Di sinilah semua data dimasukkan. Dan dalam penyemak imbas, pengguna mendapat halaman HTML siap, yang tidak mempunyai tanda Java." Anda boleh yakin bahawa halaman JSP adalah benar-benar servlet, kerana setiap halaman mempunyai kaedah yang perlu dilaksanakan. Contohnya, indeks .jsp menunjukkan bahawa apabila anda mengklik pada butang "Mula bekerja dengan pangkalan data", kaedah dapatkan akan dilaksanakan (kaedah = "dapatkan"). Halaman addUser.jsp, yang bertanggungjawab untuk mencipta pengguna baharu, melaksanakan kaedah siaran (kaedah = "siaran") apabila anda mengklik butang simpan. Halaman JSP yang selebihnya terdiri daripada penanda HTML statik biasa, jadi kami tidak akan memikirkannya. Itu topik untuk artikel lain dan terdapat banyak tentang ini topik di Internet. Jadi, kami telah mencipta aplikasi kami! Sekarang kita perlu mengujinya dalam tindakan! Untuk melakukan ini, kami memerlukan bekas servlet Apache Tomcat yang disebutkan di atas. Anda boleh memuat turun bekasdari laman web rasmi (saya menggunakan versi 8). Seterusnya, kami perlu membuat konfigurasi dalam IDEA untuk menjalankan aplikasi kami melalui Tomcat. Untuk melakukan ini, buka tab "Edit Konfigurasi", buat konfigurasi baharu dan pilih "Tomcat Server Local". Pada tab "Pelayan Aplikasi", tentukan laluan ke folder Tomcat Seterusnya, pergi ke tab "Pengerahan". Di sini, kami mengkonfigurasi penggunaan aplikasi kami pada pelayan tempatan. Tekan "+", pilih "Artifact" -> YourProjectName:war (kami akan membina aplikasi ke fail perang). Dan itu kira-kira meringkaskannya! Pada halaman "Pelayan", anda boleh melihat bahawa aplikasi kami akan dijalankan di http://localhost:8080/. Simpan konfigurasi dan beri nama (saya panggil konfigurasi saya "Tommy"). Seterusnya, pada tab Maven dalam IDEA (di sebelah kanan), kami akan menggunakan plugin perang untuk membina projek kami kepada fail perang (Plugins -> war -> war: war). Selepas binaan selesai, jalankan aplikasi dan tunggu. Berjaya! Halaman permulaan telah dilancarkan. Sekarang kita klik butang "Mula bekerja dengan pangkalan data". index.jsp kami akan menjana permintaan GET yang akan diproses oleh pelayan. Pelayan akan menjana respons dan mengembalikannya kepada kami dalam bentuk senarai semua pengguna sedia ada (dengan mengandaikan bahawa terdapat pengguna dalam pangkalan data, sudah tentu). Dan di sana mereka! Itulah anda mempunyainya! Anda menulis aplikasi pertama anda menggunakan servlet Java. Itu tidak begitu teruk, bukan? :) Untuk kerja rumah, anda boleh memulihkan fungsi kereta dari artikel sebelumnya. Dalam erti kata lain, buat halaman servlet dan JSP yang berasingan untuk kereta, dan ajar aplikasi cara menyenaraikan kereta pengguna, menambah kereta baharu kepada pengguna dan mengedit serta memadamkannya. PS Servlets dan JavaServer Pages adalah teknologi yang agak kuno. Di Internet, anda selalunya boleh menemui ulasan seperti "Siapa yang memerlukan sampah lama ini?" Jawapannya agak mudah: terutamanya orang yang akan bekerja pada projek sebenar, di mana mereka mungkin menghadapi banyak kod yang menggunakan teknologi ini. Dan walaupun tanpa memahami cara ia berfungsi, ia masih menyeronokkan untuk memotong "sampah lama" menjadi sesuatu yang baharu :) Untuk kajian yang lebih teliti tentang JSP dan servlet, anda boleh merujuk buku "Kepala Servlet dan JSP Pertama ". Ia ditulis oleh pengarang yang sama seperti buku super terkenal "Head First Java", yang ramai akan ambil sebagai jaminan kualiti :) Saya harap artikel ini telah membantu! Terima kasih atas perhatian anda, dan semoga berjaya dalam pembelajaran!