La tua prima applicazione che utilizza servlet Java

Ciao a tutti! In questo articolo acquisirai familiarità con il concetto di base dello sviluppo web dei servlet e sarai in grado di scrivere una semplice applicazione utilizzandoli. Per evitare passaggi inutili, non inizieremo da zero e continueremo a lavorare sulla nostra applicazione dal mio precedente articolo su Hibernate . Tuttavia, poiché abbiamo appena iniziato con le servlet, ho rimosso dall'applicazione tutto ciò che riguarda la classe Auto e ho lasciato solo la classe User e le sue azioni. La struttura del progetto sarà simile a questa: Allora, servlet! Wikipedia dice: "Una servlet è un'interfaccia Java la cui implementazione estende la funzionalità del server. Una servlet interagisce con i client attraverso un principio di richiesta-risposta." E infatti lo è. Qui incontriamo per la prima volta il concetto di “architettura applicativa client-server”. La sua essenza è abbastanza semplice e si inserisce in un'unica immagine (presa da qui ). Il client contatta il server inviando una richiesta HTTP. Il server genera i dati necessari (ad esempio, li riceve dal database) e li restituisce al client. L'esempio più semplice: su un determinato social network si clicca sul pulsante “Amici” e si invia così una richiesta al server. Il server controlla l'elenco dei tuoi amici nel database e te lo restituisce (al client). L'elenco delle richieste HTTP è piuttosto ampio, ma se non le hai mai incontrate, per una migliore comprensione è meglio leggerle, ad esempio, qui . Il nostro compito è: Creare un'applicazione CRUD utilizzando le servlet. L'applicazione deve essere in grado di creare, modificare ed eliminare utenti dal database utilizzando un servlet che elabora le richieste HTTP. La nostra applicazione dell'articolo su Hibernate sapeva già come farlo, ma era controllata direttamente dal codice Java, più precisamente, dal metodo main(). Qui le richieste verranno inviate dal client, cioè da te :) La prima cosa che dobbiamo fare è aggiungere nuove dipendenze al nostro file 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>

Abbiamo aggiunto 3 dipendenze:

1. La stessa libreria javax.servlet-api;
2. Libreria di tag JSTL. Sarà necessario creare la parte client, ovvero le pagine JSP;
3. Primavera-WebMVC. Avremo bisogno di una lezione primaverile, di cui parleremo poco dopo.

Il funzionamento delle servlet è gestito dal contenitore servlet. Nel nostro caso utilizzeremo Apache Tomcat. Una cosa piuttosto popolare e probabilmente ne hai già sentito parlare :) Il ciclo di vita di una servlet consiste nei seguenti passaggi:

1. Se non è presente alcuna servlet nel contenitore.
   
   • La classe servlet viene caricata dal contenitore.
   • Il contenitore crea un'istanza della classe servlet.
   • Il contenitore chiama il metodo init(). Questo metodo inizializza il servlet e viene chiamato prima che il servlet possa soddisfare le richieste. Il metodo init() viene chiamato solo una volta durante l'intero ciclo di vita.
2. Servire una richiesta del cliente. Ogni richiesta viene elaborata nel proprio thread separato. Il contenitore chiama il metodo service() per ogni richiesta. Questo metodo determina il tipo della richiesta in entrata e lo distribuisce al metodo corrispondente a questo tipo per l'elaborazione della richiesta. Lo sviluppatore del servlet deve fornire implementazioni per questi metodi. Se viene ricevuta una richiesta per la quale non è implementato un metodo, viene chiamato il metodo della classe genitore e solitamente termina con la restituzione di un errore al richiedente.
3. Nel caso in cui il contenitore debba eliminare una servlet, chiama il metodo destroy(), che rimuove la servlet dal servizio. Come il metodo init(), anche questo metodo viene chiamato una volta durante l'intero ciclo della servlet.

Il nostro servlet apparirà abbastanza semplice:

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

