La tua prima applicazione che utilizza i servlet Java

Ciao a tutti! Acquisirai familiarità con i servlet come concetto base dello sviluppo web e sarai in grado di scrivere una semplice applicazione che li utilizzi. Per evitare azioni inutili, non partiremo da zero. Continueremo a lavorare sulla nostra applicazione dal mio precedente articolo su Hibernate . Ma poiché stiamo appena iniziando a familiarizzare con i servlet, ho rimosso dall'applicazione tutto ciò che riguarda la classe Auto e ho lasciato solo la classe User e le azioni che la coinvolgono. Il progetto sarà così strutturato: Quindi, servlet! Wikipedia afferma: "Un servlet Java è un componente software Java che estende le capacità di un server. Sebbene i servlet possano rispondere a molti tipi di richieste, più comunemente implementano contenitori Web per l'hosting di applicazioni Web su server Web e quindi si qualificano come server- API web servlet laterale." Questo è esattamente vero. Qui, per la prima volta, ci imbattiamo nel concetto di "architettura applicativa client-server". È abbastanza semplice al suo interno. Il client accede al server inviando una richiesta HTTP. Il server genera i dati necessari (ad esempio, li recupera da un database) e li restituisce al client. L'esempio più semplice è quando fai clic sul pulsante "Amici" su un determinato social network, inviando così una richiesta al server. Il server aggiorna l'elenco dei tuoi amici nel database e te lo restituisce (il client). L'elenco delle richieste HTTP è piuttosto lungo, quindi se non le hai mai incontrate prima, sarebbe meglio che tu le leggessi altrove, ad esempio,qui . Il nostro obiettivo è: Creare un'applicazione CRUD utilizzando i servlet. L'applicazione deve essere in grado di creare, leggere, aggiornare ed eliminare gli utenti dal database utilizzando un servlet che elabora le richieste HTTP. La nostra applicazione dell'articolo Hibernate poteva già farlo, ma era controllata direttamente dal codice Java, più precisamente dal metodo main(). Questa volta, è il client che invierà le richieste, cioè tu :) 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. La libreria di tag JSTL. Sarà necessario per creare il lato client, ovvero le pagine JSP
3. Spring-WebMVC. Avremo bisogno di un corso primaverile, di cui parleremo un po 'più tardi.

La gestione del servlet è gestita dal servlet container. Nel nostro caso, useremo Apache Tomcat. È piuttosto popolare - probabilmente ne hai già sentito parlare :) Il ciclo di vita del servlet consiste nei seguenti passaggi:

1. Se non ci sono 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 per primo, prima che il servlet possa servire le richieste. Durante l'intero ciclo di vita, il metodo init() viene chiamato solo una volta.
2. Servire la richiesta del cliente. Ogni richiesta viene elaborata sul proprio thread separato. Il contenitore chiama il metodo service() per ogni richiesta. Questo metodo determina il tipo di richiesta in entrata e la invia al metodo appropriato per l'elaborazione. Lo sviluppatore del servlet deve fornire le implementazioni per questi metodi. Se arriva una richiesta per un gestore che non è implementato, viene chiamato il metodo della classe genitore e di solito finisce per restituire un errore al richiedente.


3. Se il contenitore deve rimuovere il servlet, chiama il metodo destroy(), che mette fuori servizio il servlet. Come il metodo init(), anche questo metodo viene chiamato una volta durante l'intero ciclo del servlet.

Il nostro servlet sembra 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 coincidono con quattro richieste HTTP: doPost(), doGet(), doPut() e doDelete(). Ci consentono di creare, leggere, aggiornare ed eliminare utenti. I metodi accettano istanze delle classi javax.servlet.http.HttpServletRequest e javax.servlet.http.HttpServletResponse come input, ovvero richieste inviate al server e risposte ricevute dal client. Internamente, i metodi chiamano i metodi pertinenti della classe UserService e una risposta per il client viene generata e reindirizzata all'URL /users. Ad esempio, nel metodo doGet(), otteniamo un elenco di tutti gli utenti. Successivamente, creiamo un oggetto RequestDispatcher, che ci consente di includere oggetti in una richiesta HTTP e reindirizzarla a una risorsa specifica (ad esempio, a una pagina JSP del client). Nel metodo doPut() (che aggiorna i dati dell'utente), elaboriamo una richiesta HTTP, estraiamo i parametri id, name ed age, troviamo l'utente con l'id specificato, gli assegniamo il nome e l'età che nella richiesta e restituiamo alla pagina /utenti. Ma affinché tutti questi metodi funzionino correttamente, dobbiamo configurare il servlet. Per fare ciò, 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 abbastanza intuitivi, ma esaminiamoli in ordine. <welcome-file-list> - Viene indicata la pagina iniziale JSP, che verrà aperta per prima all'avvio dell'applicazione. Nel nostro caso, questo è index.jsp. <servlet> - Registrazione della nostra classe UserSimpleServlet come servlet. <servlet-mapping> - un tag molto importante. Definisce gli URL che verranno elaborati dal servlet. Nel nostro caso, sono tutti URL, quindi indichiamo semplicemente "/". Ma se avessimo un'applicazione che coinvolge gli utenti e le loro auto (auto), allora potremmo creare un secondo servlet (SimpleAutoServlet). Quindi la mappatura del servlet dell'utente sarebbe "/users" (ovvero le richieste sugli utenti) e la mappatura del servlet automatico sarebbe "/autos". E infine, <filtro>. Internamente, definisce un'istanza dell'org. classe springframework.web.filter.HiddenHttpMethodFilter. Questo articolo non riguarda la primavera, quindi non lo descriverò in dettaglio. Dirò solo che è imbullonato alla nostra applicazione solo come funzionalità aggiuntiva. Il fatto è che useremo le pagine JSP per creare il lato client. I nostri dati verranno visualizzati nella pagina come una tabella con un elenco di utenti. All'interno delle pagine JSP verranno utilizzati tag HTML <form/>. Ma solo le richieste HTTP GET e POST possono essere utilizzate per inviare dati da un <form/>. In altre parole, 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 un'opzione per noi. In linea di principio, questo è abbastanza normale e facile da implementare, ma la classe HiddenHttpMethodFilter ci consente di utilizzarli. In questo modo, il lettore vedrà più chiaramente la differenza tra le operazioni nell'applicazione. Infine, passiamo al lato client. È rappresentato da cinque pagine 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>

