Prima ta aplicație care folosește servlet-uri Java

Bună ziua tuturor! Te vei familiariza cu servlet-urile ca un concept de bază al dezvoltării web și vei putea scrie o aplicație simplă care să le folosească. Pentru a evita acțiunile inutile, nu vom începe de la zero. Vom continua să lucrăm la aplicația noastră din articolul meu anterior despre Hibernate . Dar din moment ce abia începem să ne familiarizăm cu servleturile, am eliminat tot ce are legătură cu clasa Auto din aplicație și am lăsat doar clasa User și acțiunile care o implică. Proiectul va fi structurat astfel: Deci, servlet-uri! Wikipedia afirmă: „Un servlet Java este o componentă software Java care extinde capacitățile unui server. Deși servleturile pot răspunde la multe tipuri de solicitări, ele implementează cel mai frecvent containere web pentru găzduirea aplicațiilor web pe servere web și astfel se califică drept server- API-ul web al servletului lateral." Acest lucru este exact adevărat. Aici, pentru prima dată, întâlnim conceptul de „arhitectură de aplicație client-server”. Este destul de simplu la bază. Clientul accesează serverul prin trimiterea unei cereri HTTP. Serverul generează datele necesare (de exemplu, le preia dintr-o bază de date) și le returnează clientului. Cel mai simplu exemplu este atunci când faceți clic pe butonul „Prieteni” de pe o anumită rețea socială, trimițând astfel o solicitare către server. Serverul actualizează lista prietenilor tăi din baza de date și ți-o returnează (clientului). Lista solicitărilor HTTP este destul de mare, așa că dacă nu le-ați mai întâlnit până acum, atunci ar fi mai bine să citiți despre ele în altă parte, de exemplu,aici . Obiectivul nostru este să creăm o aplicație CRUD folosind servlet-uri. Aplicația trebuie să poată crea, citi, actualiza și șterge utilizatori din baza de date folosind un servlet care procesează cereri HTTP. Aplicația noastră din articolul Hibernate putea deja să facă acest lucru, dar era controlată direct din codul Java, mai precis, din metoda main(). De data aceasta, clientul este cel care va trimite cererile, adică tu :) Primul lucru pe care trebuie să-l facem este să adăugăm noi dependențe la fișierul nostru 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>com.itis4</groupId>
    <artifactId>UsersDaoProject</artifactId>
    <version>1.0-SNAPSHOT</version>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.6</version>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!-- PostgreSQL  -->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>9.4.1212.jre7</version>
        </dependency>

        <!-- Hibernate 5.2.6 Final -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.6.Final</version>
        </dependency>

        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.4.RELEASE</version>
        </dependency>

    </dependencies>

</project>

Am adăugat 3 dependențe:

1. Biblioteca javax.servlet-api în sine
2. Biblioteca de etichete JSTL. Va fi necesar pentru a crea partea client, și anume paginile JSP
3. Spring-WebMVC. Vom avea nevoie de o clasă de primăvară, despre care vom vorbi puțin mai târziu.

Gestionarea servlet-ului este gestionată de containerul servlet. În cazul nostru, vom folosi Apache Tomcat. Este destul de popular - probabil ați auzit deja despre el :) Ciclul de viață al servletului constă din următorii pași:

1. Dacă nu există niciun servlet în container:
   
   • Clasa servlet este încărcată de container.
   • Containerul creează o instanță a clasei servlet.
   • Containerul apelează metoda init(). Această metodă inițializează servletul și este apelată mai întâi, înainte ca servletul să poată servi cererile. Pe parcursul întregului ciclu de viață, metoda init() este apelată o singură dată.
2. Serviți cererea clientului. Fiecare cerere este procesată pe propriul thread separat. Containerul apelează metoda service() pentru fiecare cerere. Această metodă determină tipul cererii primite și o trimite către metoda corespunzătoare pentru procesare. Dezvoltatorul de servlet trebuie să furnizeze implementări pentru aceste metode. Dacă sosește o solicitare pentru un handler care nu este implementat, metoda clasei părinte este apelată și de obicei ajunge să returneze o eroare solicitantului.