Come puoi vedere, contiene il metodo init(), descritto sopra, e implementa 4 metodi che corrispondono a quattro richieste HTTP: doGet(), doPost(), doPut() e doDelete(). Ciascuno di essi ci consentirà, rispettivamente, di ricevere, creare, modificare ed eliminare utenti. I metodi accettano come oggetti di input le classi javax.servlet.http.HttpServletRequest e javax.servlet.http.HttpServletResponse, ovvero la richiesta inviata al server e la risposta che il client riceve. All'interno dei metodi vengono eseguiti i metodi necessari della classe UserService, viene generata una risposta per il client e quindi reindirizzata all'indirizzo /users. Ad esempio, nel metodo doGet() otteniamo un elenco di tutti gli utenti. Successivamente, creiamo un oggetto della classe RequestDispatcher, che ci consente di includere oggetti in una richiesta Http, nonché di reindirizzarla a una risorsa specifica (ad esempio, una pagina JSP client). Nel metodo doPut() (aggiornamento dei dati utente), elaboriamo la richiesta HTTP, estraiamo da essa i parametri id, nome ed età, troviamo l'utente con l'id specificato, gli assegniamo il nome e l'età che è arrivato con lui nel file richiesta e tornare alla pagina /users. Tuttavia, affinché tutti questi metodi funzionino correttamente, è necessario configurare la servlet. Per questo utilizziamo il file web.xml nella cartella 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>

Tutti i tag in questo file sono, in linea di principio, intuitivi, ma esaminiamoli in sequenza. <welcome-file-list> - viene specificata la pagina JSP iniziale, che verrà aperta per prima all'avvio dell'applicazione. Nel nostro caso, questa è la pagina index.jsp. <servlet> - registra la nostra classe UserSimpleServlet come servlet. <servlet-mapping> è un tag molto importante. Definisce gli URL che verranno elaborati dal servlet. Nel nostro caso si tratta di tutti URL, quindi indichiamo semplicemente “/”. Ma, ad esempio, se avessimo un'applicazione con gli utenti e le loro macchine, potremmo creare un secondo servlet: SimpleAutoServlet. Quindi la mappatura per la servlet utente sarebbe “/users” (ovvero, richieste relative all'elaborazione degli utenti), e per la servlet automatica sarebbe “/autos”. E infine, <filtro>. Definisce internamente un oggetto della classe org.springframework.web.filter.HiddenHttpMethodFilter. L'articolo non riguarda la Primavera, quindi non ne parlerò nel dettaglio. Lasciatemi solo dire che è allegato alla nostra applicazione solo come funzionalità aggiuntiva. Il punto è che utilizzeremo le pagine JSP per creare il lato client. I nostri dati verranno visualizzati sulla pagina come una tabella con l'elenco degli utenti. All'interno delle pagine JSP verranno utilizzati i tag HTML <form/>. E solo le richieste HTTP GET e POST possono essere utilizzate per inviare dati da <form/>. Cioè, per tutte e tre le operazioni - aggiornamento, eliminazione e creazione di un utente - dovremmo utilizzare solo richieste POST. L'utilizzo delle richieste PUT e DELETE non sarebbe disponibile per noi. E, in linea di principio, questo è abbastanza normale e facile da implementare, ma la classe HiddenHttpMethodFilter ci consente di usarli. Ciò renderà più chiare al lettore le differenze tra le operazioni nell'applicazione. Passiamo infine al lato client. È rappresentato da cinque pagine JSP. indice.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Здравствуйте!</title>
</head>
<body>
Если вы хотите начать работу с базой данных пользователей - <br>
нажмите кнопку ниже:

<form action = "users" method="get">
    <input type="submit" value="Начать работу с базой данных">
</form>
</body>
</html>

addUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Добавить нового пользователя</title>
</head>
<body>
<form action = "/users" method="post">
    <input required type="text" name="name" placeholder="Name">
    <input required type="text" name="age" placeholder="Возраст">
    <input type="submit" value="Сохранить">
</form>
</body>
</html>

deleteUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Удалить пользователя</title>
</head>
<body>

