Bahagian 6: Bekas Servlet

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

• mengenai rangkaian ;
• mengenai seni bina perisian ;
• mengenai protokol HTTP/HTTPS ;
• tentang asas Maven;
• tentang servlets (menulis aplikasi web mudah) .

Dalam artikel lepas, kami berkenalan dengan servlet dan belajar cara membuat aplikasi web dengan bantuan mereka. Sudah tiba masanya untuk melihat dengan lebih dekat apa percutian ini tidak mungkin dilakukan tanpa - bekas servlet.

Kandungan:

• Apakah bekas servlet
• Cara menggunakan bekas servlet
• Memasang dan menjalankan Tomcat"
• Menggunakan Aplikasi kepada Tomcat
• Menggunakan protokol HTTPS dan bukannya HTTP
• Menjana sijil
• Menyediakan pelayan
• Penjanaan dinamik halaman HTML
• Alternatif kepada Tomcat

Apakah bekas servlet

Ini 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 letakkan servlet di dalamnya. Cara ia berfungsi adalah mudah: apabila pelanggan menghubungi pelayan, bekas memproses permintaannya, menentukan servlet mana yang harus memprosesnya dan meneruskannya.

Cara menggunakan bekas servlet

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

1. Menjana halaman HTML secara dinamik daripada fail JSP.
2. Menyulitkan/menyahsulit mesej HTTPS.
3. Menyediakan akses terhad untuk pentadbiran servlet.

Secara umum, kedengarannya bagus, yang tinggal hanyalah memikirkan cara menerapkan semuanya. Nah, untuk belajar menggunakan sesuatu, anda hanya perlu... cuba gunakannya :) Jadi hari ini kita akan berlatih! Bekas servlet yang paling popular ialah Apache Tomcat . Ia adalah sumber terbuka dan percuma untuk digunakan. Muat turun Tomcat untuk sistem pengendalian anda daripada pautan ini , dan mari lihat cara bekerja dengan bekas dalam tindakan.

Memasang dan menjalankan Tomcat

1. Untuk memasang Tomcat, cuma buka pek arkib yang dimuat turun ke dalam direktori yang dikehendaki.

2. Sila ambil perhatian bahawa Tomcat memerlukan Java versi 8 atau lebih tinggi untuk dijalankan. Pastikan pembolehubah persekitaran JAVA_HOME merujuk kepada versi jdk semasa.

3. Seterusnya anda perlu mengkonfigurasi akses pengguna kepada Tomcat . Ini dilakukan dalam fail tomcat-users.xml, yang terletak dalam folder conf.

   Tomcat didatangkan dengan pra-peruntukan dengan empat peranan:

   • pengurus-gui - akses kepada antara muka grafik dan halaman status;
   • skrip pengurus - akses kepada antara muka teks dan halaman status;
   • pengurus-jmx - akses kepada JMX dan halaman status;
   • status pengurus - akses hanya ke halaman status.

   Di dalam teg <tomcat-users>, kami akan menulis peranan ini secara eksplisit 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!

4. Dalam folder bin, jalankan fail startup.bat (startup.sh pada Linux).

5. Selepas beberapa saat, buka pautan http://localhost:8080/ dalam penyemak imbas anda . Pengurus grafik akan muncul di sana:

   Jika anda melihat menu sedemikian, ia bermakna Tomcat sedang berjalan.

6. Jika ia tidak berfungsi, semak pembolehubah persekitaran JAVA_HOME dan CATALINA_HOME secara manual:

   • JAVA_HOME - mesti merujuk kepada versi semasa Java 8+;
   • CATALINA_HOME - mesti merujuk kepada Tomcat atau tidak hadir (tidak boleh menunjuk kepada versi Tomcat yang lain).

Menggunakan Aplikasi kepada Tomcat

Kami berjaya melancarkan Tomcat, jadi sudah tiba masanya untuk menggunakan beberapa jenis 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 digunakan, servlet kami mesti dibungkus dalam arkib perang. Biasanya Maven digunakan untuk ini, tetapi untuk mencipta arkib perang anda memerlukan fail web.xml di mana semua servlet dipetakan. Kami menulis servlet menggunakan anotasi @WebServlet baharu, jadi kami tidak mempunyai web.xml. Nasib baik, IDEA boleh melakukan kerja kotor untuk kami dan membungkus projek kami secara individu dalam arkib perang. Untuk melakukan ini, anda perlu membuka struktur projek (Ctrl + Shift + Alt + S) -> Artifak -> Pilih minuman yang dikehendaki -> Tandai kotak di sebelah "Sertakan dalam binaan projek" -> Klik "OK". Bina projek menggunakan gabungan Ctrl + F9. Sekarang arkib perang kami berada dalam direktori sasaran. Fail boleh ditukar nama kepada sesuatu yang lebih mudah - contohnya, servlet.war - dan dialihkan ke tempat yang lebih mudah - dalam C:\my\. Apabila bancuhan sedia untuk digunakan, letakkan di dalam bekas . Ini boleh dilakukan dengan dua cara.