3. Dacă containerul trebuie să elimine servletul, apelează metoda destroy(), care scoate servletul din funcțiune. La fel ca metoda init(), această metodă este de asemenea apelată o dată pe parcursul întregului ciclu servlet.

Servletul nostru pare destul de simplu:

package servlets;

import models.User;
import services.UserService;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

public class UserSimpleServlet extends HttpServlet {

    private UserService service = new UserService();

    public void init(ServletConfig servletConfig) {
        try {
            super.init(servletConfig);
        } catch (ServletException e) {
            e.printStackTrace();
        }
    }

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

        List<User> users = service.findAllUsers();
        req.setAttribute("users", users);
        RequestDispatcher dispatcher = req.getRequestDispatcher("/showUsers.jsp");
        dispatcher.forward(req, resp);

    }

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

        String name = req.getParameter("name");
        int age = Integer.parseInt(req.getParameter("age"));
        User user = new User(name, age);
        service.saveUser(user);
        resp.sendRedirect("/users");

    }

    @Override
    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        int id = Integer.parseInt(req.getParameter("id"));
        User user = service.findUser(id);
        user.setName(req.getParameter("name"));
        user.setAge(Integer.parseInt(req.getParameter("age")));
        service.updateUser(user);
        resp.sendRedirect("/users");
    }

    @Override
    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        int id = Integer.parseInt(req.getParameter("id"));
        service.deleteUser(service.findUser(id));
        resp.sendRedirect("/users");
    }
}

După cum puteți vedea, conține metoda init(), care a fost descrisă mai sus și implementează 4 metode care coincid cu patru solicitări HTTP: doPost(), doGet(), doPut() și doDelete(). Ne permit să creăm, să citim, să actualizăm și să ștergem utilizatori. Metodele acceptă instanțe ale claselor javax.servlet.http.HttpServletRequest și javax.servlet.http.HttpServletResponse ca intrare, adică solicitări trimise către server și răspunsuri primite de client. Intern, metodele apelează metodele relevante ale clasei UserService, iar un răspuns pentru client este generat și redirecționat către adresa URL /users. De exemplu, în metoda doGet(), obținem o listă cu toți utilizatorii. Apoi, creăm un obiect RequestDispatcher, care ne permite să includem obiecte într-o solicitare HTTP și să o redirecționăm către o anumită resursă (de exemplu, către o pagină JSP client). În metoda doPut() (care actualizează datele utilizatorului), procesăm o solicitare HTTP, extragem id, numele și parametrii de vârstă, găsim utilizatorul cu id-ul specificat, îi atribuim numele și vârsta din cerere și returnăm la pagina /users. Dar pentru ca toate aceste metode să funcționeze corect, trebuie să configuram servletul. Pentru a face acest lucru, folosim fișierul web.xml din folderul WEB-INF.

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

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <servlet>
        <servlet-name>UserSimpleServlet</servlet-name>
        <servlet-class>servlets.UserSimpleServlet</servlet-class>
    </servlet>

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

    <filter>
        <filter-name>hiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>hiddenHttpMethodFilter</filter-name>
        <servlet-name>UserSimpleServlet</servlet-name>
    </filter-mapping>

</web-app>