Вы действительно хотите удалить пользователя ${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="Удалить">
</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>Список пользователей</title>
</head>
<body>
<table border="2">
    <tr>
        <td>ID</td>
        <td>Name</td>
        <td>Возраст</td>
        <td>Действия</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="Изменить" style="float:left">
                </form>
                <form action="deleteUser.jsp" method="post">
                    <input type="hidden" name="id" value="${user.getId()}">
                    <input type="submit" value="Удалить" style="float:left">
                </form></td>
        </tr>
    </c:forEach>
</table>

<form action = "addUser.jsp">
    <input type="submit" value="Добавить нового пользователя">
</form>
</body>
</html>

updateUser.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Изменить данные пользователя</title>
</head>
<body>

Редактировать пользователя

<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="Обновить">
</form>

</body>
</html>

Una pagina JSP (pagina server Java) contiene due tipi di testo: dati di origine statici, che possono essere in uno dei formati di testo (HTML, SVG, WML o XML) ed elementi JSP, che costruiscono contenuto dinamico. Per capire cos'è JSP, mi permetterò di copiare e incollare un pezzo di un ottimo articolo di un autore ( da qui ). "Essenzialmente, JSP viene convertito in un servlet la prima volta che si accede e funziona come un servlet. Questo è molto importante da capire. JSP NON È una pagina come una pagina HTML : è importante che un programmatore alle prime armi comprenda chiaramente che questo è un altro servlet: semplicemente non è necessario programmare il suo output. Puoi semplicemente disegnarlo. E sostituire i dati nei posti giusti. Ma poiché la pagina JSP almeno in qualche modo assomiglia all'HTML, sarà ovviamente più facile per il progettista. E ancora una volta dico FORTEMENTE ai principianti: JSP è un SERVLET . È preparato con tutti i dati sul server. È qui che vengono inseriti tutti i dati. E l'utente riceve una pagina HTML già pronta nel browser, che non lo fa avere qualche segno di JAVA." Puoi vedere tu stesso che la pagina JSP è effettivamente una servlet, perché ogni pagina contiene un metodo che deve essere eseguito. Ad esempio, la pagina iniziale index.jsp afferma che quando si fa clic sul pulsante "Inizia a lavorare con il database", verrà eseguito metodo="get". Nella pagina addUser.jsp, responsabile della creazione di un nuovo utente, quando si fa clic sul pulsante Salva, verrà eseguito Method="post". Il resto del JSP è costituito dal normale markup HTML statico, quindi non ci soffermeremo su di essi in dettaglio: questo è l'argomento di un articolo separato, di cui ce ne sono molti su Internet. Quindi abbiamo creato la nostra applicazione, non resta che testarla in azione! Per fare ciò, avremo bisogno del contenitore servlet Apache Tomcat menzionato sopra. Puoi scaricare il gatto dal sito ufficiale (io uso la versione 8). Successivamente, dobbiamo creare una configurazione in IDEA per eseguire la nostra applicazione tramite Tomcat. Per fare ciò, apri la scheda "Modifica configurazioni", crea una nuova configurazione e seleziona Tomcat Server Local. Nella scheda Application Server, specifica il percorso della cartella in cui si trova Tomcat, quindi vai alla scheda Deployment. Qui configuriamo la distribuzione della nostra applicazione su un server locale. Fai clic su "+", seleziona "Artifact" -> Nome del tuo progetto: war (assembleremo l'applicazione in un file war). Fondamentalmente è tutto! Nella pagina "Server" puoi vedere che la stessa applicazione verrà eseguita su "http://localhost:8080/". Salva questa configurazione e assegnale un nome (il mio nome di configurazione è "Tommy"). Successivamente, nella scheda Maven in IDEA (sul lato destro) utilizzeremo il plugin war per costruire il nostro progetto in un file war (Plugins -> war -> war: war). Successo! La pagina iniziale è stata lanciata. Ora fai clic sul pulsante "Inizia a lavorare con il database". La nostra pagina JSP index.jsp genererà una richiesta GET che verrà elaborata dal server. Il server genererà una risposta e ce la restituirà sotto forma di un elenco di tutti gli utenti esistenti (se, ovviamente, sono nel database). Ed eccoli qui! Proviamo a eliminare uno degli utenti: funziona anche! Quindi abbiamo scritto la nostra prima applicazione utilizzando servlet. Come puoi vedere, tutto si è rivelato non così difficile :) Come compito a casa, puoi, ad esempio, restituire all'applicazione la funzionalità di lavorare con le auto dall'articolo precedente. Quelli. crea un servlet separato e pagine jsp per le auto e insegna alla nostra applicazione a visualizzare un elenco delle auto dell'utente, ad aggiungergli nuove auto, nonché a modificarle ed eliminarle. Servlet PS e JSP sono tecnologie piuttosto antiche e su Internet è spesso possibile trovare commenti nello spirito "chi ha bisogno di questa spazzatura?" La risposta è abbastanza semplice: è necessaria principalmente per coloro che lavoreranno su progetti reali, in cui è del tutto possibile che verrà scritto molto codice utilizzandoli. E segare "roba vecchia" in qualcosa di nuovo, senza capire come funziona, è comunque un piacere :) Per uno studio più approfondito dell'argomento JSP e servlet, è possibile utilizzare il libro "Head First Servlets and JSP" (in Solo inglese). È stato scritto dagli stessi autori del famoso superlibro "Head First Java", che per molti può essere una garanzia di qualità :) Spero che questo articolo sia stato utile ai lettori! Se desideri vedere nuovi articoli, non dimenticare di sostenere l'autore nel concorso mettendo "Mi piace". O meglio ancora: "Mi piace moltissimo" :) Grazie per l'attenzione e buona fortuna per i tuoi studi!