Bagian 6. Kontainer servlet

Materi ini merupakan bagian dari seri "Pengantar Pengembangan Usaha". Artikel sebelumnya:

• tentang jaringan
• tentang arsitektur perangkat lunak
• tentang HTTP/HTTPS
• tentang dasar-dasar Maven
• tentang servlet (menulis aplikasi web sederhana)

Di artikel terakhir, kami berkenalan dengan servlet dan mempelajari cara menggunakannya untuk membuat aplikasi web. Waktunya telah tiba untuk melihat lebih dekat bagian penting dari kesenangan ini: wadah servlet.

Daftar isi:

• Apa itu wadah servlet?
• Bagaimana wadah servlet digunakan?
• Menginstal dan memulai Tomcat
• Menyebarkan aplikasi di Tomcat
• Menggunakan HTTPS alih-alih HTTP
• Menghasilkan sertifikat
• Mengkonfigurasi server
• Menghasilkan halaman HTML secara dinamis
• Alternatif untuk Tomcat

Apa itu wadah servlet?

Ini adalah program yang berjalan di server dan dapat berinteraksi dengan servlet yang kami buat. Dengan kata lain, jika kita ingin menjalankan aplikasi web kita di server, pertama-tama kita menerapkan wadah servlet dan kemudian memasukkan servlet ke dalamnya. Alur kerjanya sederhana: ketika klien mengakses server, wadah memproses permintaannya, menentukan servlet mana yang harus memprosesnya, dan kemudian meneruskan permintaan tersebut.

Bagaimana wadah servlet digunakan?

Selain permintaan perutean, wadah servlet melakukan fungsi lain:

1. Ini secara dinamis menghasilkan halaman HTML dari file JSP.
2. Ini mengenkripsi/mendekripsi pesan HTTPS.
3. Ini menyediakan akses terbatas untuk administrasi servlet.

Secara umum, ini semua terdengar bagus. Sekarang kita hanya perlu mencari cara untuk mempraktikkan semuanya. Nah, untuk mempelajari cara menggunakan sesuatu, cukup selami dan coba gunakan :) Jadi, hari ini kita akan berlatih! Kontainer servlet yang paling populer adalah Apache Tomcat . Ini adalah open source dan dapat digunakan secara gratis. Unduh Tomcat untuk sistem operasi Anda di sini dan kami akan mengeksplorasi bekerja dengan kontainer "beraksi".

Menginstal dan memulai Tomcat

1. Untuk menginstal Tomcat, cukup unzip arsip yang diunduh ke direktori yang diinginkan.

2. Harap perhatikan bahwa Tomcat membutuhkan Java versi 8 atau lebih tinggi untuk memulai dan menjalankan. Verifikasi bahwa variabel lingkungan JAVA_HOME mereferensikan versi JDK saat ini.

3. Selanjutnya, Anda perlu mengonfigurasi akses pengguna ke Tomcat . Ini dilakukan di file Tomcat-users.xml, yang terletak di folder conf.

   Ada empat peran preset di Tomcat:

   • manager-gui — Akses ke antarmuka grafis dan halaman status
   • skrip manajer — Akses ke antarmuka teks dan halaman status
   • manager-jmx — Akses ke JMX dan halaman status
   • manajer-status — Akses hanya ke halaman status

   Di dalam tag <Tomcat-users>, kami secara eksplisit menentukan peran ini dan menetapkannya ke pengguna kami:

   
   <role rolename="manager-gui"/>
   <role rolename="manager-script"/>
   <role rolename="manager-jmx"/>
   <role rolename="manager-status"/>
   <user username="user" password="password"
       roles="manager-gui, manager-script, manager-jmx, manager-status"/>
   

   Sekarang semuanya siap diluncurkan!

4. Di folder bin, jalankan file startup.bat (startup.sh di Linux).

5. Setelah beberapa detik, buka tautan http://localhost:8080/ di browser Anda. Anda akan melihat dasbor grafis:

   Jika Anda melihat menu seperti ini, maka Tomcat sedang berjalan.

6. Jika tidak berjalan, periksa variabel lingkungan JAVA_HOME dan CATALINA_HOME secara manual:

   • JAVA_HOME — Ini harus mengacu pada versi Java 8+ saat ini.
   • CATALINA_BASE — Ini harus mereferensikan Tomcat atau tidak ada (seharusnya tidak mereferensikan versi lain dari Tomcat).

Menyebarkan aplikasi di Tomcat

Kami berhasil meluncurkan Tomcat, jadi sekarang saatnya menerapkan beberapa proyek di dalamnya. Mari gunakan servlet dari artikel sebelumnya . Servlet Utama:

