Bahagi 5. Mga Servlet at ang 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 networking
• tungkol sa arkitektura ng software
• tungkol sa HTTP/HTTPS
• tungkol sa mga pangunahing kaalaman ng Maven

Alam mo na ba kung paano magsulat ng mga Java application na nagpapakita 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 ipagmalaki sa iyong mga kaibigan nang hindi nagpapadala sa kanila ng JAR file at nang hindi pinipilit silang mag-download ng Java. Sumulat tayo ng isang simpleng web application . Kung hindi ka pa pamilyar sa mga diskarte na ginagamit sa web development, inirerekomenda ko na magsimula ka sa pamamagitan ng pagbabasa ng unang artikulo sa seryeng " Introduction to Enterprise Development ".

Ano ang isang servlet?

Una, alamin natin kung ano ang mga servlet at kung bakit madalas mong marinig ang tungkol sa mga ito. Ang Java Servlet API ay isang standardized na API na nilalayong ipatupad sa server. Nakikipag-ugnayan ito sa mga kliyente ayon sa scheme ng kahilingan-tugon. Ang servlet ay isang klase na maaaring makatanggap ng mga kahilingan mula sa isang kliyente at magbabalik ng mga tugon sa kliyente. Sa katunayan, ang mga servlet ay eksaktong mga bloke ng gusali na ginagamit namin upang lumikha ng arkitektura ng client-server sa Java. Maaalala mo na napag-usapan na namin ang tungkol sa arkitektura na iyon sa isa pang artikulo sa serye. Hindi tayo magpapatalo sa paligid: sumulat tayo kaagad ng ilang code.

Ano ang kailangan mo upang lumikha ng isang web application

Para sa pinakamalaking kaginhawahan kapag nagtatrabaho sa mga Java servlet, kailangan mo ng IntelliJ IDEA Ultimate Edition. Ito ay isang bayad na produkto, ngunit maaari mong i-activate ang isang 30-araw na pagsubok o gamitin ang bersyon ng maagang pag-access, na palaging libre. Gayundin, i-install ang Apache Tomcat — ang server ng aming application. Ang Tomcat ay isang servlet container: pinoproseso nito ang mga papasok na kahilingan at ipinapasa ang mga ito sa aming aplikasyon. I-download ang Tomcat dito .

Gawin natin ang ating unang web application

Kung handa na ang lahat, lumikha ng isang proyekto ng Maven. Kung hindi ka pamilyar kay Maven, tingnan ang nakaraang artikulo . Magsimula na tayo!

1. Sa pom.xml, magdagdag ng javax.servlet-api dependency at tukuyin ang WAR packaging:

   
   <?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, at ang URL at port para sa pakikipag-ugnayan sa server. Dapat mayroon kang ganito:

4. Ngayon kailangan lang nating 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 default na halaga para sa konteksto ng Application ay servlets_war_exploded . Nangangahulugan ito na ina-access namin ang application sa: http://localhost:8080/servlets_war_exploded .

   Bakit gusto namin ng anumang karagdagang teksto? Tanggalin natin ang hindi kailangan. Ngayon, ang address ng aming web application ay: http://localhost:8080 .

6. I-click ang OK. Nakita namin na maaari na naming ilunsad ang application:

   Ngayon kapag binuksan mo ang application sa iyong browser, dapat kang makakuha ng 404 error. Ito ay makatuwiran, dahil ang address na http://localhost:8080/ ay nangangailangan ng isang servlet na nagmamapa sa "/", ngunit ang aming nag-iisang servlet na mga mapa sa "/hello" .

7. Maa-access namin ito sa http://localhost:8080/hello . Kapag ginawa namin iyon, makukuha namin ang inaasahang sagot — ang string na "Hello"!

