Aplikasi pertama Anda menggunakan servlet Java

Halo semuanya! Anda akan terbiasa dengan servlet sebagai konsep dasar pengembangan web, dan Anda akan dapat menulis aplikasi sederhana yang menggunakannya. Untuk menghindari tindakan yang tidak perlu, kami tidak akan memulai dari awal. Kami akan melanjutkan mengerjakan aplikasi kami dari artikel saya sebelumnya tentang Hibernate . Tapi karena kita baru mulai berkenalan dengan servlet, saya telah menghapus semua yang terkait dengan kelas Auto dari aplikasi dan hanya menyisakan kelas Pengguna dan tindakan yang melibatkannya. Proyek ini akan disusun seperti ini: Jadi, servlet! Wikipedia menyatakan: "Java servlet adalah komponen perangkat lunak Java yang memperluas kemampuan server. Meskipun servlet dapat menanggapi banyak jenis permintaan, mereka paling sering menerapkan wadah web untuk hosting aplikasi web di server web dan dengan demikian memenuhi syarat sebagai server- API web servlet samping." Ini memang benar. Di sini, untuk pertama kalinya, kami menemukan konsep "arsitektur aplikasi server-klien". Ini cukup sederhana pada intinya. Klien mengakses server dengan mengirimkan permintaan HTTP. Server menghasilkan data yang diperlukan (misalnya, mengambilnya dari database) dan mengembalikannya ke klien. Contoh paling sederhana adalah saat Anda mengklik tombol "Teman" di jejaring sosial tertentu, sehingga mengirimkan permintaan ke server. Server memperbarui daftar teman Anda di database dan mengembalikannya kepada Anda (klien). Daftar permintaan HTTP cukup besar, jadi jika Anda belum pernah menemukannya sebelumnya, sebaiknya Anda membacanya di tempat lain, misalnya,di sini . Tujuan kami adalah untuk: Membuat aplikasi CRUD menggunakan servlet. Aplikasi harus dapat membuat, membaca, memperbarui, dan menghapus pengguna dari database menggunakan servlet yang memproses permintaan HTTP. Aplikasi kita dari artikel Hibernate sudah dapat melakukan ini, tetapi dikontrol langsung dari kode Java, lebih tepatnya, dari metode main(). Kali ini klien yang akan mengirim permintaan, 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 menambahkan 3 dependensi:

1. Pustaka javax.servlet-api itu sendiri
2. Pustaka tag JSTL. Diperlukan untuk membuat sisi klien, yaitu halaman JSP
3. Spring-WebMVC. Kami akan membutuhkan satu kelas Musim Semi, yang akan kami bicarakan nanti.

Manajemen servlet ditangani oleh wadah servlet. Dalam kasus kami, kami akan menggunakan Apache Tomcat. Ini cukup populer — Anda mungkin pernah mendengarnya :) Siklus hidup servlet terdiri dari langkah-langkah berikut:

1. Jika tidak ada servlet di wadah:
   
   • Kelas servlet dimuat oleh wadah.
   • Wadah membuat turunan dari kelas servlet.
   • Kontainer memanggil metode init(). Metode ini menginisialisasi servlet dan dipanggil terlebih dahulu, sebelum servlet dapat melayani permintaan. Sepanjang siklus hidup, metode init() dipanggil hanya sekali.
2. Melayani permintaan klien. Setiap permintaan diproses pada utasnya sendiri yang terpisah. Kontainer memanggil metode service() untuk setiap permintaan. Metode ini menentukan jenis permintaan yang masuk dan mengirimkannya ke metode yang sesuai untuk diproses. Pengembang servlet harus menyediakan implementasi untuk metode ini. Jika permintaan tiba untuk penangan yang tidak diterapkan, metode kelas induk dipanggil dan biasanya berakhir dengan mengembalikan kesalahan ke pemohon.


3. Jika container perlu menghapus servlet, container akan memanggil metode destroy() , yang membuat servlet berhenti beroperasi. Seperti metode init(), metode ini juga dipanggil satu kali selama seluruh siklus servlet.

