Aplikasi pertama anda menggunakan servlet Java

Hai semua! Dalam artikel ini, anda akan membiasakan diri dengan konsep pembangunan web asas servlet dan boleh menulis aplikasi mudah menggunakannya. Untuk mengelakkan langkah yang tidak perlu, kami tidak akan bermula dari awal, dan akan terus mengusahakan aplikasi kami dari artikel saya sebelum ini tentang Hibernate . Walau bagaimanapun, memandangkan kita baru bermula dengan servlet, saya mengalih keluar semua yang berkaitan dengan kelas Auto daripada aplikasi dan meninggalkan hanya kelas Pengguna dan tindakannya. Struktur projek akan kelihatan seperti ini: Jadi, servlets! Wikipedia berkata: "Servlet ialah antara muka Java yang pelaksanaannya memanjangkan kefungsian pelayan. Servlet berinteraksi dengan pelanggan melalui prinsip permintaan-tindak balas." Dan memang begitu. Di sini kita mula-mula menemui konsep "seni bina aplikasi pelayan-pelanggan". Intipatinya agak mudah dan sesuai dengan satu gambar (diambil dari sini ). Pelanggan menghubungi pelayan dengan menghantar permintaan HTTP. Pelayan menjana data yang diperlukan (contohnya, menerimanya daripada pangkalan data) dan mengembalikannya kepada klien. Contoh paling mudah: pada rangkaian sosial tertentu anda mengklik butang "Rakan" dan dengan itu menghantar permintaan ke pelayan. Pelayan menyemak senarai rakan anda dalam pangkalan data dan mengembalikannya kepada anda (pelanggan). Senarai permintaan HTTP agak besar, tetapi jika anda tidak pernah menemuinya, maka untuk pemahaman yang lebih baik adalah lebih baik untuk membaca tentangnya, sebagai contoh, di sini . Tugas kami ialah: Buat aplikasi CRUD menggunakan servlets. Aplikasi mesti boleh mencipta, mengubah suai dan memadam pengguna daripada pangkalan data menggunakan servlet yang memproses permintaan HTTP. Aplikasi kami daripada artikel tentang Hibernate sudah tahu cara melakukan ini, tetapi ia dikawal terus daripada kod Java, lebih tepat lagi, daripada kaedah main(). Di sini permintaan akan dihantar oleh pelanggan, 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 telah 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.

Operasi servlet diuruskan oleh bekas servlet. Dalam kes kami, kami akan menggunakan Apache Tomcat. Perkara yang agak popular, dan anda mungkin pernah mendengarnya :) 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 melayani permintaan. Kaedah init() dipanggil sekali sahaja semasa keseluruhan kitaran hayatnya.
2. Melayan permintaan pelanggan. Setiap permintaan diproses dalam urutan tersendiri. Bekas memanggil kaedah service() untuk setiap permintaan. Kaedah ini menentukan jenis permintaan masuk dan mengedarkannya kepada kaedah yang sepadan dengan jenis ini untuk memproses permintaan. Pembangun servlet mesti menyediakan pelaksanaan untuk kaedah ini. Jika permintaan diterima yang mana kaedah tidak dilaksanakan, kaedah kelas induk dipanggil dan biasanya berakhir dengan ralat dikembalikan kepada peminta.
3. Sekiranya bekas perlu memadamkan servlet, ia memanggil kaedah destroy(), yang mengalih keluar servlet daripada perkhidmatan. Seperti kaedah init(), kaedah ini juga dipanggil sekali semasa keseluruhan kitaran servlet.

