Aplikasi pertama Anda menggunakan Java servlet

Halo semua! Pada artikel ini, Anda akan mengenal konsep dasar pengembangan web servlet dan mampu menulis aplikasi sederhana menggunakan konsep tersebut. Untuk menghindari langkah-langkah yang tidak perlu, kami tidak akan memulai dari awal, dan akan terus mengerjakan aplikasi kami dari artikel saya sebelumnya tentang Hibernate . Namun, karena kita baru memulai dengan servlet, saya menghapus semua yang berhubungan dengan kelas Auto dari aplikasi dan hanya menyisakan kelas User dan tindakannya. Struktur proyeknya akan terlihat seperti ini: Jadi, servlet! Wikipedia mengatakan: "Servlet adalah antarmuka Java yang implementasinya memperluas fungsionalitas server. Servlet berinteraksi dengan klien melalui prinsip permintaan-respons." Dan memang benar. Di sini kita pertama kali menemukan konsep “arsitektur aplikasi client-server”. Esensinya cukup sederhana dan cocok menjadi satu gambar (diambil dari sini ). Klien menghubungi server dengan mengirimkan permintaan HTTP. Server menghasilkan data yang diperlukan (misalnya, menerimanya dari database) dan mengembalikannya ke klien. Contoh paling sederhana: di jejaring sosial tertentu Anda mengklik tombol "Teman" dan mengirim permintaan ke server. Server memeriksa daftar teman Anda di database dan mengembalikannya kepada Anda (klien). Daftar permintaan HTTP cukup banyak, tetapi jika Anda belum pernah menemukannya, maka untuk lebih memahaminya lebih baik membacanya, misalnya di sini . Tugas kita adalah: Membuat aplikasi CRUD menggunakan servlet. Aplikasi harus dapat membuat, mengubah, dan menghapus pengguna dari database menggunakan servlet yang memproses permintaan HTTP. Aplikasi kita dari artikel tentang Hibernate sudah mengetahui cara melakukan ini, tetapi dikontrol langsung dari kode Java, lebih tepatnya, dari metode main(). Di sini permintaan akan dikirim oleh klien, yaitu Anda :) Hal pertama yang perlu kita lakukan adalah menambahkan dependensi baru ke file pom.xml kita

<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 menambahkan 3 dependensi:

1. Pustaka javax.servlet-api itu sendiri;
2. Perpustakaan tag JSTL. Diperlukan untuk membuat sisi klien, yaitu halaman JSP;
3. Musim Semi-WebMVC. Kita memerlukan satu kelas Musim Semi, yang akan kita bicarakan nanti.

Pengoperasian servlet dikelola oleh container servlet. Dalam kasus kami, kami akan menggunakan Apache Tomcat. Hal yang cukup populer, dan Anda mungkin pernah mendengarnya :) Siklus hidup sebuah servlet terdiri dari langkah-langkah berikut:

1. Jika tidak ada servlet di dalam wadah.
   
   • Kelas servlet dimuat oleh container.
   • Kontainer menciptakan sebuah instance dari kelas servlet.
   • Kontainer memanggil metode init(). Metode ini menginisialisasi servlet dan dipanggil terlebih dahulu sebelum servlet dapat melayani permintaan. Metode init() hanya dipanggil sekali sepanjang siklus hidupnya.
2. Melayani permintaan klien. Setiap permintaan diproses di thread tersendiri. Kontainer memanggil metode service() untuk setiap permintaan. Metode ini menentukan jenis permintaan yang masuk dan mendistribusikannya ke metode yang sesuai dengan jenis tersebut untuk memproses permintaan tersebut. Pengembang servlet harus menyediakan implementasi untuk metode ini. Jika permintaan diterima namun metodenya tidak diimplementasikan, metode kelas induk akan dipanggil dan biasanya berakhir dengan kesalahan yang dikembalikan ke pemohon.
3. Jika container perlu menghapus servlet, ia akan memanggil metode destroy(), yang akan menghapus servlet dari layanan. Seperti metode init(), metode ini juga dipanggil satu kali selama seluruh siklus servlet.

