CodeGym /Java Blog /Random /Paglikha ng isang simpleng web application gamit ang mga ...

Antas

San Francisco

21 July 2023
209 views
0 comments

Paglikha ng isang simpleng web application gamit ang mga servlet at JSP (bahagi 1)

Kaalaman na kinakailangan upang maunawaan ang artikulo: Mas marami o mas kaunti na ang naisip mo na ang Java Core at gusto mong tingnan ang mga teknolohiya ng JavaEE at web programming . Ito ay magiging pinakamahalaga para sa iyo na kasalukuyang nag-aaral ng Java Collections quest , na tumatalakay sa mga paksang malapit sa artikulo.

Ang materyal na ito ay ang lohikal na pagpapatuloy ng aking artikulo Paglikha ng pinakasimpleng proyekto sa web sa IntelliJ Idea Enterprise . Sa artikulong iyon, ipinakita ko kung paano lumikha ng isang gumaganang template ng proyekto sa web. Sa pagkakataong ito, ipapakita ko sa iyo kung paano lumikha ng simple ngunit lubos na kaakit-akit na web application gamit ang Java Servlet API at ang JavaServer Pages API . Ang aming aplikasyon ay magkakaroon ng home page na may dalawang link:

isang link sa isang pahina para sa pagdaragdag ng mga user;
isang link sa listahan ng mga user.

Gaya ng dati, gagamit ako ng IntelliJ Idea Enterprise Edition , Apache Maven (magkokonekta lang kami ng ilang dependencies), at Apache Tomcat . Sa huli, "pagandahin" namin ang aming application gamit ang W3.CSS framework. Ipagpalagay namin na mayroon ka nang walang laman na proyekto na idadagdag namin ngayon. Kung hindi, patakbuhin ang unang artikulo at gumawa ng isa. Tatagal lang ng ilang minuto :)

Kaunti tungkol sa istraktura ng aming aplikasyon sa hinaharap

Ang aming home page (/) ay magiging isang pinaka-ordinaryong static na HTML page na may header at dalawang link/button:

magdagdag ng bagong user (nag-navigate sa / magdagdag );
tingnan ang listahan ng mga user (nag-navigate sa / listahan ).

Ang Tomcat ay kukuha ng mga kahilingan para sa mga address na ito at ipapadala ang mga ito sa isa sa dalawang servlet na aming gagawin (tukuyin namin ang pagmamapa sa web.xml ). Ipoproseso ng mga servlet ang mga kahilingan, maghahanda ng data (o mag-save ng data, kung magdaragdag kami ng user), at maglilipat ng kontrol sa naaangkop na mga JSP file , na pagkatapos ay "i-render" ang resulta. Iimbak namin ang data sa isang simpleng listahan ng vanilla (Listahan).

Lumikha ng isang static na home page

Kung nag-index.jsp ka sa iyong web folder, tanggalin ito. Sa halip, lumikha ng isang simpleng HTML file na tinatawag na index.html sa folder na ito:


<!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>

Walang kumplikado dito. Sa tag ng pamagat , ipinapahiwatig namin ang pamagat ng aming pahina. Sa page body, mayroon kaming dalawang pangunahing div: header at content . Ang content div ay may kasamang holder para sa aming mga button. At doon mayroon kaming dalawang mga pindutan na magdadala sa iyo sa kaukulang address sa isang pag-click. Maaari mong patakbuhin ang proyekto at tingnan kung ano ang hitsura nito ngayon. Kung mag-click ka sa mga pindutan, makakakuha ka ng 404-error na mga pahina, dahil wala pa kaming mga kaukulang pahina. Ngunit masasabi natin na gumagana ang mga pindutan. Tandaan na hindi ito ang pinaka-unibersal na diskarte: kung naka-off ang JavaScript sa browser, hindi gagana ang mga button na ito. Ngunit ipagpalagay namin na walang nagdi-disable ng JavaScript. :) Malinaw, maaari kang makakuha ng sa pamamagitan ng mga simpleng link, ngunit mas gusto ko ang mga pindutan. Magagawa mo ito gayunpaman gusto mo. At huwag mag-alala tungkol sa katotohanang iyon na ang aking mga halimbawa ay magkakaroon ng maraming div . Pupunuin natin ang mga ito ng mga istilo sa ibang pagkakataon, at magiging mas maganda ang lahat. :)