import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class MainServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
       HttpSession session = req.getSession();
       Integer visitCounter = (Integer) session.getAttribute("visitCounter");
       if (visitCounter == null) {
           visitCounter = 1;
       } else {
           visitCounter++;
       }
       session.setAttribute("visitCounter", visitCounter);
       String username = req.getParameter("username");
       resp.setContentType("text/html");
       PrintWriter printWriter = resp.getWriter();
       if (username == null) {
           printWriter.write("Hello, Anonymous" + "
");
       } else {
           printWriter.write("Hello, " + username + "
");
       }
       printWriter.write("Page was visited " + visitCounter + " times.");
       printWriter.close();
   }
}

IndeksServlet:

import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/")
public class IndexServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
       resp.sendRedirect(req.getContextPath() + "/hello");
   }
}

Sebelum menerapkan, kami perlu mengemas servlet kami dalam file WAR. Maven biasanya digunakan untuk melakukan ini, tetapi untuk membuat file WAR Anda memerlukan file web.xml yang memiliki pemetaan untuk semua servlet. Kami menggunakan anotasi @WebServlet baru untuk menulis servlet, jadi kami tidak memiliki file web.xml. Untungnya, IDEA dapat melakukan pekerjaan kotor untuk kami, membungkus proyek kami dalam file WAR. Untuk melakukan ini, buka struktur proyek (Ctrl+Shift+Alt+S) -> Artefak -> Pilih file WAR yang diinginkan -> Pilih kotak centang di sebelah "Sertakan dalam pembuatan proyek" -> Klik "OK". Mari bangun proyek menggunakan kombinasi tombol Ctrl+F9. Sekarang file WAR kita ada di direktori target. File tersebut dapat diubah namanya menjadi sesuatu yang lebih sederhana, misalnya servlet.war, dan dipindahkan ke tempat yang lebih nyaman, misalnya C:\\my\\.kami akan memasukkannya ke dalam wadah . Ada dua cara untuk melakukan ini.

1. Menggunakan antarmuka grafis

   Untuk melakukannya, ikuti tautan ini: http://localhost:8080/manager/html . Tomcat harus meminta nama pengguna dan kata sandi.

   Jika Anda mengikuti saya sampai saat ini, maka nama penggunanya adalah "pengguna", dan kata sandinya adalah "kata sandi" .

   Setelah berhasil masuk, Anda akan melihat Manajer Aplikasi Web Tomcat. Bagian "Aplikasi" sudah berisi 5 aplikasi — ini adalah utilitas Tomcat, yang membuat Tomcat lebih mudah digunakan. Mereka dapat dihapus di masa mendatang.

   Di bawah ini adalah bagian "Menyebarkan". Di sini Anda dapat memilih arsip WAR untuk diterapkan. Mari masukkan jalur dan konteks secara manual:

   Klik "Sebarkan" dan kami melihat bahwa aplikasi kami telah muncul di bagian "Aplikasi":

   Menggunakan antarmuka grafis Tomcat, kita dapat menghentikan, memulai ulang, dan menghapus sesi, serta mengatur panjang sesi. Saat menerapkan, kami menentukan konteks /demo, yang berarti bahwa aplikasi kami diakses menggunakan http://localhost:8080/demo . Periksa. Semuanya harus bekerja.

2. Melalui sistem file

   Untuk menggunakan aplikasi dengan cara ini, Anda perlu membuka direktori tempat Tomcat dibuka ritsletingnya. Lalu buka folder "webapps". Di sini Anda akan menemukan utilitas yang telah kami temui:

   Yang diperlukan hanyalah memindahkan file servlet.war kita ke sini.

   Kami menunggu beberapa detik dan kemudian melihat folder "servlet" baru telah muncul. Ini berarti bahwa aplikasi kita dikerahkan. Buka antarmuka Application Manager di http://localhost:8080/manager/ . Di sini kita melihat bahwa aplikasi kita di-deploy dalam konteks /servlet:

   Saat diterapkan dengan cara ini, konteks ditetapkan secara otomatis berdasarkan nama file WAR yang diterapkan. Untuk mengubah konteksnya, Anda dapat mengganti nama folder yang baru dibuat yang berisi aplikasi tersebut, tetapi sebelum melakukannya, Anda perlu menghapus file WAR. Jika tidak, Tomcat akan menerapkan ulang aplikasi dengan nama arsip.

   Seperti yang Anda lihat, menerapkan aplikasi di Tomcat jauh lebih mudah daripada yang terlihat. Namun fungsi lainnya juga mudah digunakan. Mari kita periksa.

Menggunakan HTTPS alih-alih HTTP