1. Melalui GUI

   Untuk melakukan ini, ikuti pautan http://localhost:8080/manager/html . Tomcat harus meminta anda untuk log masuk dan kata laluan.

   Jika anda mengulangi semua langkah selepas saya, maka log masuk adalah pengguna, kata laluan adalah kata laluan .

   Selepas kebenaran berjaya anda akan melihat Pengurus Aplikasi Web Tomcat. Bahagian Aplikasi sudah mengandungi 5 aplikasi - ini adalah aplikasi utiliti Tomcat yang diperlukan untuk memudahkan kerja dengannya. Mereka boleh dialih keluar pada masa hadapan.

   Di bawah ialah bahagian Deploy. Menggunakannya, anda boleh memilih arkib perang untuk digunakan. Mari kita masukkan laluan dan konteks secara manual:

   Klik "Kerahkan", kami melihat bahawa aplikasi kami telah muncul dalam bahagian Aplikasi:

   Menggunakan GUI Tomcat kita boleh menghentikannya, mulakan semula, tetapkan panjang sesi dan padamkannya. Semasa menggunakan, kami menetapkan konteks /demo, yang bermaksud bahawa aplikasi kami mesti diakses melalui pautan http://localhost:8080/demo . Semak, semuanya harus berfungsi.

2. Melalui sistem fail

   Untuk menggunakan aplikasi dengan cara ini, anda perlu membuka direktori di mana Tomcat dinyahzip dan pergi ke aplikasi web. Berikut ialah aplikasi utiliti yang biasa kami gunakan:

   Apa yang perlu kita lakukan ialah memindahkan servlet.war kita ke sini.

   Kami menunggu beberapa saat, kami melihat bahawa folder servlet baharu telah muncul, yang bermaksud bahawa aplikasi kami digunakan. Mari pergi ke antara muka Pengurus Aplikasi yang biasa - http://localhost:8080/manager/ . Di sini kita melihat bahawa aplikasi kita digunakan dalam konteks /servlet:

   Apabila digunakan dengan cara ini, konteks ditetapkan secara automatik kepada nama arkib perang yang digunakan. Untuk menukar konteks, anda boleh menamakan semula folder yang baru dibuat dengan aplikasi, tetapi sebelum itu anda perlu memadamkan fail: jika tidak, Tomcat akan menggunakan semula aplikasi dengan nama arkib.

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

Menggunakan protokol HTTPS dan bukannya HTTP

Jika anda masih ingat, kami membincangkan perbezaan antara HTTP dan HTTPS dalam artikel berasingan . HTTPS adalah protokol yang sama seperti HTTP, tetapi menggunakan penyulitan data yang dipindahkan. Di sisi pelanggan, penyulitan dikendalikan oleh penyemak imbas, dan kami mesti menyediakan penyulitan di bahagian pelayan. Memandangkan permintaan HTTP diterima dan dihalakan oleh Tomcat, adalah logik untuk mewakilkan penyulitan kepadanya. Untuk melakukan ini anda perlukan:

1. Hasilkan sijil yang ditandatangani sendiri;
2. Buat tetapan pelayan tambahan.

Jom amalkan ini.

Menjana sijil

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

• keytool - melancarkan utiliti dengan parameter;
• -genkey - menunjukkan bahawa kita ingin menjana kunci baharu;
• -alias tomcat — buat alias kunci;
• -keyalg RSA - pilih RSA sebagai algoritma penjanaan kunci.