Lumikha ng mga JSP file upang i-render ang resulta

Sa parehong web directory, lumikha ng isang folder kung saan namin idaragdag ang aming mga JSP file . Tinawag ko itong ' view ', ngunit maaari kang mag-improvise muli. Sa folder na ito, gagawa kami ng dalawang JSP file:

add.jsp — isang pahina para sa pagdaragdag ng mga user;
list.jsp — pahina upang ipakita ang listahan ng mga gumagamit.

Magtalaga ng naaangkop na mga header ng pahina sa kanila. Isang bagay na tulad ng " Magdagdag ng bagong user " at " Listahan ng user ", at hahayaan namin itong ganoon.

Lumikha ng dalawang servlet

Tatanggap at ipoproseso ng mga Servlet ang mga kahilingang ipinapadala sa kanila ng Tomcat . Sa src/main/java folder, lumikha ng app package, kung saan ilalagay namin ang aming source code. Doon din pupunta ang ibang packages. Kaya, para maiwasang malikha ang mga package na ito sa loob ng isa't isa, gagawa kami ng ilang klase sa package ng app ( tatanggalin namin ito sa ibang pagkakataon). Gumawa ngayon ng tatlong magkakaibang mga pakete sa app package:

entity — ang aming mga entity (ang klase na naglalarawan sa mga bagay ng user) ay pumunta dito;
modelo — dito napupunta ang aming modelo (pag-uusapan natin ito sa ibang pagkakataon);
servlets — at dito napupunta ang aming mga servlet.

Kapag nagawa mo na ito, maaari mong mahinahon na tanggalin ang klase na iyon mula sa package ng app (kung ginawa mo ito, siyempre). Sa servlets package, lumikha ng dalawang klase:

AddServlet — pinoproseso ang mga kahilingang ipinadala sa / idagdag ;
ListServlet — pinoproseso ang mga kahilingang ipinadala sa / listahan .

Pagkonekta ng mga dependency sa Maven

Ang Tomcat 9 .* ay nagpapatupad ng mga detalye para sa Servlet 4.0 at JavaServer Pages 2.3 . Iyan ang nakasaad sa pangalawang linya ng unang talata ng opisyal na dokumentasyon ng Tomcat 9. Nangangahulugan ito na kung ikaw, tulad ko, ay gumagamit ng bersyong ito ng Tomcat , kung gayon ang code na iyong isusulat at tatakbo ay gagamit ng mga bersyong ito. Ngunit gusto naming magkaroon ng mga pagtutukoy na ito sa aming proyekto, upang ang aming code, na gumagamit ng mga ito, ay matagumpay na na-compile. At para magawa ito, kailangan nating i-load ang mga ito sa ating proyekto. Dito sumagip si Maven .

Ang pangkalahatang tuntunin ay ito: kung kailangan mong ikonekta ang isang bagay sa iyong proyekto gamit ang Maven:

pumunta sa website ng repositoryo mula sa Maven;
hanapin ang kinakailangang bersyon ng kinakailangang library;
kunin ang dependency code na kailangang idikit sa iyong pom.xml;
idikit! :)

Magsimula tayo. Una, ihanda ang POM file . Sa isang lugar pagkatapos ng entry na /version , ngunit bago /project , ipasok ang sumusunod:


<dependencies>

</dependencies>