Kung gumagana ang lahat, pag-aralan natin ang code. Upang makagawa ng isang HTTP-servlet mula sa isang ordinaryong klase , dapat itong magmana ng HttpServlet na klase. Sa itaas ng deklarasyon ng klase, ipinapahiwatig namin ang @WebServlet()anotasyon. Ito ay kung saan namin bind (o mapa) ang servlet sa isang tiyak na landas ("/hello"). Ang anotasyong ito ay lumitaw lamang sa Java Servlet API 3.0, kaya ang Internet ay may maraming mga halimbawa kung saan ang servlet mapping ay nangyayari sa pamamagitan ng isang XML file. Hindi na ito kailangan. Upang pangasiwaan ang mga kahilingan sa GET , ino-override namin ang doGet()pamamaraan. Bigyang-pansin ang mga parameter ng pamamaraan: HttpServletRequestat HttpServletResponse. Ang HttpServletRequestobject ay nagbibigay sa amin ng lahat ng kinakailangang impormasyon tungkol sa kahilingan. Sa HttpServletResponse, isinusulat namin ang aming tugon at itinatakda ang mga kinakailangang header.

Paggawa gamit ang mga parameter at isang session

Pagbutihin natin ang ating servlet upang maproseso nito ang mga parameter ng kahilingan at gumana sa isang 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();
   }
}

Ngayon ang servlet ay gumagana sa isang session, pinapataas ang halaga ng visitCounterbawat oras na binibisita ang pahina. Kung ang visitCounterkatangian ay hindi pa nagagawa (sa unang pagbisita sa pahina), ang getAttribute()pamamaraan ay nagbabalik ng null, kaya kailangan nating suriin para sa null. Ang parehong napupunta para sa mga parameter ng kahilingan. Kung ang user ay hindi pumasa sa username parameter, ang halaga nito ay magiging null. Sa kasong ito, binabati namin ang user bilang isang hindi kilalang bisita. Upang maipasa ang isang parameter sa isang kahilingan sa GET, ginagamit ang isang string ng query, Halimbawa, maaari naming gamitin ang sumusunod na URL: http:// localhost:8080/hello? Username=Paul. Maaari kang magbasa nang higit pa tungkol sa mga kahilingan sa HTTP sa nakaraang artikulosa serye. Ang aming application ay kasalukuyang walang gaanong lohika, ngunit medyo nakakainis na nakakakuha kami ng 404 error sa root path. Upang ayusin ito, gagawa kami ng isa pang servlet at imapa ito sa panimulang pahina: @WebServlet("/"). Ang layunin 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 ay kapaki-pakinabang na maunawaan ang pagkakaiba sa pagitan nila. Ang isang forward ay nagde-delegate sa pagproseso ng kahilingan sa isa pang servlet sa server. Hindi kasali ang kliyente. Upang gawin ito, idagdag ang sumusunod na code sa pamamaraan ng doGet() ng bagong servlet:

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

Sa code na ito, ina-access namin ang konteksto ng servlet, kunin ang dispatcher ng kahilingan para sa nauugnay na servlet, at hilingin itong iproseso ang isang partikular na kahilingan gamit ang mga tinukoy na argumento (req, resp). Ang isang pag-redirect ay nagbabalik sa kliyente ng address na dapat gamitin ng kliyente upang iproseso ang kahilingan nito. Karamihan sa mga browser ay awtomatikong nagna-navigate sa ibinalik na URL. Upang magpatupad ng pag-redirect, kailangan mong idagdag ang code na ito:

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

Tinatawag namin ang redirect()pamamaraan sa HttpServletResponseparameter at ipinapasa ito sa address na kailangang gamitin ng kliyente. Narito ang 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 gamitin ang forward, ngunit kung minsan ang paggamit redirectay mas mahusay. Kung naiintindihan mo ang pagkakaiba sa kung paano gumagana ang mga ito, hindi ka gagawa ng maling pagpili. 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");
   }
}

Buod

Tapos na ang iyong unang web application. 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 pinangangasiwaan sa katulad na paraan — sa pamamagitan ng pag-override sa mga kaukulang pamamaraan ng parent class. Maaari kang gumamit ng mga simpleng servlet na tulad nito upang bumuo ng mga sopistikadong versatile na web application. Siyempre, ang paggamit ng malalaking framework tulad ng Spring ay ginagawang mas madali ito. Ngunit kung gusto mo talagang suriin ang lahat ng mga kakayahan ng mga servlet, maaari mong basahin ang opisyal na detalye . Bahagi 6. Mga lalagyan ng Servlet Bahagi 7. Ipinapakilala ang pattern ng MVC (Model-View-Controller)