Artikel
Miwiti
Mulai sinau
CodeGym /Blog Jawa /Acak /Nggawe aplikasi web prasaja nggunakake servlets lan JSPs ...
John Squirrels
tingkat
San Francisco

Nggawe aplikasi web prasaja nggunakake servlets lan JSPs (bagean 1)

Diterbitake ing grup
Kawruh sing dibutuhake kanggo mangerteni artikel kasebut: Sampeyan wis luwih utawa kurang ngerti Java Core lan pengin ndeleng teknologi JavaEE lan pemrograman web . Iku bakal nggawe paling raos yen sampeyan lagi sinau ing Java Collections nggoleki , sing gegayutan karo topik cedhak artikel.
Nggawe aplikasi web prasaja nggunakake servlets lan JSPs (bagean 1) - 1
Materi iki minangka tutugan logis saka artikelku Nggawe proyek web paling gampang ing IntelliJ Idea Enterprise . Ing artikel kasebut, aku nuduhake carane nggawe template proyek web sing bisa digunakake. Wektu iki aku bakal nuduhake sampeyan carane nggawe aplikasi web sing prasaja nanging apik banget nggunakake Java Servlet API lan JavaServer Pages API . Aplikasi kita bakal duwe kaca ngarep kanthi rong tautan:
  • pranala menyang kaca kanggo nambah pangguna;
  • link menyang dhaptar pangguna.
Kaya sadurunge, aku bakal nggunakake IntelliJ Idea Enterprise Edition , Apache Maven (kita mung bakal nyambung sawetara dependensi), lan Apache Tomcat . Pungkasane, kita bakal "beautify" aplikasi kita nggunakake framework W3.CSS . Kita bakal nganggep yen sampeyan wis duwe proyek kosong sing saiki bakal ditambahake. Yen ora, mbukak artikel pisanan lan nggawe siji. Mung sawetara menit :)

A sethitik babagan struktur aplikasi mangsa

Kaca ngarep kita (/) bakal dadi kaca HTML statis sing paling biasa kanthi header lan rong pranala/tombol:
  • nambah pangguna anyar (navigasi menyang / nambah );
  • ndeleng dhaptar pangguna (navigasi menyang / dhaptar ).
Tomcat bakal nyekel panjalukan kanggo alamat kasebut lan ngirim menyang salah siji saka rong servlet sing bakal kita lakoni (kita bakal nemtokake pemetaan ing web.xml ). Servlet banjur bakal ngolah panjalukan, nyiapake data (utawa nyimpen data, yen kita nambahake pangguna), lan nransfer kontrol menyang file JSP sing cocog , sing banjur "render" asil. Kita bakal nyimpen data ing dhaftar vanilla kosong (Dhaptar).

Nggawe kaca ngarep statis

Yen sampeyan index.jsp ing folder web, mbusak. Nanging, nggawe file HTML prasaja disebut index.html ing folder iki: 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>My super project!</title>
</head>
<body>
    <!-- header -->
    <div>
        <h1>Super app!<//h1>
    </div>

    <div>       <!-- content -->
        <div>    <!-- button holder -->
            <button onclick="location.href='/list'">List users<//button>
            <button onclick="location.href='/add'">Add user<//button>
        </div>
    </div>
</body>
</html>
Ora ana sing rumit ing kene. Ing tag judhul , kita nuduhake judhul kaca kita. Ing awak kaca, kita duwe rong div utama: header lan isi . Div isi kalebu wadhah kanggo tombol kita. Lan ing kana kita duwe rong tombol sing nggawa sampeyan menyang alamat sing cocog karo klik. Sampeyan bisa mbukak proyek lan ndeleng carane katon saiki. Yen sampeyan ngeklik tombol kasebut, sampeyan bakal entuk kaca kesalahan 404, amarga kita kaca sing cocog durung ana. Nanging kita bisa ngomong yen tombol bisa digunakake. Elinga yen iki dudu pendekatan sing paling universal: yen JavaScript dipateni ing browser, tombol kasebut ora bisa digunakake. Nanging kita bakal nganggep manawa ora ana sing mateni JavaScript. :) Temenan, sampeyan bisa njaluk kanthi pranala prasaja, nanging aku luwih seneng tombol. Sampeyan bisa nindakake nanging sampeyan seneng. Lan aja kuwatir babagan kasunyatan manawa contoku bakal duwe akeh div . Kita bakal isi karo gaya mengko, lan kabeh bakal katon luwih ayu. :)