Selepas melaksanakan arahan, utiliti akan memulakan dialog dengan kami: Masukkan maklumat yang diperlukan. Kini kami telah mencipta stor kunci dalam direktori rumah kami (untuk Windows ia ialah C:\Users\{username}\.keystore) dan kunci tomcat di dalamnya. Kami telah menghasilkan sijil ringkas yang akan diterima oleh kebanyakan penyemak imbas. Sijil ini tidak sesuai untuk aplikasi komersial: ia hanya boleh digunakan untuk tujuan ujian. Pada pelayan pengeluaran, anda mesti menggunakan sijil daripada pihak berkuasa sijil (contohnya, https://letsencrypt.org/ ).

Menyediakan pelayan

Setelah sijil sudah siap, anda perlu melaraskan tetapan pelayan, iaitu penyambung SSL. Ini dilakukan dalam fail server.xml, yang terletak di apache-tomcat-9.0.30/conf/ . Kami mencari blok seperti:

<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 di sebelahnya kami meletakkan konfigurasi kami:

<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 memberikan parameter keystoreFile dan keystorePass nilai yang relevan untuk kami, simpan dan mulakan semula Tomcat menggunakan fail shutdown.bat dan startup.bat. Sekarang pelayan bersedia untuk memproses permintaan https, hanya sedikit pada alamat yang diubah - https://localhost:8443/demo/hello . Apabila anda mengklik pada pautan, anda akan melihat amaran tentang sijil yang boleh dipersoalkan, yang tidak menghairankan. Seperti yang diterangkan sedikit sebelum ini, untuk mendapatkan sijil biasa anda perlu menggunakan perkhidmatan salah satu perkhidmatan pensijilan. Tetapi setakat ini kami telah mencapai matlamat kami: aplikasi berfungsi menggunakan protokol HTTPS, dan ini adalah perkara utama!

Penjanaan dinamik halaman HTML

Sekarang mari kita teruskan ulasan kami tentang ciri-ciri lain bekas servlet - penjanaan dinamik halaman HTML. Bayangkan dunia yang ideal di mana, bukannya membosankan kod HTML statik, anda boleh menulis kod JAVA menggunakan pembolehubah, gelung, tatasusunan dan binaan bahasa lain. Adakah anda bayangkan? Berita baiknya ialah sesuatu yang serupa wujud, berita buruknya ialah ia tidak wujud sepenuhnya. Jika anda tidak meneka, kita bercakap tentang teknologi JSP (Java Server Pages). Ringkasnya, ini adalah teknologi yang membolehkan anda memasukkan kepingan kod JAVA ke dalam halaman HTML. Benar, maka kod ini masih ditukar menjadi HTML sebelum dihantar kepada pelanggan, tetapi ia akan dijana secara dinamik dengan mengambil kira pelbagai faktor. Contohnya, anda boleh menggunakan binaan bersyarat dan menyediakan 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 . Sebenarnya... kami di sini bukan untuk ini, tetapi demi bekas servlet! Apa kaitan JSP dengannya? Mudah sahaja: transformasi kod JAVA daripada JSP kepada kod HTML dijalankan oleh bekas servlet. Apabila servlet akan memulangkan kandungan JSP sebagai respons, bekas itu mengambil perhatian dan mula-mula mengubahnya menjadi halaman HTML yang boleh dibaca pelayar sebelum menghantar kandungan tersebut kepada klien. Hari ini terdapat banyak analog teknologi JSP - Thymeleaf, FreeMarket, Misai dan lain-lain. Mereka semua bekerja pada prinsip yang sama. Yang mana satu untuk dipilih untuk bekerja adalah soal citarasa. Ini juga terpakai untuk memilih bekas servlet. Dalam contoh yang kami gunakan Tomcat, bekas yang paling biasa, tetapi sesetengah projek menggunakan yang lain. Perlu membiasakan diri secara ringkas dengan yang paling popular dan melihat perbezaan mereka daripada Tomcat.

Alternatif kepada Tomcat

1. GlassFish ialah bekas sumber terbuka yang disokong oleh Oracle.

   Tidak seperti Tomcat, ia adalah pelayan web lengkap yang, sebagai tambahan kepada servlet, boleh mengendalikan komponen lain daripada rangka kerja JavaEE. Pada masa yang sama, ia menggunakan lebih banyak RAM. Lebih fleksibel apabila memperhalusi pelayan, yang menjadikannya lebih sukar untuk digunakan. Ia berbaloi untuk digunakan apabila membangunkan aplikasi menggunakan rangka kerja JavaEE.

2. WildFly - dahulunya Jboss . Juga sumber terbuka. Dibangunkan oleh Red Hat. Nama itu ditukar untuk mengelakkan kekeliruan dengan produk syarikat lain - Platform Aplikasi Perusahaan JBoss.

   WildFly, seperti GlassFish, ialah pelayan web yang lengkap. By the way, di bawah tudung WildFly menggunakan Tomcat sebagai bekas servlet. Tidak seperti GlassFish, WildFly lebih ringan dan lebih mudah untuk disediakan.

3. Jeti - sama dengan yang sebelumnya, adalah sumber terbuka. 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.

4. WebLogic ialah perisian berlesen yang memerlukan pembelian sebelum digunakan. Dimiliki oleh Oracle.

   Berbanding dengan Tomcat, fungsinya lebih luas sedikit. Boleh bekerja dengan protokol ftp. Tetapi ia tidak begitu fleksibel semasa membangunkan dan menguji aplikasi.

5. WebSphere (Pelayan Aplikasi WebSphere tepatnya) ialah perisian berbayar. Dibangunkan oleh IBM. Sama seperti WildFly dan GlassFish, ia adalah pelayan aplikasi yang lengkap. Tetapi ia mempunyai antara muka persediaan yang lebih mesra, serta kebolehpercayaan operasi yang tinggi.

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

Bekas servlet atau pelayan aplikasi mana yang hendak dipilih bergantung pada projek tertentu. Terdapat projek di mana walaupun orang luar yang jelas akan dapat membuktikan dirinya dengan kualiti tertinggi, tetapi pada mulanya adalah lebih baik untuk memahami satu perkara dengan teliti. Mungkin calon yang ideal untuk yang ini ialah Tomcat. Kami telah pun mengambil langkah pertama dalam mengkajinya, dan kemudian terpulang kepada anda! Dalam artikel akhir siri "Pengenalan kepada Pembangunan Perusahaan", kita akan berkenalan dengan corak MVC. Bahagian 7. Pengenalan kepada corak MVC (Model-View-Controller) Bahagian 8. Menulis aplikasi kecil dalam spring-boot