Una pagina JSP (JavaServer Page) contiene due tipi di testo: dati di origine statici che possono essere formattati come testo (HTML, SVG, WML o XML) ed elementi JSP utilizzati per creare contenuto dinamico. Per aiutarti a capire cos'è una pagina JSP, ho copiato un passaggio da un ottimo articolo. "Fondamentalmente, la prima volta che viene richiesto un JSP, si trasforma in un servlet e funziona come un servlet. Questo è molto importante da capire. Una pagina JSP NON È come una pagina HTML : un programmatore principiante deve capire chiaramente che si tratta di un altro servlet - è solo che non devi scrivere per programmare come viene visualizzato. Può semplicemente essere disegnato. E aggiungere dati dove necessario. Ma poiché una pagina JSP ricorda l'HTML, un designer lo troverà ovviamente più facile. E ancora una volta SOTTOLINEARE FORTEMENTE ai principianti,una pagina JSP è un SERVLET. Viene generato, inclusa l'aggiunta di tutti i dati, sul server. Qui è dove vengono inseriti tutti i dati. E nel browser, l'utente ottiene la pagina HTML finita, che non ha segni di Java." Puoi essere certo che una pagina JSP è davvero un servlet, perché ogni pagina ha un metodo che deve essere eseguito. Ad esempio, index .jsp indica che quando si fa clic sul pulsante "Inizia a lavorare con il database", verrà eseguito il metodo get (method = "get") La pagina addUser.jsp, che è responsabile della creazione di nuovi utenti, esegue il metodo post (metodo = "post") quando fai clic sul pulsante Salva.Il resto della pagina JSP è costituito da un normale markup HTML statico, quindi non ci soffermeremo su questo.Questo è un argomento per un altro articolo e ce ne sono molti su questo argomento su Internet. Quindi, abbiamo creato la nostra applicazione! Ora dobbiamo testarlo in azione! Per fare ciò, abbiamo bisogno del contenitore servlet Apache Tomcat menzionato sopra. Puoi scaricare il contenitoredal 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 Tomcat Successivamente, vai alla scheda "Distribuzione". Qui, configuriamo la distribuzione della nostra applicazione sul server locale. Premi "+", seleziona "Artifact" -> YourProjectName:war (creeremo l'applicazione in un file war). E questo riassume tutto! Nella pagina "Server", puoi vedere che la nostra applicazione verrà eseguita su http://localhost:8080/. Salva la configurazione e assegnale un nome (io chiamo la mia configurazione "Tommy"). Successivamente, nella scheda Maven in IDEA (sul lato destro), utilizzeremo il plug-in war per creare il nostro progetto in un file war (Plugin -> war -> war: war). Al termine della compilazione, eseguire l'applicazione e attendere. Successo! La pagina iniziale è stata lanciata. Ora facciamo clic sul pulsante "Inizia a lavorare con il database". Il nostro 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 (supponendo che ci siano utenti nel database, ovviamente). Ed eccoli! Che ce l'hai! Hai scritto la tua prima applicazione utilizzando i servlet Java. Non era così male, vero? :) Per i compiti, puoi ripristinare la funzionalità dell'auto dall'articolo precedente. In altre parole, crea un servlet separato e pagine JSP per le auto e insegna all'applicazione come elencare le auto di un utente, aggiungere nuove auto a un utente e modificarle ed eliminarle. PS Servlet e JavaServer Pages sono tecnologie piuttosto antiche. Su Internet, puoi spesso trovare commenti come "Chi ha bisogno di questa vecchia spazzatura?" La risposta è abbastanza semplice: principalmente persone che lavoreranno su progetti reali, dove potrebbero incontrare molto codice che utilizza queste tecnologie. E anche senza capire come funziona, è comunque divertente tagliare la "vecchia spazzatura" in qualcosa di nuovo :) Per uno studio più approfondito di JSP e servlet, puoi fare riferimento al libro "Head First Servlets and JSP ". È stato scritto dagli stessi autori del famoso super libro "Head First Java", che molti prenderanno come garanzia di qualità :) Spero che questo articolo sia stato utile! Grazie per l'attenzione e buona fortuna per l'apprendimento!