Servlet kami 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: doPost(), doGet(), doPut() dan doDelete(). Mereka mengizinkan kami membuat, membaca, memperbarui, dan menghapus pengguna. Metode menerima instance kelas javax.servlet.http.HttpServletRequest dan javax.servlet.http.HttpServletResponse sebagai masukan, yaitu permintaan dikirim ke server dan tanggapan diterima oleh klien. Secara internal, metode memanggil metode yang relevan dari kelas UserService, dan respons untuk klien dibuat dan dialihkan ke URL /users. Misalnya, dalam metode doGet(), kita mendapatkan daftar semua pengguna. Selanjutnya, kami membuat objek RequestDispatcher, yang memungkinkan kami menyertakan objek dalam permintaan HTTP dan mengarahkannya ke sumber daya tertentu (misalnya, ke halaman JSP klien). Dalam metode doPut() (yang memperbarui data pengguna), kami memproses permintaan HTTP, mengekstrak parameter id, nama, dan usia, menemukan pengguna dengan id yang ditentukan, menetapkan nama dan usia yang ada dalam permintaan, dan mengembalikan ke halaman /pengguna. Tetapi agar semua metode ini berfungsi dengan benar, kita perlu mengonfigurasi servlet. Untuk melakukan 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 cukup intuitif, tetapi mari kita telusuri secara berurutan. <welcome-file-list> - Halaman awal JSP ditunjukkan, yang akan dibuka pertama kali saat aplikasi dimulai. Dalam kasus kami, ini adalah index.jsp. <servlet> - Pendaftaran kelas UserSimpleServlet kami sebagai servlet. <servlet-mapping> - tag yang sangat penting. Ini mendefinisikan URL yang akan diproses oleh servlet. Dalam kasus kami, itu semua adalah URL, jadi kami cukup menunjukkan "/". Tetapi jika kita memiliki aplikasi yang melibatkan pengguna dan mobil mereka (mobil), maka kita dapat membuat servlet kedua (SimpleAutoServlet). Maka pemetaan servlet pengguna akan menjadi "/ pengguna" (yaitu permintaan tentang pengguna), dan pemetaan servlet otomatis akan menjadi "/ autos". Dan terakhir, <filter>. Secara internal, ini mendefinisikan sebuah instance dari org. kelas springframework.web.filter.HiddenHttpMethodFilter. Artikel ini bukan tentang Musim Semi, jadi saya tidak akan menjelaskannya secara detail. Saya hanya akan mengatakan bahwa itu dibaut ke aplikasi kita hanya sebagai fitur tambahan. Masalahnya adalah 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. Namun hanya permintaan HTTP GET dan POST yang dapat digunakan untuk mengirim data dari <form/>. Dengan kata lain, untuk ketiga operasi — memperbarui, menghapus, dan membuat pengguna — kita harus menggunakan permintaan POST saja. Menggunakan permintaan PUT dan DELETE tidak akan menjadi pilihan bagi kami. Pada prinsipnya, ini cukup normal dan mudah diterapkan, tetapi kelas HiddenHttpMethodFilter memungkinkan kita menggunakannya. Lewat sini, pembaca akan lebih jelas melihat perbedaan antara operasi dalam aplikasi. Akhirnya, mari kita lanjutkan ke sisi klien. Itu 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>
 
 

hapusUser.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 (JavaServer Page) berisi dua jenis teks: data sumber statis yang dapat diformat sebagai teks (HTML, SVG, WML, atau XML), dan elemen JSP yang digunakan untuk membuat konten dinamis. Untuk membantu Anda memahami apa itu halaman JSP, saya telah menyalin bagian dari artikel yang sangat bagus. "Pada dasarnya, pertama kali JSP diminta, ia berubah menjadi servlet dan beroperasi sebagai servlet. Ini sangat penting untuk dipahami. Halaman JSP TIDAK seperti halaman HTML — programmer pemula harus memahami dengan jelas bahwa ini adalah servlet lain — hanya saja Anda tidak menulis harus memprogram bagaimana tampilannya. Halaman ini dapat dengan mudah digambar. Dan menambahkan data jika diperlukan. Tetapi karena halaman JSP mengingatkan pada HTML, seorang desainer jelas akan lebih mudah melakukannya. Dan sekali lagi SANGAT UTAMAKAN untuk pemula,halaman JSP adalah SERVLET. Itu dihasilkan, termasuk menambahkan semua data, di server. Di sinilah semua data dimasukkan. Dan di browser, pengguna mendapatkan halaman HTML jadi, yang tidak memiliki tanda-tanda Java." Anda dapat yakin bahwa halaman JSP benar-benar sebuah servlet, karena setiap halaman memiliki metode yang harus dijalankan. Misalnya, indeks .jsp menunjukkan bahwa ketika Anda mengklik tombol "Mulai bekerja dengan database", metode get akan dieksekusi (method = "get") Halaman addUser.jsp, yang bertanggung jawab untuk membuat pengguna baru, mengeksekusi metode post (method = "post") ketika Anda mengklik tombol simpan. Halaman JSP lainnya terdiri dari markup HTML statis biasa, jadi kami tidak akan memikirkannya. Itu adalah topik untuk artikel lain dan ada banyak tentang ini topik di Internet. Jadi, kami' telah membuat aplikasi kami! Sekarang kita perlu mengujinya dalam aksi! Untuk melakukan ini, kita memerlukan wadah servlet Apache Tomcat yang disebutkan di atas. Anda dapat mengunduh wadahnyadari 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 "Lokal Server Tomcat". Pada tab "Application Server", tentukan path ke folder Tomcat Selanjutnya, buka tab "Deployment". Di sini, kami mengonfigurasi penerapan aplikasi kami di server lokal. Tekan "+", pilih "Artifact" -> YourProjectName:war (kami akan membangun aplikasi ke file perang). Dan itu tentang meringkasnya! Pada halaman "Server", Anda dapat melihat bahwa aplikasi kita akan berjalan di http://localhost:8080/. Simpan konfigurasi dan beri nama (saya beri nama konfigurasi saya "Tommy"). Selanjutnya, pada tab Maven di IDEA (di sebelah kanan), kita akan menggunakan plugin perang untuk membangun proyek kita ke file perang (Plugins -> war -> war: war). Setelah build selesai, jalankan aplikasi dan tunggu. Kesuksesan! Halaman awal diluncurkan. Sekarang kita klik tombol "Mulai bekerja dengan database". Index.jsp kita akan menghasilkan permintaan GET yang akan diproses oleh server. Server akan menghasilkan respons dan mengembalikannya kepada kami dalam bentuk daftar semua pengguna yang ada (dengan asumsi ada pengguna di database, tentu saja). Dan itu dia! Itu dia! Anda menulis aplikasi pertama Anda menggunakan servlet Java. Itu tidak terlalu buruk, bukan? :) Untuk pekerjaan rumah, Anda dapat mengembalikan fungsi mobil dari artikel sebelumnya. Dengan kata lain, buat halaman servlet dan JSP terpisah untuk mobil, dan ajari aplikasi cara membuat daftar mobil pengguna, menambahkan mobil baru ke pengguna, serta mengedit dan menghapusnya. PS Servlets dan JavaServer Pages adalah teknologi yang agak kuno. Di Internet, Anda sering menemukan komentar seperti "Siapa yang butuh sampah lama ini?" Jawabannya cukup sederhana: terutama orang-orang yang akan mengerjakan proyek nyata, di mana mereka sangat mungkin menemukan banyak kode yang menggunakan teknologi ini. Dan bahkan tanpa memahami cara kerjanya, masih menyenangkan untuk memotong "sampah lama" menjadi sesuatu yang baru :) Untuk studi JSP dan servlet yang lebih menyeluruh, Anda dapat merujuk ke buku "Head First Servlets and JSP ". Itu ditulis oleh penulis yang sama dengan buku super terkenal "Head First Java", yang akan dianggap oleh banyak orang sebagai jaminan kualitas :) Semoga artikel ini bermanfaat! Terima kasih atas perhatiannya, dan selamat belajar!