Servlet kami akan terlihat cukup sederhana:

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, ini berisi metode init(), yang dijelaskan di atas, dan mengimplementasikan 4 metode yang bertepatan dengan empat permintaan HTTP - doGet(), doPost(), doPut() dan doDelete(). Masing-masing dari mereka akan memungkinkan kita untuk menerima, membuat, mengedit, dan menghapus pengguna. Metode ini mengambil objek input dari kelas javax.servlet.http.HttpServletRequest dan javax.servlet.http.HttpServletResponse - yaitu, permintaan yang dikirim ke server dan respons yang diterima klien. Di dalam metode, metode yang diperlukan dari kelas UserService dieksekusi, respons dihasilkan untuk klien, dan kemudian diarahkan ke alamat /users. Misalnya, dalam metode doGet() kita mendapatkan daftar semua pengguna. Selanjutnya, kita membuat objek kelas RequestDispatcher, yang memungkinkan kita memasukkan objek dalam permintaan Http, serta mengarahkannya ke sumber daya tertentu (misalnya, halaman JSP klien). Dalam metode doPut() (memperbarui data pengguna), kami memproses permintaan HTTP, mengekstrak parameter id, nama, dan usia darinya, menemukan pengguna dengan id yang ditentukan, menetapkan kepadanya nama dan usia yang menyertainya di permintaan, dan kembali ke halaman /pengguna. Namun, agar semua metode ini berfungsi dengan benar, kita perlu mengkonfigurasi servlet. Untuk ini kami menggunakan file web.xml di 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 tag dalam file ini, pada prinsipnya, intuitif, tetapi mari kita bahas secara berurutan. <welcome-file-list> - halaman JSP awal ditentukan, yang akan dibuka pertama kali saat aplikasi diluncurkan. Dalam kasus kami, ini adalah halaman index.jsp. <servlet> - mendaftarkan kelas UserSimpleServlet kami sebagai servlet. <servlet-mapping> adalah tag yang sangat penting. Ini mendefinisikan URL yang akan diproses oleh servlet. Dalam kasus kami, ini semua adalah URL, jadi kami cukup menunjukkan “/”. Namun, misalnya, jika kita memiliki aplikasi dengan pengguna dan mesin mereka, maka kita dapat membuat servlet kedua - SimpleAutoServlet. Maka pemetaan untuk servlet pengguna akan menjadi “/users” (yaitu, permintaan yang terkait dengan pemrosesan pengguna), dan untuk servlet otomatis akan menjadi “/autos”. Dan terakhir, <filter>. Ini mendefinisikan secara internal objek kelas org.springframework.web.filter.HiddenHttpMethodFilter. Artikel ini tidak membahas tentang Musim Semi, jadi saya tidak akan membicarakannya secara detail. Izinkan saya mengatakan bahwa itu melekat pada aplikasi kita hanya sebagai fitur tambahan. Intinya kita akan menggunakan halaman JSP untuk membuat sisi klien. Data kami akan ditampilkan di halaman sebagai tabel dengan daftar pengguna. Di dalam halaman JSP, tag HTML <form/> akan digunakan. Dan hanya permintaan HTTP GET dan POST yang dapat digunakan untuk mengirim data dari <form/>. Artinya, untuk ketiga operasi - memperbarui, menghapus, dan membuat pengguna - kita hanya perlu menggunakan permintaan POST. Menggunakan permintaan PUT dan DELETE tidak akan tersedia bagi kami. Dan, pada prinsipnya, ini cukup normal dan mudah diterapkan, tetapi kelas HiddenHttpMethodFilter memungkinkan kita untuk menggunakannya. Ini akan membuat perbedaan antara operasi dalam aplikasi menjadi lebih jelas bagi pembaca. Terakhir, mari beralih ke sisi klien. Itu diwakili oleh lima halaman JSP. indeks.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>

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

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

