Bahagian 6. Bekas Servlet

Bahan ini adalah sebahagian daripada siri "Pengenalan kepada Pembangunan Perusahaan". Artikel sebelumnya:

Dalam artikel lepas, kami berkenalan dengan servlet dan mempelajari cara menggunakannya untuk membuat aplikasi web. Masanya telah tiba untuk melihat dengan lebih dekat bahagian penting keseronokan ini: bekas servlet.

Isi kandungan:

Apakah bekas servlet?

Ia adalah program yang berjalan pada pelayan dan boleh berinteraksi dengan servlet yang kami cipta. Dalam erti kata lain, jika kami ingin menjalankan aplikasi web kami pada pelayan, kami mula-mula menggunakan bekas servlet dan kemudian meletakkan servlet di dalamnya. Aliran kerja adalah mudah: apabila pelanggan mengakses pelayan, bekas memproses permintaannya, menentukan servlet mana yang harus memprosesnya, dan kemudian menghantar permintaan itu bersama-sama. Bahagian 6. Bekas Servlet - 2

Bagaimanakah bekas servlet digunakan?

Sebagai tambahan kepada permintaan penghalaan, bekas servlet melaksanakan fungsi lain:

Ia secara dinamik menjana halaman HTML daripada fail JSP.
Ia menyulitkan/menyahsulit mesej HTTPS.
Ia menyediakan akses terhad untuk pentadbiran servlet.

Secara umum, ini semua terdengar baik. Sekarang kita hanya perlu memikirkan bagaimana untuk melaksanakan semuanya. Nah, untuk belajar cara menggunakan sesuatu, hanya selami dan cuba gunakannya :) Jadi, hari ini kita akan berlatih! Bekas servlet yang paling popular ialah Apache Tomcat . Ia adalah sumber terbuka dan boleh digunakan secara percuma. Muat turun Tomcat untuk sistem pengendalian anda di sini dan kami akan meneroka kerja dengan bekas "dalam tindakan".

Memasang dan memulakan Tomcat

Untuk memasang Tomcat, hanya nyahzip arkib yang dimuat turun ke dalam direktori yang dikehendaki.
Sila ambil perhatian bahawa Tomcat memerlukan Java versi 8 atau lebih tinggi untuk dimulakan dan dijalankan. Sahkan bahawa pembolehubah persekitaran JAVA_HOME merujuk versi semasa JDK.
Seterusnya, anda perlu mengkonfigurasi akses pengguna kepada Tomcat . Ini dilakukan dalam fail tomcat-users.xml, yang terletak dalam folder conf.

Terdapat empat peranan pratetap dalam Tomcat:
- manager-gui — Akses kepada antara muka grafik dan halaman status
- skrip pengurus — Akses kepada antara muka teks dan halaman status
- manager-jmx — Akses kepada JMX dan halaman status
- status pengurus — Akses hanya ke halaman status
Di dalam teg <tomcat-users>, kami secara eksplisit menyatakan peranan ini dan memberikannya kepada 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"/>
```
Kini semuanya sedia untuk dilancarkan!
Dalam folder bin, jalankan fail startup.bat (startup.sh pada Linux).
Selepas beberapa saat, buka pautan http://localhost:8080/ dalam pelayar anda. Anda akan melihat papan pemuka grafik:

Jika anda melihat menu seperti ini, maka Tomcat sedang berjalan.
Jika ia tidak berjalan, semak pembolehubah persekitaran JAVA_HOME dan CATALINA_HOME secara manual:
- JAVA_HOME — Ini mesti merujuk versi semasa Java 8+.
- CATALINA_BASE — Ini mesti merujuk Tomcat atau tidak hadir (ia tidak sepatutnya merujuk versi Tomcat yang lain).

Menggunakan aplikasi dalam Tomcat

Kami berjaya melancarkan Tomcat, jadi sudah tiba masanya untuk menggunakan beberapa projek di dalamnya. Mari gunakan servlet dari artikel sebelumnya . MainServlet:

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

IndexServlet:

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 menggunakan, kami perlu membungkus servlet kami dalam fail WAR. Maven biasanya digunakan untuk melakukan ini, tetapi untuk mencipta fail WAR anda memerlukan fail web.xml yang mempunyai pemetaan untuk semua servlet. Kami menggunakan anotasi @WebServlet baharu untuk menulis servlet, jadi kami tidak mempunyai fail web.xml. Nasib baik, IDEA boleh melakukan kerja kotor untuk kami, membungkus projek kami dalam fail WAR. Untuk melakukan ini, buka struktur projek (Ctrl+Shift+Alt+S) -> Artifak -> Pilih fail WAR yang dikehendaki -> Pilih kotak semak di sebelah "Sertakan dalam binaan projek" -> Klik "OK". Bahagian 6. Bekas Servlet - 4

Mari bina projek menggunakan kombinasi kekunci Ctrl+F9. Sekarang fail WAR kami berada dalam direktori sasaran Bahagian 6. Bekas Servlet - 5

Fail boleh ditukar nama kepada sesuatu yang lebih mudah, cth servlet.war, dan dipindahkan ke tempat yang lebih mudah, cth C:\\my\\.kita masukkan dalam bekas . Terdapat dua cara untuk melakukan ini.

Menggunakan antara muka grafik

Untuk melakukan ini, ikuti pautan ini: http://localhost:8080/manager/html . Tomcat harus meminta nama pengguna dan kata laluan.

Jika anda mengikuti bersama saya sehingga ke tahap ini, maka nama pengguna ialah "pengguna", dan kata laluan ialah "kata laluan" .

Selepas berjaya melog masuk, anda akan melihat Pengurus Aplikasi Web Tomcat. Bahagian "Aplikasi" sudah mengandungi 5 aplikasi — ini adalah utiliti Tomcat, yang menjadikan Tomcat lebih mudah untuk digunakan. Mereka boleh dipadamkan pada masa hadapan.

Di bawah ialah bahagian "Deploy". Di sini anda boleh memilih arkib WAR untuk digunakan. Mari kita masukkan laluan dan konteks secara manual:

Klik "Kerahkan" dan kami melihat bahawa aplikasi kami telah muncul dalam bahagian "Aplikasi":
Menggunakan antara muka grafik Tomcat, kami boleh menghentikan, memulakan semula dan memadam sesi, serta menetapkan panjang sesi. Semasa menggunakan, kami menetapkan konteks /demo, yang bermaksud bahawa aplikasi kami diakses menggunakan http://localhost:8080/demo . Semak ia. Semuanya harus berfungsi.
Melalui sistem fail

Untuk menggunakan aplikasi dengan cara ini, anda perlu membuka direktori tempat Tomcat telah dinyahzip. Kemudian pergi ke folder "webapps". Di sini anda akan menemui utiliti yang telah kami temui:

Apa yang diperlukan ialah kami memindahkan fail servlet.war kami di sini.

Kami menunggu beberapa saat dan kemudian melihat bahawa folder "servlet" baharu telah muncul. Ini bermakna aplikasi kami digunakan. Pergi ke antara muka Pengurus Aplikasi di http://localhost:8080/manager/ . Di sini kita melihat bahawa aplikasi kita digunakan dalam konteks /servlet:

Apabila digunakan dengan cara ini, konteks ditetapkan secara automatik berdasarkan nama fail WAR yang digunakan. Untuk menukar konteks, anda boleh menamakan semula folder yang baru dibuat yang mengandungi aplikasi, tetapi sebelum berbuat demikian anda perlu mengalih keluar fail WAR. Jika tidak, Tomcat akan menggunakan semula aplikasi dengan nama arkib.

Seperti yang anda lihat, menggunakan aplikasi dalam Tomcat adalah lebih mudah daripada yang kelihatan. Tetapi fungsinya yang lain juga mudah digunakan. Jom semak.

Menggunakan HTTPS dan bukannya HTTP

Jika anda masih ingat, kami melihat perbezaan antara HTTP dan HTTPS dalam artikel berasingan . HTTPS adalah protokol yang sama seperti HTTP, tetapi ia menyulitkan data yang dihantar. Di sisi pelanggan, penyemak imbas bertanggungjawab untuk penyulitan, tetapi kami mesti menyediakan penyulitan di sebelah pelayan. Memandangkan Tomcat menerima dan mengarahkan permintaan HTTP, masuk akal untuk mewakilkan penyulitan kepadanya. Untuk melakukan ini, kita mesti:

Hasilkan sijil yang ditandatangani sendiri
Buat tetapan pelayan tambahan

Mari kita berlatih melakukan ini.

Menjana sijil

Tanpa mengira versi, JDK termasuk sejumlah besar utiliti. Salah satunya ialah keytool . Ini ialah alat untuk menjana dan bekerja dengan kunci penyulitan. Untuk menggunakannya, pada baris arahan, pergi ke direktori C:\\Program Files\\Java\\jdk1.8.0_181\\bin dan jalankan arahan keytool -genkey -alias tomcat -keyalg RSA .

keytool — Nama utiliti yang kami jalankan dengan pilihan baris arahan
-genkey — Tunjukkan bahawa kami ingin menjana kunci baharu
-alias tomcat — Buat alias kunci
-keyalg RSA — Pilih RSA sebagai algoritma penjanaan kunci

Selepas melaksanakan arahan, utiliti memulakan dialog dengan kami: Bahagian 6. Bekas Servlet - 11

Masukkan maklumat yang diperlukan. Kini kami telah mencipta stor kunci dalam direktori rumah kami (untuk Windows, ini ialah C:\\Users\\{username}\\.keystore) dan kunci tomcat di dalamnya. Kami menjana sijil mudah yang kebanyakan pelayar akan mengadu. Sijil sedemikian tidak sesuai untuk aplikasi komersial: ia hanya boleh digunakan untuk tujuan ujian. Pada pelayan pengeluaran, anda perlu menggunakan sijil daripada pihak berkuasa pensijilan (contohnya, https://letsencrypt.org/ ).

Mengkonfigurasi pelayan

Sekarang bahawa sijil sudah sedia, kita perlu melaraskan tetapan pelayan, iaitu, penyambung SSL. Ini dilakukan dalam fail server.xml, yang terletak di apache-tomcat-9.0.30/conf/ . Di dalamnya, kami dapati 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 meletakkan konfigurasi kami di sebelah mereka:

<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 terkini kepada parameter keystoreFile dan keystorePass, simpan fail, dan kemudian mulakan semula Tomcat menggunakan fail shutdown.bat dan startup.bat. Sekarang pelayan bersedia untuk memproses permintaan HTTPS. Alamat telah berubah sedikit sahaja: https://localhost:8443/demo/hello . Apabila anda mengklik pada pautan, anda akan menerima amaran tentang kebolehpercayaan sijil, yang tidak menghairankan. Seperti yang kami katakan sedikit sebelum ini, anda perlu menggunakan perkhidmatan salah satu pihak berkuasa pensijilan untuk mendapatkan sijil biasa. Tetapi buat masa ini, kami telah mencapai matlamat kami: aplikasi berjalan menggunakan protokol HTTPS, dan itu penting!

Menjana halaman HTML secara dinamik

Kini kami akan meneruskan gambaran keseluruhan kami tentang bekas servlet dengan mempertimbangkan ciri lain: penjanaan halaman HTML yang dinamik. Bayangkan dunia yang sempurna di mana, bukannya membosankan kod HTML statik, anda boleh menulis kod Java, menggunakan pembolehubah, gelung, tatasusunan dan binaan bahasa lain. Adakah anda dapat membayangkannya? Berita baiknya ialah sesuatu yang serupa wujud. Berita buruknya ialah ia tidak mencapai fantasi ini sepenuhnya. Jika anda tidak meneka, kita bercakap tentang JavaServer Pages (JSP). Ringkasnya, ini adalah teknologi yang membolehkan anda memasukkan kepingan kod Java ke dalam halaman HTML. Benar, kod Java ini masih ditukar kepada HTML sebelum ia dihantar kepada pelanggan, tetapi HTML itu akan dijana secara dinamik, dengan mengambil kira pelbagai faktor. Sebagai contoh, anda boleh menggunakan pernyataan bersyarat dan mengembalikan kandungan yang berbeza bergantung pada beberapa syarat. 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 boleh membaca lebih lanjut mengenai JSP di sini. Pada penghujung hari, artikel ini bukan tentang JSP — kami di sini untuk bercakap tentang bekas servlet! Jadi mengapa kami menyebut JSP? Mudah sahaja: bekas servlet ialah perkara yang menukar kod Java daripada JSP kepada HTML. Apabila servlet akan mengembalikan kandungan JSP sebagai respons, bekas mengambil perhatian dan mula-mula menukarnya menjadi halaman HTML mesra pelayar sebelum menghantar kandungan tersebut kepada klien. Hari ini, terdapat banyak analog kepada teknologi JSP — Thymeleaf, FreeMarket, Misai dan lain-lain. Mereka semua bekerja dengan cara yang sama. Mana antara mereka untuk dipilih untuk kerja anda adalah soal citarasa. Ini juga terpakai untuk memilih bekas servlet. Dalam contoh ini, kami menggunakan Tomcat, bekas yang paling biasa, tetapi sesetengah projek menggunakan bekas lain. Adalah berfaedah untuk menyemak secara ringkas yang paling popular dan pertimbangkan perbezaannya daripada Tomcat.

Alternatif kepada Tomcat

GlassFish ialah bekas sumber terbuka yang pembangunannya disokong oleh Oracle.

Tidak seperti Tomcat, ia adalah pelayan web sepenuhnya, yang, sebagai tambahan kepada servlet, boleh beroperasi dengan komponen lain daripada rangka kerja JavaEE. Yang berkata, ia menggunakan lebih banyak RAM. Terdapat fleksibiliti yang lebih besar apabila memperhalusi pelayan, yang merumitkan penggunaannya. Ia harus digunakan semasa membangunkan aplikasi pada rangka kerja JavaEE.
WildFly sebelum ini dikenali sebagai JBoss . Ia juga merupakan sumber terbuka. Ia dibangunkan oleh Red Hat. Nama itu ditukar untuk mengelakkan kekeliruan dengan satu lagi produk syarikat — Platform Aplikasi Perusahaan JBoss.

Seperti GlassFish, WildFly ialah pelayan web yang lengkap. Secara kebetulan, di bawah hud, WildFly menggunakan Tomcat sebagai bekas servlet. Tidak seperti GlassFish, WildFly lebih ringan dan mudah dikonfigurasikan.
Jeti , seperti yang sebelumnya, adalah sumber terbuka. Ia dibangunkan oleh Eclipse.

Seperti Tomcat, ia adalah bekas servlet yang ringkas, tanpa sokongan untuk semua komponen rangka kerja JavaEE. Pada masa yang sama, ia lebih ringan malah boleh dijalankan pada telefon bimbit. Ia bermula dan berhenti dengan cepat dan berskala dengan baik. Tidak seperti Tomcat, ia mempunyai komuniti dan pangkalan pengetahuan yang lebih kecil.
WebLogic ialah perisian berlesen yang mesti dibeli sebelum digunakan. Ia milik Oracle.

Ia mempunyai fungsi yang lebih luas sedikit daripada Tomcat. Ia boleh berfungsi dengan protokol FTP. Tetapi ia tidak begitu fleksibel semasa membangunkan dan menguji aplikasi.
WebSphere (Pelayan Aplikasi WebSphere, tepatnya) ialah perisian berbayar. Ia dibangunkan oleh IBM. Sama seperti WildFly dan GlassFish, ia adalah pelayan aplikasi yang lengkap. Tetapi ia mempunyai antara muka konfigurasi yang lebih mesra, serta kebolehpercayaan yang tinggi dalam operasi.

Kelemahannya termasuk fakta bahawa ia menggunakan banyak sumber dan mengambil masa yang lama untuk dimulakan dan dihentikan, yang tidak begitu mudah apabila membangunkan projek kecil.

Pilihan bekas servlet atau pelayan aplikasi yang betul bergantung pada projek tertentu. Terdapat projek yang walaupun underdog yang jelas mungkin terbukti sebagai pilihan yang sangat baik, tetapi pada mulanya adalah yang terbaik untuk membuat kajian mendalam tentang satu bekas servlet. Tomcat mungkin adalah calon yang sesuai untuk kajian ini. Dan kami telah pun mengambil langkah pertama dalam mengkajinya, tetapi dari sini terpulang kepada anda! Dalam artikel akhir siri "Pengenalan kepada Pembangunan Perusahaan", kita akan mengetahui corak MVC. Bahagian 7. Memperkenalkan corak MVC (Model-View-Controller).