Gawe file JSP kanggo menehi asil

Ing direktori web sing padha , gawe folder ing ngendi kita bakal nambah file JSP kita . Aku diarani ' views ', nanging maneh sampeyan bisa improvisasi. Ing folder iki, kita bakal nggawe rong file JSP:
Java webinar
  • add.jsp — kaca kanggo nambah pangguna;
  • list.jsp — kaca kanggo nampilake dhaptar pangguna.
Temtokake header kaca sing cocog kanggo dheweke. Kayata " Tambah pangguna anyar " lan " Dhaptar pangguna ", lan kita bakal tetep kaya ngono.

Nggawe rong servlet

Servlet bakal nampa lan ngolah panjaluk sing dikirim Tomcat . Ing folder src/main/java , nggawe paket app , ngendi kita bakal sijine kode sumber. Paket liyane uga bakal ana. Dadi, kanggo nyegah paket-paket kasebut ora digawe ing siji liyane, kita bakal nggawe sawetara kelas ing paket app (bakal mbusak mengko). Saiki gawe telung paket beda ing paket app :
  • entitas - entitas kita (kelas sing nggambarake obyek pangguna) menyang kene;
  • model - iki ngendi model kita (kita bakal ngomong babagan iki mengko);
  • servlets - lan iki ngendi servlets kita pindhah.
Yen wis rampung, sampeyan bisa kanthi tenang mbusak kelas kasebut saka paket app (yen sampeyan nggawe, mesthi). Ing paket servlets , nggawe rong kelas:
  • AddServlet — pangolahan panjalukan dikirim menyang / nambah ;
  • ListServlet — pangolahan panjalukan dikirim menyang / dhaftar .

Nyambungake dependensi ing Maven

Tomcat 9 .* ngleksanakake spesifikasi Servlet 4.0 lan JavaServer Pages 2.3 . Iku sing nyatakake ing baris kapindho paragraf pisanan dokumentasi resmi Tomcat 9. Iki tegese yen sampeyan, kaya aku, nggunakake versi Tomcat iki , banjur kode sing bakal sampeyan tulis lan mbukak bakal nggunakake versi kasebut. Nanging kita pengin duwe spesifikasi kasebut ing proyek kita, supaya kode kita, sing nggunakake, paling ora bisa dikompilasi. Lan kanggo nindakake iki, kita kudu ngemot menyang proyek kita. Iki ngendi Maven teka kanggo ngluwari.

Aturan umum yaiku: yen sampeyan kudu nyambungake menyang proyek sampeyan nggunakake Maven:

  • pindhah menyang situs web repositori saka Maven;
  • golek versi perpustakaan sing dibutuhake;
  • entuk kode dependensi sing kudu disisipake menyang pom.xml sampeyan;
  • tempel! :)
Ayo diwiwiti. Pisanan, nyiyapake file POM . Nang endi wae sawise entri / versi , nanging sadurunge / project , lebokake ing ngisor iki: 

<dependencies>

