Bahagi 5. Mga Servlet, Java servlet API. Pagsusulat ng isang simpleng web application

Ang materyal na ito ay bahagi ng seryeng "Introduction to Enterprise Development". Mga nakaraang artikulo:

• tungkol sa network ;
• tungkol sa arkitektura ng software ;
• tungkol sa mga protocol ng HTTP/HTTPS ;
• tungkol sa mga pangunahing kaalaman sa Maven .

Alam mo na ba kung paano magsulat ng mga Java application na naglalabas ng text sa console, ngunit hindi mo pa rin talaga alam kung paano gumawa ng iyong unang web application? Mahusay, gawing komportable ang iyong sarili. Sa artikulong ito, makikilala natin ang mga servlet at magsulat ng isang application na maaari mong ipakita sa iyong mga kaibigan nang hindi nagpapadala sa kanila ng jarnik o pinipilit silang mag-download ng Java. Sumulat tayo ng isang web application . Kung hindi ka pa pamilyar sa mga diskarte na ginagamit sa web programming, ipinapayo ko sa iyo na simulan ang pagbabasa mula sa unang artikulo sa seryeng " Panimula sa Enterprise Development ".

Ano ang isang servlet

Una, alamin natin kung ano ang isang servlet at kung bakit madalas mong marinig ang tungkol dito. Ang Java Servlet API ay isang standardized na API na idinisenyo para sa pagpapatupad sa server at pakikipagtulungan sa client gamit ang isang request-response scheme. Ang servlet ay isang klase na maaaring makatanggap ng mga kahilingan mula sa isang kliyente at magbabalik ng mga tugon dito. Oo, ang mga servlet sa Java ay tiyak na mga elemento kung saan binuo ang arkitektura ng client-server. Kung naaalala mo, napag-usapan na natin ito sa isa sa mga artikulo sa serye. Huwag tayong magpatalo: sumulat tayo kaagad ng ilang code.

Ano ang kailangan mo upang lumikha ng isang web application

Upang gumana nang kumportable sa mga servlet sa Java, kakailanganin mo ng Intellij IDEA Ultimate Edition. Ito ay binabayaran, ngunit maaari mong i-activate ang isang 30-araw na panahon ng pagsubok o gamitin ang bersyon ng maagang pag-access - ito ay palaging libre. I-install din ang aming server ng application - Apache Tomcat. Ang Tomcat ay isang lalagyan ng servlet: ito ang nagpoproseso ng mga papasok na kahilingan mula sa labas at ipinapasa ang mga ito sa aming aplikasyon. Maaari mong i-download ang Tomcat mula sa link na ito .

Paglikha ng unang web application

Kung handa na ang lahat, gumawa tayo ng proyekto ng Maven. Kung hindi ka pamilyar sa Maven, bigyang-pansin ang nakaraang artikulo . Magsimula tayo!

1. Sa pom.xml, idagdag ang javax.servlet-api dependency at itakda ang packaging war:

   <?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>org.example</groupId>
      <artifactId>servlets</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
   
      <dependencies>
          <dependency>
              <groupId>javax.servlet</groupId>
              <artifactId>javax.servlet-api</artifactId>
              <version>4.0.1</version>
          </dependency>
      </dependencies>
   </project>

   Simpleng klase ng servlet:

   import javax.servlet.ServletException;
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.IOException;
   import java.io.PrintWriter;
   
   @WebServlet("/hello")
   public class MainServlet extends HttpServlet {
   
      @Override
      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          resp.setContentType("text/html");
          PrintWriter printWriter = resp.getWriter();
          printWriter.write("Hello!");
          printWriter.close();
      }
   }

2. Upang patakbuhin ang application kailangan mong lumikha ng configuration ng Tomcat:

3. Susunod, ipinapahiwatig namin kung aling bersyon ng Tomcat ang gagamitin namin, ang URL kung saan maa-access namin ang server, at ang port. Dapat kang makakuha ng isang bagay tulad nito:

4. Ang natitira na lang ay tukuyin ang artifact (ang naka-assemble na proyekto sa isang archive ng jar), na ide-deploy sa lalagyan. Maaari mong i-click ang Fix button at piliin ang war exploded : nangangahulugan ito na pagkatapos maitayo muli ang proyekto, ang artifact ay awtomatikong ilalagay sa servlet container.

5. Ang konteksto ng Application ay nakatakda sa servlets_war_exploded bilang default , na nangangahulugan na ang application ay dapat ma-access sa: http://localhost:8080/servlets_war_exploded .

   Bakit kailangan natin ng dagdag na text? Alisin natin ang mga hindi kailangan. Ngayon ang aming address ng aplikasyon ay: http://localhost:8080 .

6. I-click ang OK. Nakita namin na mayroon na kaming pagkakataong ilunsad ang application:

   Ngayon, kapag inilunsad mo ang application, dapat magbukas ang browser at magpakita ng 404 error. Ito ay lohikal, dahil sa address na http://localhost:8080/ dapat mayroong isang servlet na may "/" na pagmamapa, at ang aming tanging servlet ay may "/hello" na pagmamapa .

7. Nakipag-ugnayan kami dito sa http://localhost:8080/hello at makuha ang inaasahang tugon - ang string na “Hello”!