perbaruiPengguna.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 Server Java) berisi dua jenis teks: data sumber statis, yang bisa dalam salah satu format teks (HTML, SVG, WML, atau XML), dan elemen JSP, yang membuat konten dinamis. Untuk memahami apa itu JSP, saya akan membiarkan diri saya menyalin dan menempelkan artikel yang sangat bagus oleh seorang penulis ( dari sini ). "Pada dasarnya, JSP diubah menjadi servlet saat pertama kali diakses dan berfungsi sebagai servlet. Ini sangat penting untuk dipahami. JSP BUKAN halaman seperti halaman HTML - penting bagi programmer pemula untuk memahami dengan jelas bahwa ini adalah servlet lain - Anda hanya tidak perlu memprogram outputnya. Anda cukup menggambarnya. Dan mengganti datanya di tempat yang tepat. Tapi karena halaman JSP setidaknya menyerupai HTML, jelas akan lebih mudah bagi perancangnya. Dan saya sekali lagi SANGAT memberi tahu pemula - JSP adalah SERVLET . Ini disiapkan dengan semua data di server. Di sinilah semua data dimasukkan. Dan pengguna menerima halaman HTML siap pakai di browser, yang tidak memiliki tanda-tanda JAWA." Anda bisa melihat sendiri bahwa halaman JSP memang merupakan servlet, karena setiap halaman berisi metode yang perlu dijalankan. Misalnya, halaman awal index.jsp menyatakan bahwa ketika Anda mengklik tombol "Mulai bekerja dengan database", metode = "dapatkan" akan dijalankan. Pada halaman addUser.jsp, yang bertanggung jawab untuk membuat pengguna baru, ketika Anda mengklik tombol simpan, metode = "posting" akan dijalankan. JSP lainnya terdiri dari markup HTML statis biasa, jadi kami tidak akan membahasnya secara detail - ini adalah topik artikel terpisah, yang banyak terdapat di Internet. Jadi, kami telah membuat aplikasi kami, yang tersisa hanyalah mengujinya secara langsung! Untuk melakukan ini, kita memerlukan wadah servlet Apache Tomcat yang disebutkan di atas. Anda dapat mendownload cat dari situs resminya (saya menggunakan versi 8). Selanjutnya, kita perlu membuat konfigurasi di IDEA untuk menjalankan aplikasi kita melalui Tomcat. Untuk melakukan ini, buka tab "Edit Konfigurasi", buat konfigurasi baru dan pilih Tomcat Server Lokal. Pada tab Application Server, tentukan path ke folder tempat Tomcat berada. Selanjutnya, masuk ke tab Deployment. Di sini kita mengkonfigurasi penerapan aplikasi kita di server lokal. Klik "+", pilih "Artefak" -> Nama Proyek Anda: war (kami akan merakit aplikasi menjadi file perang). Pada dasarnya itu saja! Pada halaman "Server" Anda dapat melihat bahwa aplikasi yang sama akan berjalan di "http://localhost:8080/". Simpan konfigurasi ini dan beri nama sesuatu (nama konfigurasi saya adalah "Tommy"). Selanjutnya, pada tab Maven di IDEA (di sisi kanan) kita akan menggunakan plugin perang untuk membangun proyek kita menjadi file perang (Plugins -> war -> war:war). Kesuksesan! Halaman awal telah diluncurkan. Sekarang klik tombol “Mulai bekerja dengan database”. Halaman JSP kami index.jsp akan menghasilkan permintaan GET yang akan diproses oleh server. Server akan menghasilkan respon dan mengembalikannya kepada kami dalam bentuk daftar semua pengguna yang ada (jika tentu saja mereka ada di database). Dan inilah mereka! Mari kita coba menghapus salah satu pengguna: Berhasil juga! Jadi kami menulis aplikasi pertama kami menggunakan servlet. Seperti yang Anda lihat, semuanya ternyata tidak terlalu sulit :) Sebagai pekerjaan rumah, Anda dapat, misalnya, mengembalikan fungsionalitas bekerja dengan mobil dari artikel sebelumnya ke aplikasi. Itu. buat halaman servlet dan jsp terpisah untuk mobil dan ajari aplikasi kita untuk menampilkan daftar mobil pengguna, menambahkan mobil baru ke dalamnya, serta mengedit dan menghapusnya. PS Servlets dan JSP adalah teknologi yang cukup kuno, dan di Internet Anda sering dapat menemukan komentar dengan semangat “siapa yang butuh sampah ini?” Jawabannya cukup sederhana - pertama-tama dibutuhkan oleh mereka yang akan mengerjakan proyek nyata, yang kemungkinan besar akan ada banyak kode yang ditulis menggunakan proyek tersebut. Dan menggergaji “barang lama” menjadi sesuatu yang baru, tanpa memahami cara kerjanya, tetaplah menyenangkan :) Untuk mempelajari topik JSP dan servlet lebih mendalam, Anda dapat menggunakan buku “Head First Servlets dan JSP” (dalam Hanya bahasa Inggris). Itu ditulis oleh penulis yang sama dengan buku super terkenal "Head First Java", yang bagi banyak orang dapat menjadi jaminan kualitasnya :) Saya harap artikel ini bermanfaat bagi pembaca! Jika Anda ingin melihat artikel baru, jangan lupa dukung penulis dalam kompetisi dengan "Like" dia. Atau lebih baik lagi - “Saya sangat menyukainya” :) Terima kasih atas perhatian Anda, dan semoga sukses dalam studi Anda!