Jika Anda ingat, kami melihat perbedaan antara HTTP dan HTTPS di artikel terpisah . HTTPS adalah protokol yang sama dengan HTTP, tetapi mengenkripsi data yang sedang dikirim. Di sisi klien, browser bertanggung jawab atas enkripsi, tetapi kami harus menyediakan enkripsi di sisi server. Karena Tomcat menerima dan merutekan permintaan HTTP, masuk akal untuk mendelegasikan enkripsi padanya. Untuk melakukan ini, kita harus:

1. Hasilkan sertifikat yang ditandatangani sendiri
2. Buat pengaturan server tambahan

Mari berlatih melakukan ini.

Menghasilkan sertifikat

Terlepas dari versinya, JDK menyertakan sejumlah besar utilitas. Salah satunya adalah alat kunci . Ini adalah alat untuk menghasilkan dan bekerja dengan kunci enkripsi. Untuk menggunakannya, pada baris perintah, buka direktori C:\\Program Files\\Java\\jdk1.8.0_181\\bin dan jalankan perintah keytool -genkey -alias tomcat -keyalg RSA .

• keytool — Nama utilitas yang kami jalankan dengan opsi baris perintah
• -genkey — Menunjukkan bahwa kita ingin membuat kunci baru
• -alias tomcat — Membuat alias kunci
• -keyalg RSA — Pilih RSA sebagai algoritme pembuatan kunci