</dependencies>
Kita nindakake iki kanggo nuduhake yen kita bakal dhaptar dependensi sing dibutuhake ing tag kasebut. Saiki pindhah menyang mvnrepository.com . Ana kolom telusuran ing sisih ndhuwur. Kanggo miwiti, goleki ' servlet '. Asil pisanan, sing wis digunakake luwih saka pitung ewu, cocog karo kita. Elinga, kita butuh versi 4.0 (kanggo Tomcat 9). Versi liyane bisa uga cocog kanggo implementasine lawas. Iki minangka versi sing cukup anyar, mula ora akeh panggunaan. Nanging kita butuh. A kaca mbukak ngendi sampeyan bisa njaluk kode kanggo dependensi iki kanggo macem-macem manager paket, utawa sampeyan mung bisa ngundhuh. Nanging amarga kita pengin nyambungake nggunakake Maven, kita bakal milih kode ing tab Maven. Kita nyalin lan nempel menyang bagean dependensi file POM kita. Yen sampeyan entuk kabar sing takon apa sampeyan pengin ngaktifake ngimpor otomatis ing pojok sisih tengen ngisor IDEA , terusake lan setuju. Yen sampeyan ora sengaja nolak, pindhah menyang " Setelan " lan aktifake ngimpor otomatis kanthi manual: Setelan (Ctrl + Alt + S) -> Build, Execution, Deployment -> Maven -> Importing .lan file konfigurasi IDEA kanggo proyek iki ing sinkronisasi. Kanthi prinsip sing padha, kita bakal nemokake lan nyambungake JavaServer Pages 2.3 (goleki "JSP"). Lan wiwit kita wis miwiti Maven, ayo kang mung marang iku file sumber kita tindakake Java 8 sintaks, lan kita kudu ngumpulake menyang bytecode kanggo versi sing. Sawise kabeh langkah iki, pom.xml kita bakal katon kaya iki: 

<?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>cc.codegym.info.fatfaggy</groupId>
    <artifactId>my-super-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compile.source>1.8</maven.compile.source>
        <maven.compile.target>1.8</maven.compile.target>
    </properties>

    <dependencies>
        <!-- Servlet API 4.0 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- JavaServer Pages API 2.3 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

Nggawe servlets kita dadi servlets nyata

Ing wayahe, pasangan servlet sing digawe iku sejatine kelas biasa. Dheweke ora duwe fungsi. Nanging saiki kita wis nyambungake Servlet API kanggo proyek kita, lan kita bisa nggunakake sawijining kelas. Kanggo nggawe servlet kita "nyata", kabeh sing kudu kita lakoni yaiku nggawe dheweke duwe kelas HttpServlet .

Pemetaan utawa markup

Saiki luwih becik kanggo ngandhani Tomcat manawa panjaluk alamat / add diproses dening AddServlet , lan panjaluk alamat / dhaptar ditangani dening ListServlet . Proses iki diarani pemetaan (markup). Iki ditindakake ing web.xml nggunakake prinsip sing padha:
  • kanggo miwiti, njlèntrèhaké servlet (nyedhiyakake sawetara jeneng lan nemtokake path kanggo kelas dhewe);
  • banjur ikatan servlet iki menyang alamat tartamtu (nemtokake jeneng servlet, sing mung diwenehi, lan nemtokake alamat sing panjalukane kudu dikirim menyang servlet iki).
Nerangake servlet: 

<servlet>
    <servlet-name>add</servlet-name>
    <servlet-class>app.servlets.AddServlet</servlet-class>
</servlet>
Saiki ikatan menyang alamat: 

<servlet-mapping>
    <servlet-name>add</servlet-name>
    <url-pattern>/add</url-pattern>
</servlet-mapping>
Nalika sampeyan bisa ndeleng, servlet-jeneng padha ing loro kasus. Akibaté, Tomcat ngerti yen panjalukan kanggo / nambah ditampa, kudu dikirim menyang app.servlets.AddServlet. Kita nindakake perkara sing padha karo servlet kapindho. Pungkasane, web.xml kita nduweni kira-kira isi ing ngisor iki: 

<?xml version="1.0" encoding="UTF-8"?>
<web-app 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"
         version="3.1">

    <!-- add servlet -->
    <servlet>
        <servlet-name>add</servlet-name>
        <servlet-class>app.servlets.AddServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>add</servlet-name>
        <url-pattern>/add</url-pattern>
    </servlet-mapping>

    <!-- list servlet -->
    <servlet>
        <servlet-name>list</servlet-name>
        <servlet-class>app.servlets.ListServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>list</servlet-name>
        <url-pattern>/list</url-pattern>
    </servlet-mapping>
</web-app>
Miturut cara, kita ora nggawe markup kanggo kaca ngarep (/). Kasunyatan iku kita ora perlu ing kasus iki. Kaca ngarep kita minangka file HTML prasaja sing mung nampilake rong tombol. Ora ana isi dinamis, supaya kita ora perlu nggawe servlet kapisah kanggo panjalukan saka / sing bakal nindakake apa-apa nanging nerusake eksekusi kanggo sawetara JSP (kang uga kudu digawe) kanggo tarik rong tombol kanggo kita. Kita ora butuh iki. Kaca statis cocog karo kita. Nalika Tomcat nampa panjaluk, bakal mriksa manawa ana siji servlet sing bisa ngolah panyuwunan alamat kasebut, banjur bakal weruh manawa alamat iki wis ngemot file HTML sing wis siap ., kang bakal ngawula munggah. Kita bisa mbukak aplikasi maneh (restart server utawa redeploy maneh-apa wae sing disenengi) lan priksa manawa kaca ngarep wis digawe, ora ana sing rusak, lan transisi kedadeyan nalika ngeklik tombol kasebut (sanajan ana kesalahan maneh). Miturut cara, nalika sadurunge entuk kesalahan 404, saiki entuk 405. Tegese pemetaan kasebut bisa digunakake lan servlet ditemokake, nanging ora ana cara sing cocog kanggo nangani panjaluk kasebut.

Short digression: apa mengkono "ing hood"?

Sampeyan bisa uga wis mikir babagan cara aplikasi kita bisa digunakake ing Tomcat. Apa sing kedadeyan ing kana? Lan ing ngendi cara utama ()? Sanalika sampeyan pindhah menyang localhost:8080 ing browser sampeyan, browser ngirim panjalukan menyang alamat iki nggunakake protokol HTTP. Muga-muga sampeyan wis ngerti manawa ana macem-macem jinis panjaluk, lan sing paling populer yaiku GET lan POST. Saben panjaluk kudu dijawab. A panjalukan GET wis samesthine kanggo nampa respon saka siap-kanggo-nggunakake kode HTML, bali menyang browser. Browser banjur ngganti kode bakal kabeh huruf cantik, tombol, lan formulir. A request POST sethitik liyane menarik, awit uga kaleksanane sawetara informasi. Contone, umpamane sampeyan ngetik kredensial ing formulir registrasi utawa mlebu ing situs web, banjur klik "Kirim". Iki nyebabake panjalukan POST karo informasi pribadhi dikirim menyang server. Server nampa informasi iki, ngolah, lan ngasilake sawetara respon (contone, kaca HTML karo profil sampeyan). Bentenane utama ing antarane yaiku panjaluk GET mung digunakake kanggo njupuk data saka server, dene panjaluk POST nggawa sawetara informasi (lan data ing server bisa diganti). Contone, nalika sampeyan ngunggah gambar menyang server, iku digawa ana ing request POST lan server nambah menyang database, IE ana owah-owahan. Saiki bali menyang Tomcat. Nalika nampa panjalukan saka klien, katon ing alamat. Iku mriksa apa ana servlet cocok kanggo proses panjalukan kanggo alamat kasebut (utawa sumber kasedhiya sing bisa bali langsung). Yen ora nemokake apa-apa kanggo bali, banjur nanggapi karo kesalahan 404 tinimbang kaca HTML. Nanging yen nemokake servlet sing cocog "lungguh" ing alamat kasebut, banjur katon ing jinis panyuwunan (GET, POST, utawa liya-liyane) lan takon servlet yen duwe metode sing bisa nangani pitakon jinis iki. Yen servlet ngandika ora ngerti carane nangani jinis iki, banjurTomcat ngasilake kode 405. Lan iki mung kedadeyan ing proyek kita. Nanging yen servlet sing cocok ditemokake, lan nduweni cara sing cocok, banjur Tomcat nggawe obyek servlet, diwiwiti ing thread anyar(sing ngidini mbukak dhewe), lan Tomcat terus karya dhewe, nampa lan ngirim panjalukan. Kajaba iku, Tomcat nggawe rong obyek liyane: HttpServletRequest (sing bakal diarani "request"), lan HttpServletResponse (sing bakal daksebut "respon"). Iki nempatake kabeh data sing ditampa saka panjalukan klien menyang obyek pisanan, supaya kabeh data kasebut bisa diekstrak saka iku. Banjur sawise kabeh iki, loro obyek kasebut ditransfer menyang cara sing cocog saka servlet sing diwiwiti ing benang sing kapisah. Sanalika servlet rampung karya lan wis respon siap dikirim menyang klien, gelombang flag ing Tomcat, ngandika "Aku wis rampung. Kabeh wis siyap ". Tomcat nampa respon lan dikirim menyang klien. Iki ngidini Tomcat nampa panjalukan lan ngirim tanggapan, tanpa dadi disambi, lan kabeh karya wis rampung dening servlets mlaku ing Utas kapisah. Tegese nalika nulis kode servlet, kita nemtokake apa sing bakal ditindakake. Lan sampeyan bisa mikir cara utama () dumunung ing Tomcat dhewe (ya, ditulis ing Jawa), lan nalika kita "dibukak" Tomcat, cara utama () diwiwiti. Nggawe aplikasi web prasaja nggunakake servlets lan JSPs (bagean 1) - 2
Java university

Gunakake servlets kanggo nyekel cara GET lan ngirim respon super prasaja

Saiki, servlet kita ora duwe metode sing cocog (GET), mula Tomcat ngasilake kesalahan 405. Ayo padha nggawe! Kelas HttpServlet, sing diwarisake dening servlet, nyatakake macem-macem cara. Kanggo nemtokake kode tartamtu kanggo metode, kita mung ngganti. Ing kasus iki, kita kudu ngganti doGet()cara ing loro servlets. 

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

}
Minangka sampeyan bisa ndeleng, cara iki njupuk rong argumen: req (request) lan resp (respon). Iki minangka obyek sing Tomcat nggawe lan populates kanggo kita nalika nelpon cara sing cocog ing servlet. Kanggo miwiti, kita bakal nggawe respon sing paling gampang. Kanggo nindakake iki, kita bakal njupuk obyek resp lan njaluk obyek PrintWriter saka iku. Jinis obyek iki digunakake kanggo nyipta respon. Kita bakal nggunakake kanggo output string prasaja. 

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.println("GET method from AddServlet");
}
Kita bakal nindakake sing padha ing ListServlet, banjur kita bakal miwiti maneh server. Nalika sampeyan bisa ndeleng, kabeh bisa! Nalika sampeyan ngeklik tombol, sampeyan entuk kaca kanthi teks sing "ditulis" karo PrintWriter. Nanging file JSP sing disiapake kanggo ngasilake kaca kanthi tanggapan ora digunakake. Iku mung amarga padha ora tau dieksekusi. Servlet kita nggawe respon dhewe lan rampung mlaku, menehi tandha marang Tomcat yen wis siyap nanggapi klien. Tomcat mung njupuk respon lan ngirim maneh menyang klien. Ayo pass kontrol saka servlets menyang file JSP. Kita bakal ngganti kode cara kita kaya ing ngisor iki:
  • kita entuk obyek dispatcher request saka obyek request, lan pass alamat kaca JSP sing arep kita transfer kontrol;
  • kita nggunakake obyek iki kanggo nransfer kontrol menyang kaca JSP kasebut, ora lali kanggo pass panjalukan lan respon obyek sing ditampa saka Tomcat.

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
    requestDispatcher.forward(req, resp);
}
Ing tag awak kaca JSP, sampeyan bisa nambah soko supaya kita bisa ndeleng kanthi jelas kaca sing ditampilake. Yen wis rampung, miwiti maneh server lan mriksa. Kita klik tombol ing kaca utama lan kaca mbukak, sing tegese panjalukan dikirim menyang servlets. Banjur kontrol diterusake menyang kaca JSP, sing saiki diwenehake. Semono wae. Ing bagean sabanjure artikel iki, kita bakal ngupayakake fungsi aplikasi kita.

Wacan liyane:
Komentar
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION