Partea 5. Servlet-uri și API-ul Java Servlet. Scrierea unei aplicații web simple

Acest material face parte din seria „Introducere în dezvoltarea întreprinderii”. Articole anterioare:

Știi deja să scrii aplicații Java care afișează text pe consolă, dar încă nu știi cum să creezi prima ta aplicație web? Grozav, fă-te confortabil. În acest articol, ne vom familiariza cu servlet-urile și vom scrie o aplicație cu care vă puteți lăuda prietenilor dvs. fără a le trimite un fișier JAR și fără a-i forța să descarce Java. Să scriem o aplicație web simplă . Dacă nu sunteți deja familiarizați cu abordările folosite în dezvoltarea web, vă recomand să începeți prin a citi primul articol din seria „ Introducere în dezvoltarea întreprinderii ”.

Ce este un servlet?

Mai întâi, să ne dăm seama ce sunt servleturile și de ce auziți atât de des despre ele. API- ul Java Servlet este un API standardizat destinat a fi implementat pe server. Interacționează cu clienții conform unei scheme cerere-răspuns. Un servlet este o clasă care poate primi cereri de la un client și poate returna răspunsuri clientului. De fapt, servleturile sunt exact blocurile pe care le folosim pentru a crea o arhitectură client-server în Java. Poate vă amintiți că am vorbit deja despre acea arhitectură într-un alt articol din serie. Nu ne vom bate prin tufiș: hai să scriem niște cod imediat.

De ce aveți nevoie pentru a crea o aplicație web

Pentru cea mai mare comoditate atunci când lucrați cu servlet-uri Java, aveți nevoie de IntelliJ IDEA Ultimate Edition. Este un produs cu plată, dar puteți activa o perioadă de încercare de 30 de zile sau puteți utiliza versiunea cu acces anticipat, care este întotdeauna gratuită. De asemenea, instalați Apache Tomcat — serverul aplicației noastre. Tomcat este un container de servlet: procesează cererile primite și le transmite aplicației noastre. Descărcați Tomcat de aici .

Să creăm prima noastră aplicație web

Dacă totul este gata, creați un proiect Maven. Dacă nu sunteți familiarizat cu Maven, aruncați o privire la articolul anterior . Sa incepem!

În pom.xml, adăugați o dependență javax.servlet-api și specificați ambalajul 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>

Clasa simplă de 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();
   }
}

Pentru a rula aplicația, trebuie să creați o configurație Tomcat:
În continuare, indicăm ce versiune de Tomcat vom folosi și adresa URL și portul pentru comunicarea cu serverul. Ar trebui sa ai asa ceva:
Acum trebuie doar să specificăm artefactul (proiectul asamblat într-o arhivă JAR) care va fi implementat în container. Puteți să faceți clic pe butonul Fix și să selectați război explodat : aceasta înseamnă că, după reconstruirea proiectului, artefactul va fi plasat automat în containerul servlet-ului.
Valoarea implicită pentru contextul aplicației este servlets_war_exploded . Aceasta înseamnă că accesăm aplicația la: http://localhost:8080/servlets_war_exploded .

De ce am dori un text suplimentar? Să ștergem ceea ce nu este necesar. Acum, adresa aplicației noastre web este: http://localhost:8080 .
Faceți clic pe OK. Vedem că acum putem lansa aplicația:

Acum, când deschideți aplicația în browser, ar trebui să primiți o eroare 404. Acest lucru are sens, deoarece adresa http://localhost:8080/ are nevoie de un servlet care se mapează la „/”, dar singurul nostru servlet se mapează la „/hello” .
Îl putem accesa la http://localhost:8080/hello . Odată ce facem asta, obținem răspunsul așteptat - șirul „Bună ziua”!

Dacă totul funcționează, să analizăm codul. Pentru a face un HTTP-servlet dintr-o clasă obișnuită , acesta trebuie să moștenească clasa HttpServlet. Deasupra declarației de clasă, indicăm @WebServlet()adnotarea. Aici legăm (sau mapăm) servletul la o cale specifică ("/hello"). Această adnotare a apărut doar în Java Servlet API 3.0, așa că Internetul are o mulțime de exemple în care maparea servletului are loc printr-un fișier XML. Acest lucru nu mai este necesar. Pentru a gestiona cererile GET , suprascriem doGet()metoda. Acordați atenție parametrilor metodei: HttpServletRequestși HttpServletResponse. Obiectul HttpServletRequestne oferă toate informațiile necesare despre cerere. În HttpServletResponse, scriem răspunsul nostru și setăm anteturile necesare.

Lucrul cu parametrii și o sesiune

Să ne îmbunătățim servletul astfel încât să poată procesa parametrii de solicitare și să lucreze cu o sesiune:

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();
   }
}

Acum servletul funcționează cu o sesiune, crescând valoarea de visitCounterfiecare dată când pagina este vizitată. Dacă visitCounteratributul nu a fost încă creat (la prima vizită a paginii), metoda getAttribute()returnează null, așa că trebuie să verificăm nul. Același lucru este valabil și pentru parametrii de solicitare. Dacă utilizatorul nu trece parametrul nume de utilizator, atunci valoarea acestuia va fi nulă. În acest caz, salutăm utilizatorul ca un vizitator anonim. Pentru a transmite un parametru într-o solicitare GET, se folosește un șir de interogare. De exemplu, am putea folosi următorul URL: http:// localhost:8080/hello? Nume utilizator=Paul. Puteți citi mai multe despre solicitările HTTP în articolul anteriorîn serie. Aplicația noastră în prezent nu are prea multă logică, dar este puțin enervant că primim o eroare 404 la calea rădăcină. Pentru a remedia acest lucru, vom crea un alt servlet și îl vom mapa la pagina de pornire: @WebServlet("/"). Scopul acestui servlet este de a redirecționa cererile către calea „/hello”. Există două moduri de a face acest lucru: folosind „forward” sau „redirect”. Poate că merită să înțelegem diferența dintre ele. Un forward delegă procesarea cererii către un alt servlet de pe server. Clientul nu este implicat. Pentru a face acest lucru, adăugați următorul cod la metoda doGet() a noului servlet:

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

În acest cod, accesăm contextul servlet-ului, obținem dispecerul de cereri pentru servletul relevant și îi cerem să proceseze o cerere specifică cu argumentele specificate (req, resp). O redirecționare returnează clientului adresa pe care acesta trebuie să o folosească pentru a-și procesa cererea. Majoritatea browserelor navighează automat la adresa URL returnată. Pentru a implementa o redirecționare, trebuie să adăugați acest cod:

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

Apelăm redirect()metoda pe HttpServletResponseparametru și îi transmitem adresa pe care trebuie să o folosească clientul. Iată un detaliu important: parametrii HTTP trebuie adăugați și la sfârșitul căii complete de redirecționare, ceea ce nu este foarte convenabil. În situația noastră, este de preferat să folosim forward, dar uneori folosirea redirecteste mai bună. Dacă înțelegeți diferența în modul în care funcționează, nu veți face o alegere greșită. Codul pentru noul servlet arată astfel:

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");
   }
}

rezumat

Prima ta aplicație web este gata. În articolul următor, veți învăța cum să îl implementați fără a utiliza IntelliJ IDEA. Am scris o aplicație care procesează numai cererile GET. Metodele HTTP rămase sunt tratate într-un mod similar - prin suprascrierea metodelor corespunzătoare ale clasei părinte. Puteți folosi servlet-uri simple ca acesta pentru a construi aplicații web versatile și sofisticate. Desigur, utilizarea cadrelor mari, cum ar fi Spring, face acest lucru mult mai ușor. Dar dacă doriți cu adevărat să aprofundați în toate capacitățile servlet-urilor, puteți citi specificația oficială . Partea 6. Containere Servlet Partea 7. Prezentarea modelului MVC (Model-View-Controller)