Kung gumagana ang lahat, tingnan natin ang code. Upang makagawa ng isang http servlet mula sa isang regular na klase , kailangan mong mamana ito mula sa HttpServlet na klase. Sa itaas ng klase, tinukoy namin ang @WebServlet() annotation, kung saan ibine-bind (mapa) namin ang servlet sa isang partikular na path (“/hello”). Ang anotasyong ito ay lumitaw lamang sa Java Servlet API 3.0, kaya maraming mga halimbawa sa Internet kung saan ang servlet mapping ay nangyayari sa pamamagitan ng isang XML file. Ngayon hindi na ito kailangan. Upang iproseso ang mga kahilingan sa GET , ine-override namin ang paraan ng doGet(). Bigyang-pansin ang mga argumento ng pamamaraan - HttpServletRequest at HttpServletResponse. Mula sa object na HttpServletRequest maaari naming kunin ang lahat ng kinakailangang impormasyon tungkol sa kahilingan, sa HttpServletResponse maaari naming i-record ang aming tugon at itakda ang mga kinakailangang header.

Paggawa gamit ang mga parameter at session

Pagbutihin natin ang ating servlet upang maproseso nito ang mga parameter ng kahilingan at gumana sa session:

import javax.servlet.ServletException;
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 ServletException, 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" + "<br>");
       } else {
           printWriter.write("Hello, " + username + "<br>");
       }
       printWriter.write("Page was visited " + visitCounter + " times.");
       printWriter.close();
   }
}

Kasalukuyang pinapatakbo ng servlet ang session, dinadagdagan ang visitCounter sa tuwing binibisita ang page. Kung hindi pa nagagawa ang attribute na visitCounter (sa unang pagkakataong bumisita ka sa page), ang getAttribute() na paraan ay magbabalik ng null, kaya kailangan mong suriin kung null. Ang parehong naaangkop sa mga parameter ng kahilingan. Kung hindi naipasa ng user ang parameter ng username, magiging null ang halaga nito. Sa kasong ito, babatiin namin ang user bilang anonymous. Upang maipasa ang isang parameter sa isang kahilingan sa GET, ginagamit ang mga path-variable, ibig sabihin, kailangan mong i-access ang link na http://localhost:8080/hello?username=Pavel . Maaari kang magbasa nang higit pa tungkol sa mga kahilingan sa http sa nakaraang artikulo sa serye. Ngayon ang aming application ay may kaunting lohika, ngunit ang 404 error sa root path ay medyo nakakainis. Para ayusin ito, gumawa tayo ng isa pang servlet at imapa ito sa unang pahina @WebServlet("/"). Ang trabaho ng servlet na ito ay i-redirect ang mga kahilingan sa "/hello" na landas. Mayroong dalawang paraan para gawin ito: gamit ang forward o redirect. Marahil ito ay nagkakahalaga ng pag-unawa kung ano ang pagkakaiba sa pagitan nila. forward - ang mga delegado ay humiling ng pagproseso sa isa pang servlet sa server, ang kliyente ay hindi kasangkot. Upang gawin ito, kailangan mong idagdag ang sumusunod na code sa doGet() na paraan ng bagong servlet:

getServletContext().getRequestDispatcher("/hello").forward(req, resp);

Sa code na ito, ina-access namin ang konteksto ng servlet, kunin ang request manager ng nais na servlet mula dito at hilingin itong iproseso ang isang partikular na kahilingan gamit ang mga tinukoy na parameter (req, resp). redirect - ibinabalik sa kliyente ang address kung saan kailangan niyang makipag-ugnayan para maproseso ang kanyang kahilingan. Karamihan sa mga browser ay awtomatikong pumupunta sa ipinadalang link. Upang ipatupad ang pag-redirect kailangan mong idagdag ang code na ito:

resp.sendRedirect(req.getContextPath() + "/hello");

Sa HttpServletResponse tinatawag namin ang redirect() method at ipinapasa ito sa address na kailangang kontakin ng kliyente. Isang mahalagang detalye: Dapat ding idagdag ang mga parameter ng http sa dulo ng buong redirect path, na hindi masyadong maginhawa. Sa aming sitwasyon, mas mainam na gumamit ng pasulong, ngunit nangyayari na mas mahusay na gumamit ng pag-redirect. Kung naiintindihan mo ang pagkakaiba sa kanilang trabaho, hindi ka magkakamali sa iyong pinili. Ang code para sa bagong servlet ay ganito ang hitsura:

import javax.servlet.ServletException;
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 ServletException, IOException {
//        getServletContext().getRequestDispatcher("/hello").forward(req, resp);
       resp.sendRedirect(req.getContextPath() + "/hello");
   }
}

Bottom line

Ang iyong unang web application ay handa na. Sa susunod na artikulo matututunan mo kung paano i-deploy ito nang hindi gumagamit ng Intellij IDEA. Sumulat kami ng isang application na nagpoproseso lamang ng mga kahilingan sa GET. Ang natitirang mga pamamaraan ng http ay pinoproseso sa parehong paraan - override ang kaukulang pamamaraan ng parent class. Gamit ang gayong mga simpleng servlet, maaari kang bumuo ng mga kumplikado, mayayamang web application. Siyempre, gamit ang malalaking framework tulad ng Spring, mas madaling gawin ito. Ngunit kung gusto mo talagang suriin ang lahat ng mga kakayahan ng mga servlet nang mas detalyado, maaari mong basahin ang opisyal na detalye . Bahagi 6. Mga lalagyan ng Servlet Bahagi 7. Panimula sa pattern ng MVC (Model-View-Controller) Bahagi 8. Pagsusulat ng maliit na application sa spring-boot