Setelah menjalankan perintah, utilitas memulai dialog dengan kami: Masukkan informasi yang diperlukan. Sekarang kami telah membuat keystore di direktori home kami (untuk Windows, ini adalah C:\\Users\\{username}\\.keystore) dan kunci Tomcat di dalamnya. Kami membuat sertifikat sederhana yang akan dikeluhkan sebagian besar browser. Sertifikat semacam itu tidak cocok untuk aplikasi komersial: hanya dapat digunakan untuk tujuan pengujian. Di server produksi, Anda perlu menggunakan sertifikat dari otoritas sertifikasi (misalnya, https://letsencrypt.org/ ).

Mengkonfigurasi server

Sekarang sertifikat sudah siap, kita perlu menyesuaikan pengaturan server, yaitu konektor SSL. Ini dilakukan di file server.xml, yang terletak di apache-tomcat-9.0.30/conf/ . Di dalamnya, kami menemukan blok seperti ini:

<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
               maxThreads="150" SSLEnabled="true">
        <SSLHostConfig>
            <Certificate certificateKeystoreFile="conf/localhost-rsa.jks"
                         type="RSA" />
        </SSLHostConfig>
 </Connector>

dan kami menempatkan konfigurasi kami di sebelahnya:

    <Connector
           protocol="org.apache.coyote.http11.Http11NioProtocol"
           port="8443" maxThreads="200"
           scheme="https" secure="true" SSLEnabled="true"
           keystoreFile="C:\Users\user\.keystore" keystorePass="mypass"
           clientAuth="false" sslProtocol="TLS"/>

Kami menetapkan nilai terbaru ke parameter keystoreFile dan keystorePass, menyimpan file, lalu memulai ulang Tomcat menggunakan file shutdown.bat dan startup.bat. Sekarang server siap memproses permintaan HTTPS. Alamatnya sedikit berubah: https://localhost:8443/demo/hello . Ketika Anda mengklik tautan tersebut, Anda akan menerima peringatan tentang kepercayaan sertifikat, yang tidak mengherankan. Seperti yang kami katakan sebelumnya, Anda perlu menggunakan layanan dari salah satu otoritas sertifikasi untuk mendapatkan sertifikat normal. Namun untuk saat ini, kami telah mencapai tujuan kami: aplikasi berjalan menggunakan protokol HTTPS, dan itu penting!

Menghasilkan halaman HTML secara dinamis

Sekarang kita akan melanjutkan ikhtisar wadah servlet dengan mempertimbangkan fitur lain: pembuatan halaman HTML yang dinamis. Bayangkan dunia yang sempurna di mana, alih-alih kode HTML statis yang membosankan, Anda dapat menulis kode Java, menggunakan variabel, loop, array, dan konstruksi bahasa lainnya. Apakah Anda mampu membayangkannya? Kabar baiknya adalah ada sesuatu yang serupa. Berita buruknya adalah tidak sepenuhnya mencapai fantasi ini. Jika Anda belum menebaknya, kita berbicara tentang JavaServer Pages (JSP). Singkatnya, ini adalah teknologi yang memungkinkan Anda menyisipkan potongan kode Java ke dalam halaman HTML. Benar, kode Java ini masih diubah menjadi HTML sebelum dikirim ke klien, tetapi HTML tersebut akan dibuat secara dinamis, dengan mempertimbangkan berbagai faktor. Misalnya, Anda dapat menggunakan pernyataan bersyarat dan mengembalikan konten yang berbeda tergantung pada beberapa kondisi. Contoh halaman JSP:

<%@ page language="java"" %>
<html>
<head>
<title>JSP</title>
</head>

<body>
<%
String firstName="name";
String secondName="surname";
    
    if (firstName.equals("name")){
      out.print("Hello: "+firstName+"<br>");
    }

    if (firstName.equals("name") && secondName.equals("surname"))
    {
      out.print("Hello, my dear friend! <br>");
    }
    else
    {
      out.print("I don't know you. Go away! <br>");
    }
%>
</body>
</html>

Anda dapat membaca lebih lanjut tentang JSP di sini. Pada akhirnya, artikel ini bukan tentang JSP — kami di sini untuk berbicara tentang kontainer servlet! Jadi mengapa kami menyebutkan JSP? Sederhana: wadah servlet adalah yang mengubah kode Java dari JSP ke HTML. Saat servlet akan mengembalikan konten JSP sebagai respons, penampung mencatat dan pertama-tama mengubahnya menjadi halaman HTML yang ramah browser sebelum mengirimkan konten tersebut ke klien. Saat ini, ada banyak analog dengan teknologi JSP — Thymeleaf, FreeMarket, Moustache, dan lain-lain. Mereka semua bekerja dengan cara yang sama. Manakah dari mereka yang dipilih untuk pekerjaan Anda adalah masalah selera. Ini juga berlaku untuk memilih wadah servlet. Dalam contoh ini, kami menggunakan Tomcat, container yang paling umum, tetapi beberapa proyek menggunakan container lain. Penting untuk meninjau secara singkat yang paling populer dan mempertimbangkan perbedaannya dari Tomcat.

Alternatif untuk Tomcat

1. GlassFish adalah wadah sumber terbuka yang pengembangannya didukung oleh Oracle.

   Tidak seperti Tomcat, ini adalah server web lengkap yang, selain servlet, dapat beroperasi dengan komponen lain dari kerangka kerja JavaEE. Konon, ini menggunakan lebih banyak RAM. Ada fleksibilitas yang lebih besar saat menyempurnakan server, yang memperumit penggunaannya. Ini harus digunakan saat mengembangkan aplikasi pada kerangka JavaEE.

2. WildFly sebelumnya dikenal sebagai JBoss . Itu juga open source. Ini dikembangkan oleh Red Hat. Nama diubah untuk menghindari kebingungan dengan salah satu produk perusahaan lainnya — JBoss Enterprise Application Platform.

   Seperti GlassFish, WildFly adalah server web lengkap. Kebetulan, di bawah tenda, WildFly menggunakan Tomcat sebagai wadah servlet. Tidak seperti GlassFish, WildFly lebih ringan dan mudah dikonfigurasi.

3. Jetty , seperti yang sebelumnya, adalah open source. Ini dikembangkan oleh Eclipse.

   Seperti Tomcat, ini adalah wadah servlet sederhana, tanpa dukungan untuk semua komponen kerangka kerja JavaEE. Pada saat yang sama, ini lebih ringan dan bahkan dapat dijalankan di ponsel. Ini dimulai dan berhenti dengan cepat dan berskala dengan baik. Tidak seperti Tomcat, ia memiliki komunitas dan basis pengetahuan yang lebih kecil.

4. WebLogic adalah perangkat lunak berlisensi yang harus dibeli sebelum digunakan. Itu milik Oracle.

   Ini memiliki fungsi yang sedikit lebih luas daripada Tomcat. Itu dapat bekerja dengan protokol FTP. Tapi itu tidak begitu fleksibel saat mengembangkan dan menguji aplikasi.

5. WebSphere (Server Aplikasi WebSphere, tepatnya) adalah perangkat lunak berbayar. Ini dikembangkan oleh IBM. Mirip dengan WildFly dan GlassFish, ini adalah server aplikasi yang lengkap. Tetapi ia memiliki antarmuka konfigurasi yang lebih ramah, ditambah keandalan yang tinggi dalam pengoperasiannya.

   Kekurangannya termasuk fakta bahwa ia menggunakan banyak sumber daya dan membutuhkan waktu lama untuk memulai dan menghentikannya, yang sangat tidak nyaman saat mengembangkan proyek kecil.

Pilihan wadah servlet atau server aplikasi yang tepat bergantung pada proyek tertentu. Ada proyek di mana bahkan underdog yang jelas terbukti menjadi pilihan yang sangat baik, tetapi pada awalnya yang terbaik adalah melakukan studi mendalam tentang satu wadah servlet. Tomcat mungkin adalah kandidat yang sempurna untuk penelitian ini. Dan kami telah mengambil langkah pertama dalam mempelajarinya, tetapi dari sini terserah Anda! Dalam artikel terakhir dari seri "Pengantar Pengembangan Perusahaan", kita akan mengenal pola MVC. Bagian 7. Memperkenalkan pola MVC (Model-View-Controller).