Ginagawa namin ito upang isaad na ililista namin ang mga kinakailangang dependency sa loob ng mga tag na ito. Pumunta ngayon sa mvnrepository.com . Mayroong field ng paghahanap sa itaas. Upang magsimula, maghanap para sa ' servlet '. Ang unang resulta, na ginamit nang higit sa pitong libong beses, ay nababagay sa amin. Tandaan, kailangan namin ng bersyon 4.0 (para sa Tomcat 9). Maaaring naaangkop ang ibang mga bersyon para sa mga mas lumang pagpapatupad. Ito ay isang medyo kamakailang bersyon, kaya walang gaanong paggamit. Ngunit kailangan natin ito. Magbubukas ang isang pahina kung saan mo makukuha ang code para sa dependency na ito para sa iba't ibang mga manager ng package, o maaari mo lang itong i-download. Ngunit dahil gusto naming ikonekta ito gamit ang Maven, pipiliin namin ang code sa tab na Maven. Kinokopya at i-paste namin sa seksyong dependency ng aming POM file. Kung makatanggap ka ng notification na nagtatanong kung gusto mong i-enable ang auto-import sa kanang sulok sa ibaba ng IDEA , magpatuloy at sumang-ayon dito. Kung hindi mo sinasadyang tumanggi, pumunta sa " Mga Setting " at manu-manong i-on ang auto-import: Mga Setting (Ctrl + Alt + S) -> Build, Execution, Deployment -> Maven -> Importing .at ang mga file ng configuration ng IDEA para sa proyektong ito ay naka-sync. Kasunod ng parehong prinsipyo, hahanapin at ikokonekta namin ang JavaServer Pages 2.3 (hanapin ang "JSP"). At dahil nasimulan na natin ang Maven, sabihin na lang natin na ang ating mga source file ay sumusunod sa Java 8 syntax, at kailangan nating i-compile ang mga ito sa bytecode para sa bersyong iyon. Pagkatapos ng lahat ng hakbang na ito, magiging ganito ang hitsura ng aming pom.xml :


<?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>

Gawin ang aming mga servlet sa mga tunay na servlet

Sa ngayon, ang pares ng mga servlet na ginawa namin ay talagang mga ordinaryong klase. Wala silang anumang functionality. Ngunit ngayon naikonekta na namin ang Servlet API sa aming proyekto, at naaayon ay magagamit namin ang mga klase nito. Upang gawing "totoo" ang ating mga servlet, ang kailangan lang nating gawin ay ipamana sa kanila ang klase ng HttpServlet .

Pagmamapa o markup

Ngayon ay maganda na kahit papaano ay sabihin sa Tomcat na ang mga kahilingan para sa / add address ay pinoproseso ng aming AddServlet , at ang mga kahilingan para sa / list address ay pinangangasiwaan ng ListServlet . Ang prosesong ito ay tinatawag na pagmamapa (markup). Ginagawa ito sa web.xml gamit ang parehong prinsipyo:

upang magsimula, ilarawan ang servlet (magbigay ng ilang pangalan at tukuyin ang landas sa klase mismo);
pagkatapos ay itali ang servlet na ito sa isang tiyak na address (tukuyin ang pangalan ng servlet, na kakabigay lang namin, at tukuyin ang address kung saan ang mga kahilingan ay dapat ipadala sa servlet na ito).

Ilarawan ang servlet:


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

Ngayon itali ito sa address:


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

Tulad ng nakikita mo, ang servlet-name ay pareho sa parehong mga kaso. Bilang resulta, alam ng Tomcat na kung ang isang kahilingan para sa /add ay natanggap, dapat itong ipadala sa app.servlets.AddServlet. Ginagawa namin ang parehong bagay sa pangalawang servlet. Sa huli, ang aming web.xml ay may tinatayang sumusunod na nilalaman:


<?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>