Toate etichetele din acest fișier sunt destul de intuitive, dar să le parcurgem în ordine. <welcome-file-list> - Este indicată pagina de pornire JSP, care va fi deschisă prima la pornirea aplicației. În cazul nostru, acesta este index.jsp. <servlet> - Înregistrarea clasei noastre UserSimpleServlet ca servlet. <servlet-mapping> - o etichetă foarte importantă. Acesta definește adresele URL care vor fi procesate de servlet. În cazul nostru, sunt toate adresele URL, așa că pur și simplu indicăm „/”. Dar dacă am avea o aplicație care implică utilizatori și mașinile lor (auto), atunci am putea crea un al doilea servlet (SimpleAutoServlet). Apoi maparea servlet-ului utilizatorului ar fi „/users” (adică solicitări despre utilizatori), iar maparea servlet-ului automat ar fi „/autos”. Și în sfârșit, <filtru>. Pe plan intern, definește o instanță a organizației. Clasa springframework.web.filter.HiddenHttpMethodFilter. Acest articol nu este despre primăvară, așa că nu îl voi descrie în detaliu. Voi spune doar că este fixat pe aplicația noastră doar ca o caracteristică suplimentară. Chestia este că vom folosi pagini JSP pentru a crea partea client. Datele noastre vor fi afișate pe pagină ca un tabel cu o listă de utilizatori. În paginile JSP, vor fi folosite etichetele HTML <form/>. Dar numai cererile HTTP GET și POST pot fi folosite pentru trimiterea datelor dintr-un <form/>. Cu alte cuvinte, pentru toate cele trei operațiuni — actualizarea, ștergerea și crearea unui utilizator — ar trebui să folosim numai cereri POST. Folosirea cererilor PUT și DELETE nu ar fi o opțiune pentru noi. În principiu, acest lucru este destul de normal și ușor de implementat, dar clasa HiddenHttpMethodFilter ne permite să le folosim. În acest fel, cititorul va vedea mai clar diferența dintre operațiunile din aplicație. În cele din urmă, să trecem la partea clientului. Este reprezentat de cinci pagini JSP. index.jsp.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello!</title>
</head>
<body>
If you want to start working with the user database,<br>
click the button below:

<form action = "users" method="get">
    <input type="submit" value="Start working with database">
</form>
</body>
</html>

addUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Add new user</title>
</head>
<body>
<form action = "/users" method="post">
    <input required type="text" name="name" placeholder="Name">
    <input required type="text" name="age" placeholder="Age">
    <input type="submit" value="Save">
</form>
</body>
</html>

deleteUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Delete user</title>
</head>
<body>

Are you sure you want to delete the user ${param.id}?

&lform action="/users/${param.id}" method="post">
    <input type="hidden" name="id" value="${param.id}">
    <input type="hidden" name="_method" value="delete">
    <input type="submit" value="Delete">
</form>

</body>
</html>

showUsers.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>User list</title>
</head>
<body>
<table border="2">
    <tr>
        <td>ID</td>
        <td>Name</td>
        <td>Age</td>
        <td>Actions</td>
    </tr>
    <c:forEach items="${users}" var = "user">
        <tr>
            <td>${user.getId()}</td>
            <td>${user.getName()}</td>
            <td>${user.getAge()}</td>
            <td>
                <form action = "updateUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="hidden" name="name" value="${user.getName()}">
                    <input type="hidden" name="age" value="${user.getAge()}">
                    <input type="submit" value="Modify" style="float:left">
                </form>
                <form action="deleteUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="submit" value="Delete" style="float:left">
                </form></td>
        </tr>
    </c:forEach>
</table>

<form action = "addUser.jsp">
    <input type="submit" value="Add new user">
</form>
</body>
</html>

updateUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Modify user data</title>
</head>
<body>

Edit user

<form action="/users/${param.id}" method="post">
    <input type="hidden" name = "id" value="${param.id}">
    <input type="text" name="name" value="${param.name}" placeholder=${param.name}>
    <input type="text" name="age" value="${param.age}" placeholder=${param.age}>
    <input type="hidden" name="_method" value="put">
    <input type="submit" value="Update">
</form>

</body>
</html>

O pagină JSP (JavaServer Page) conține două tipuri de text: date sursă statice care pot fi formatate ca text (HTML, SVG, WML sau XML) și elemente JSP utilizate pentru a construi conținut dinamic. Pentru a vă ajuta să înțelegeți ce este o pagină JSP, am copiat un pasaj dintr-un articol foarte bun. „Practic, prima dată când este solicitat un JSP, acesta se transformă într-un servlet și funcționează ca un servlet. Acest lucru este foarte important de înțeles. O pagină JSP NU ESTE ca o pagină HTML – un programator începător trebuie să înțeleagă clar că acesta este un alt servlet. — doar că nu trebuie să scrieți să programați modul în care este afișat. Poate fi pur și simplu desenat. Și adăugați date acolo unde este necesar. Dar pentru că o pagină JSP amintește de HTML, un designer va găsi evident mai ușor. Și încă o dată SUBLINIAZĂ FORT începătorilor,o pagină JSP este un SERVLET. Este generat, inclusiv prin adăugarea tuturor datelor, pe server. Aici sunt introduse toate datele. Și în browser, utilizatorul primește pagina HTML terminată, care nu are semne de Java." Puteți fi sigur că o pagină JSP este într-adevăr un servlet, deoarece fiecare pagină are o metodă care trebuie executată. De exemplu, indexați .jsp indică faptul că atunci când faceți clic pe butonul „Începeți să lucrați cu baza de date” se va executa metoda get (method = „get”). Pagina addUser.jsp, care este responsabilă pentru crearea de noi utilizatori, execută metoda post. (metodă = „postează”) când faceți clic pe butonul de salvare. Restul paginii JSP este alcătuită din marcaj HTML static obișnuit, așa că nu ne vom opri asupra ei. Acesta este un subiect pentru un alt articol și există multe despre asta subiect pe internet. Deci, noi' am creat aplicația noastră! Acum trebuie să-l testăm în acțiune! Pentru a face acest lucru, avem nevoie de containerul servlet Apache Tomcat menționat mai sus. Puteți descărca containerulde pe site-ul oficial (folosesc versiunea 8). Apoi, trebuie să creăm o configurație în IDEA pentru a rula aplicația noastră prin Tomcat. Pentru a face acest lucru, deschideți fila „Editați configurații”, creați o nouă configurație și selectați „Tomcat Server Local”. În fila „Application Server”, specificați calea către folderul Tomcat. Apoi, mergeți la fila „Deployment”. Aici, configurăm implementarea aplicației noastre pe serverul local. Apăsați „+”, selectați „Artifact” -> YourProjectName:war (vom construi aplicația într-un fișier război). Și cam asta rezumă! Pe pagina „Server”, puteți vedea că aplicația noastră va rula la http://localhost:8080/. Salvați configurația și dați-i un nume (eu îmi spun configurația "Tommy"). Apoi, în fila Maven din IDEA (în partea dreaptă), vom folosi pluginul war pentru a construi proiectul nostru într-un fișier război (Plugins -> war -> war: war). După ce construirea este completă, rulați aplicația și așteptați. Succes! Pagina de pornire a fost lansată. Acum facem clic pe butonul „Începeți să lucrați cu baza de date”. Index.jsp va genera o solicitare GET care va fi procesată de server. Serverul va genera un răspuns și ni-l va returna sub forma unei liste cu toți utilizatorii existenți (presupunând că există utilizatori în baza de date, desigur). Și iată-i! Că acolo o ai! Ai scris prima ta aplicație folosind servlet-uri Java. Nu a fost așa de rău, nu-i așa? :) Pentru teme, ai putea restabili funcționalitatea mașinii din articolul anterior. Cu alte cuvinte, creați un servlet și pagini JSP separate pentru mașini și învățați aplicația cum să listeze mașinile unui utilizator, să adăugați mașini noi unui utilizator și să le editați și să le ștergeți. PS Servlets și JavaServer Pages sunt tehnologii mai degrabă străvechi. Pe Internet, puteți găsi adesea comentarii de genul „Cine are nevoie de acest vechi nedorit?” Răspunsul este destul de simplu: în principal oameni care vor lucra la proiecte reale, unde este posibil să întâlnească foarte mult cod care utilizează aceste tehnologii. Și chiar și fără a înțelege cum funcționează, este totuși distractiv să tăiați „junk vechi” în ceva nou :) Pentru un studiu mai amănunțit al JSP și al servlet-urilor, puteți consulta cartea „Head First Servlets and JSP ”. A fost scrisă de aceiași autori ca și celebra super carte „Head First Java”, pe care mulți o vor lua drept garanție a calității :) Sper că acest articol a fost de ajutor! Vă mulțumim pentru atenție și mult succes la învățare!