Servis kami akan 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 - doGet(), doPost(), doPut() dan doDelete(). Setiap daripada mereka akan membenarkan kami, masing-masing, untuk menerima, mencipta, mengedit dan memadam pengguna. Kaedah mengambil sebagai objek input kelas javax.servlet.http.HttpServletRequest dan javax.servlet.http.HttpServletResponse - iaitu permintaan yang dihantar ke pelayan dan respons yang diterima oleh klien. Di dalam kaedah, kaedah yang diperlukan untuk kelas UserService dilaksanakan, respons dijana untuk klien, dan kemudian dialihkan ke alamat /users. Sebagai contoh, dalam kaedah doGet() kami mendapat senarai semua pengguna. Seterusnya, kami mencipta objek kelas RequestDispatcher, yang membolehkan kami memasukkan objek dalam permintaan Http, serta mengubah halanya ke sumber tertentu (contohnya, halaman JSP pelanggan). Dalam kaedah doPut() (mengemas kini data pengguna), kami memproses permintaan HTTP, mengekstrak id, nama dan parameter umur daripadanya, mencari pengguna dengan id yang ditentukan, berikan kepadanya nama dan umur yang disertakan bersamanya dalam permintaan, dan kembali ke halaman /pengguna. Walau bagaimanapun, untuk semua kaedah ini berfungsi dengan betul, kita perlu mengkonfigurasi servlet. Untuk 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, pada dasarnya, intuitif, tetapi mari kita menelitinya secara berurutan. <welcome-file-list> - halaman JSP permulaan ditentukan, yang akan dibuka dahulu apabila aplikasi dilancarkan. Dalam kes kami, ini ialah halaman index.jsp. <servlet> - mendaftarkan kelas UserSimpleServlet kami sebagai servlet. <servlet-mapping> ialah teg yang sangat penting. Ia mentakrifkan URL yang akan diproses oleh servlet. Dalam kes kami, ini semua adalah URL, jadi kami hanya menunjukkan "/". Tetapi, sebagai contoh, jika kami mempunyai aplikasi dengan pengguna dan mesin mereka, maka kami boleh mencipta servlet kedua - SimpleAutoServlet. Kemudian pemetaan untuk servlet pengguna ialah "/users" (iaitu, permintaan yang berkaitan dengan pengguna pemprosesan), dan untuk servlet auto ia akan menjadi "/autos". Dan akhirnya, <penapis>. Ia mentakrifkan secara dalaman objek kelas org.springframework.web.filter.HiddenHttpMethodFilter. Artikel itu tidak berkenaan Spring, jadi saya tidak akan membincangkannya secara terperinci. Biar saya katakan bahawa ia dilampirkan pada aplikasi kami hanya sebagai ciri tambahan. Maksudnya 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 <form/> HTML akan digunakan. Dan hanya permintaan HTTP GET dan POST boleh digunakan untuk menghantar data daripada <form/>. Iaitu, untuk ketiga-tiga operasi - mengemas kini, memadam dan mencipta pengguna - kami perlu menggunakan permintaan POST sahaja. Menggunakan permintaan PUT dan DELETE tidak akan tersedia kepada kami. Dan, pada dasarnya, ini adalah perkara biasa dan mudah untuk dilaksanakan, tetapi kelas HiddenHttpMethodFilter membolehkan kami menggunakannya. Ini akan menjadikan perbezaan antara operasi dalam aplikasi lebih jelas kepada pembaca. Akhirnya, mari kita beralih ke bahagian pelanggan. Ia diwakili oleh lima halaman JSP. index.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>

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

Halaman JSP (Halaman Pelayan Java) mengandungi dua jenis teks: data sumber statik, yang boleh dalam salah satu format teks (HTML, SVG, WML atau XML) dan elemen JSP, yang membina kandungan dinamik. Untuk memahami apa itu JSP, saya akan membenarkan diri saya menyalin dan menampal sekeping artikel yang sangat bagus oleh seorang pengarang ( dari sini ). "Pada asasnya, JSP ditukar menjadi servlet pada kali pertama ia diakses dan berfungsi sebagai servlet. Ini sangat penting untuk difahami. JSP BUKAN halaman seperti halaman HTML - adalah penting bagi pengaturcara baru untuk memahami dengan jelas bahawa ini adalah servlet lain - anda hanya tidak perlu memprogramkan outputnya. Anda hanya boleh melukis. Dan menggantikan data di tempat yang betul. Tetapi memandangkan halaman JSP sekurang-kurangnya entah bagaimana menyerupai HTML, ia jelas akan menjadi lebih mudah untuk pereka bentuk. Dan saya sekali lagi KUAT memberitahu pemula - JSP ialah SERVLET . Ia disediakan dengan semua data pada pelayan. Di sinilah semua data dimasukkan. Dan pengguna menerima halaman HTML siap pakai dalam pelayar, yang tidak mempunyai sebarang tanda JAVA." Anda boleh lihat sendiri bahawa halaman JSP sememangnya servlet, kerana setiap halaman mengandungi kaedah yang perlu dilaksanakan. Sebagai contoh, halaman permulaan index.jsp menyatakan bahawa apabila anda mengklik pada butang "Mula bekerja dengan pangkalan data", method="get" akan dilaksanakan. Pada halaman addUser.jsp, yang bertanggungjawab untuk mencipta pengguna baharu, apabila anda mengklik pada butang simpan, method="post" akan dilaksanakan. Selebihnya JSP terdiri daripada markup HTML statik biasa, jadi kami tidak akan membincangkannya secara terperinci - ini adalah topik artikel berasingan, yang terdapat banyak di Internet. Jadi, kami telah mencipta aplikasi kami, yang tinggal hanyalah untuk mengujinya dalam tindakan! Untuk melakukan ini, kami memerlukan bekas servlet Apache Tomcat yang disebutkan di atas. Anda boleh memuat turun kucing dari 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. Dalam tab Pelayan Aplikasi, nyatakan laluan ke folder di mana Tomcat berada. Seterusnya, pergi ke tab Deployment. Di sini kami mengkonfigurasi penggunaan aplikasi kami pada pelayan tempatan. Klik "+", pilih "Artifak" -> Nama Projek Anda: perang (kami akan memasang aplikasi ke dalam fail perang). Itu pada asasnya! Pada halaman "Pelayan" anda boleh melihat bahawa aplikasi yang sama akan dijalankan di "http://localhost:8080/". Simpan konfigurasi ini dan namakannya sesuatu (nama konfigurasi saya ialah "Tommy"). Seterusnya, pada tab Maven dalam IDEA (di sebelah kanan) kami akan menggunakan plugin perang untuk membina projek kami menjadi fail perang (Plugins -> war -> war:war). Berjaya! Halaman permulaan telah dilancarkan. Sekarang klik pada butang "Mula bekerja dengan pangkalan data". Halaman JSP 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 (jika, sudah tentu, mereka berada dalam pangkalan data). Dan inilah mereka! Mari cuba padamkan salah seorang pengguna: Ia juga berfungsi! Jadi kami menulis aplikasi pertama kami menggunakan servlets. Seperti yang anda lihat, semuanya ternyata tidak begitu sukar :) Sebagai kerja rumah, anda boleh, sebagai contoh, mengembalikan fungsi bekerja dengan kereta dari artikel sebelumnya kepada aplikasi. Itu. buat halaman servlet dan jsp yang berasingan untuk kereta dan ajar aplikasi kami untuk memaparkan senarai kereta pengguna, menambah kereta baharu kepadanya, serta mengedit dan memadamkannya. PS Servlets dan JSP ialah teknologi yang agak kuno, dan di Internet anda selalunya boleh mencari komen dengan semangat "siapa yang memerlukan sampah ini?" Jawapannya agak mudah - ia diperlukan terutamanya oleh mereka yang akan bekerja pada projek sebenar, di mana sangat mungkin terdapat banyak kod yang ditulis menggunakannya. Dan menggergaji "barang lama" menjadi sesuatu yang baharu, tanpa memahami cara ia berfungsi, masih menyeronokkan :) Untuk kajian yang lebih teliti tentang topik JSP dan servlet, anda boleh menggunakan buku "Kepala Servlet dan JSP Pertama" (dalam Inggeris sahaja). Ia ditulis oleh pengarang yang sama seperti buku super terkenal "Head First Java", yang bagi kebanyakan orang boleh menjadi jaminan kualiti :) Saya harap artikel ini berguna kepada pembaca! Jika anda ingin melihat artikel baru, jangan lupa untuk menyokong penulis dalam pertandingan dengan "Suka" dia. Atau lebih baik lagi - "Saya sangat menyukainya" :) Terima kasih atas perhatian anda, dan semoga berjaya dalam pelajaran anda!