Siyanga pala, hindi kami gumawa ng markup para sa home page (/). Ang katotohanan ay hindi natin ito kailangan sa kasong ito. Ang aming home page ay isang simpleng HTML file na nagpapakita lamang ng dalawang button. Wala itong dynamic na nilalaman, kaya hindi namin kailangang lumikha ng isang hiwalay na servlet para sa mga kahilingan mula sa / na walang gagawin kundi ipasa ang pagpapatupad sa ilang JSP (na kailangan ding gawin) upang gumuhit ng dalawang pindutan para sa amin. Hindi natin ito kailangan. Ang isang static na pahina ay nababagay sa amin. Kapag nakatanggap ng kahilingan ang Tomcat, susuriin nito kung mayroong isang solong servlet na maaaring magproseso ng kahilingan para sa address na iyon, at pagkatapos ay makikita na ang address na ito ay aktwal na naglalaman ng handa na HTML file, na ihahatid nito. Maaari naming patakbuhin muli ang aming application (i-restart ang server o i-redeploy muli ito—anuman ang gusto mo) at tiyaking nai-render ang home page, walang nasira, at nangyayari ang mga transition kapag na-click namin ang mga button (bagama't muli kaming nagkakaroon ng error). Sa pamamagitan ng paraan, samantalang bago kami nakakuha ng 404 error, ngayon ay nakakuha kami ng 405. Nangangahulugan ito na ang pagmamapa ay nagtrabaho at ang mga servlet ay natagpuan, ngunit wala silang angkop na paraan upang mahawakan ang kahilingan.

Maikling digression: ano ang nangyayari "sa ilalim ng talukbong"?

Marahil ay naisip mo na kung paano gumagana ang aming application sa Tomcat. Ano ang nangyayari sa loob? At nasaan ang pangunahing() na pamamaraan? Sa sandaling pumunta ka sa localhost:8080 sa iyong browser, magpapadala ang browser ng kahilingan sa address na ito gamit ang HTTP protocol. Sana ay alam mo na na maraming iba't ibang uri ng mga kahilingan, at ang pinakasikat ay ang GET at POST. Dapat sagutin ang bawat kahilingan. Ang isang kahilingan sa GET ay inaasahang makakatanggap ng tugon ng HTML code na handa nang gamitin, na ibinalik sa browser. Papalitan ng browser ang code sa lahat ng magagandang titik, button, at form. Ang isang POST na kahilingan ay medyo mas kawili-wili, dahil nagdadala din ito ng ilang impormasyon. Halimbawa, ipagpalagay na nagpasok ka ng mga kredensyal sa isang form sa pagpaparehistro o pag-sign-in sa isang website, at i-click ang "Ipadala." Nagiging sanhi ito ng isang POST na kahilingan kasama ang iyong personal na impormasyon na maipadala sa server. Natatanggap ng server ang impormasyong ito, pinoproseso ito, at nagbabalik ng ilang tugon (halimbawa, isang HTML na pahina kasama ang iyong profile). Ang pangunahing pagkakaiba sa pagitan ng mga ito ay ang mga kahilingan sa GET ay ginagamit lamang upang kunin ang data mula sa server, habang ang mga kahilingan sa POST ay nagdadala ng ilang impormasyon (at maaaring magbago ang data sa server). Halimbawa, kapag nag-upload ka ng iyong larawan sa server, dinadala ito doon sa isang kahilingan sa POST at idinaragdag ito ng server sa database, ibig sabihin, may naganap na pagbabago. Ngayon bumalik sa Tomcat. Kapag nakatanggap ito ng kahilingan mula sa isang kliyente, tinitingnan nito ang address. Sinusuri nito kung mayroong angkop na servlet upang iproseso ang mga kahilingan para sa address na iyon (o isang magagamit na mapagkukunan na maaaring ibalik kaagad). Kung wala itong mahanap na maibabalik, pagkatapos ay tumugon ito ng 404-error sa halip na isang HTML na pahina. Ngunit kung nakahanap ito ng angkop na servlet na "nakaupo" sa address na iyon, pagkatapos ay titingnan nito ang uri ng kahilingan (GET, POST, o iba pa) at tatanungin ang servlet kung mayroon itong paraan na makakayanan ang ganitong uri ng query. Kung sinabi ng servlet na hindi nito alam kung paano pangasiwaan ang ganitong uri, kung gayonNagbabalik ang Tomcat ng 405 code. At ito lang ang nangyari sa project namin. Ngunit kung ang isang angkop na servlet ay natagpuan, at ito ay may angkop na pamamaraan, pagkatapos ang Tomcat ay lumilikha ng isang servlet na bagay, magsisimula ito sa isang bagong thread(na hinahayaan itong tumakbo nang mag-isa), at ipinagpatuloy ng Tomcat ang sarili nitong gawain, pagtanggap at pagpapadala ng mga kahilingan. Bilang karagdagan, ang Tomcat ay lumilikha ng dalawa pang bagay: isang HttpServletRequest (na tatawagin kong "kahilingan" para sa maikli), at isang HttpServletResponse (na tatawagin kong "tugon"). Inilalagay nito ang lahat ng data na natanggap mula sa kahilingan ng kliyente sa unang bagay, upang ang lahat ng data na iyon ay maaaring makuha mula dito. At pagkatapos ng lahat ng ito, ipinapasa nito ang dalawang bagay na ito sa naaangkop na pamamaraan ng servlet na sinimulan sa isang hiwalay na thread. Sa sandaling matapos ng servlet ang trabaho nito at may handa nang maipadalang tugon sa kliyente, iwinagayway nito ang bandila sa Tomcat, na nagsasabing "Tapos na ako. Handa na ang lahat". Natanggap ng Tomcat ang tugon at ipinadala ito sa kliyente. Nagbibigay-daan ito sa Tomcat na makatanggap ng mga kahilingan at magpadala ng mga tugon, nang hindi naaabala, at ang lahat ng gawain ay ginagawa ng mga servlet na tumatakbo sa magkahiwalay na mga thread. Nangangahulugan iyon na kapag isinulat namin ang servlet code natutukoy namin kung anong gawain ang isasagawa. At maaari mong isipin na ang pangunahing() na pamamaraan ay matatagpuan sa loob mismo ng Tomcat (yep, ito ay nakasulat sa Java), at kapag "inilunsad" natin ang Tomcat, ang pangunahing() na pamamaraan ay sinimulan.

Paglikha ng isang simpleng web application gamit ang mga servlet at JSP (bahagi 1) - 2

Gumamit ng mga servlet upang mahuli ang mga pamamaraan ng GET at magpadala ng mga napakasimpleng tugon

Sa ngayon, ang aming mga servlet ay walang angkop na pamamaraan (GET), kaya't ang Tomcat ay nagbabalik ng 405 na error. Gawin natin sila! Ang klase ng HttpServlet, na minana ng aming mga servlet, ay nagdedeklara ng iba't ibang pamamaraan. Upang magtalaga ng partikular na code sa mga pamamaraan, i-override lang namin ang mga ito. Sa kasong ito, kailangan nating i-override ang doGet()pamamaraan sa parehong mga servlet.


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

}

Tulad ng nakikita mo, ang pamamaraang ito ay tumatagal ng dalawang argumento: req (kahilingan) at resp (tugon). Ito ang mismong mga bagay na nililikha at napupuno ng Tomcat para sa amin kapag tinawag nito ang naaangkop na pamamaraan sa servlet. Upang magsimula, gagawa kami ng mga pinakasimpleng tugon. Upang gawin ito, kukunin namin ang resp object at kumuha ng isang PrintWriter object mula dito. Ang ganitong uri ng bagay ay ginagamit upang bumuo ng isang tugon. Gagamitin namin ito upang mag-output ng isang simpleng string.


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.println("GET method from AddServlet");
}

Gagawin namin ang isang bagay na katulad sa ListServlet, at pagkatapos ay i-restart namin ang aming server. Tulad ng nakikita mo, gumagana ang lahat! Kapag nag-click ka sa mga pindutan, makakakuha ka ng mga pahina na may teksto na aming "isinulat" gamit ang PrintWriter. Ngunit ang mga JSP file na inihanda namin para makabuo ng mga page na may mga tugon ay hindi ginagamit. Iyon ay dahil hindi sila kailanman na-execute. Ang aming servlet ay gumagawa ng tugon mismo at tinatapos ang pagtakbo, na nagsenyas sa Tomcat na ito ay handa na tumugon sa kliyente. Kinukuha lang ng Tomcat ang tugon at ibinabalik ito sa kliyente.

Ipasa natin ang kontrol mula sa mga servlet patungo sa mga file ng JSP. Babaguhin namin ang code ng aming mga pamamaraan tulad ng sumusunod:

kumuha kami ng request dispatcher object mula sa request object, at ipapasa dito ang address ng JSP page kung saan gusto naming ilipat ang kontrol;
ginagamit namin ang bagay na ito upang ilipat ang kontrol sa tinukoy na pahina ng JSP, hindi nalilimutang ipasa ang kahilingan at tugon na mga bagay na natanggap namin mula sa Tomcat.


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
    requestDispatcher.forward(req, resp);
}

Sa body tag ng mga JSP page, maaari kang magdagdag ng isang bagay para malinaw naming makita kung aling page ang ipinapakita. Kapag nagawa mo na iyon, i-restart ang server at suriin. I-click namin ang mga pindutan sa pangunahing pahina at bukas ang mga pahina, na nangangahulugang ang mga kahilingan ay ipinapadala sa mga servlet. Pagkatapos ay ipapasa ang kontrol sa mga pahina ng JSP, na nire-render na ngayon. Yun lang muna. Sa susunod na bahagi ng artikulong ito, gagawin namin ang pagpapagana ng aming application.

Higit pang pagbabasa:
Paglikha ng isang simpleng web application gamit ang mga servlet at JSP (bahagi 2) Ang iyong unang application gamit ang Java servlets

Mga komento

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION