Votre première application utilisant des servlets Java

Bonjour à tous! Vous vous familiariserez avec les servlets en tant que concept de base du développement Web et vous serez capable d'écrire une application simple qui les utilise. Pour éviter des actions inutiles, nous ne partirons pas de zéro. Nous allons continuer à travailler sur notre application depuis mon précédent article sur Hibernate . Mais comme nous commençons à peine à nous familiariser avec les servlets, j'ai supprimé tout ce qui concerne la classe Auto de l'application et je n'ai laissé que la classe User et les actions qui l'impliquent. Le projet sera structuré comme ceci : Alors, servlets ! Wikipédia déclare : "Une servlet Java est un composant logiciel Java qui étend les capacités d'un serveur. Bien que les servlets puissent répondre à de nombreux types de requêtes, elles implémentent le plus souvent des conteneurs Web pour héberger des applications Web sur des serveurs Web et sont donc qualifiées de serveur- API Web de servlet secondaire." C'est exactement vrai. Ici, pour la première fois, nous rencontrons le concept d'une "architecture d'application client-serveur". C'est assez simple à la base. Le client accède au serveur en envoyant une requête HTTP. Le serveur génère les données nécessaires (par exemple, les récupère dans une base de données) et les renvoie au client. L'exemple le plus simple est lorsque vous cliquez sur le bouton "Amis" sur un certain réseau social, envoyant ainsi une demande au serveur. Le serveur met à jour la liste de vos amis dans la base de données et vous la renvoie (le client). La liste des requêtes HTTP est assez longue, donc si vous ne les avez jamais rencontrées auparavant, il serait préférable que vous les lisiez ailleurs, par exemple,ici . Notre objectif est de : Créer une application CRUD à l'aide de servlets. L'application doit pouvoir créer, lire, mettre à jour et supprimer des utilisateurs de la base de données à l'aide d'un servlet qui traite les requêtes HTTP. Notre application de l'article Hibernate pouvait déjà le faire, mais elle était contrôlée directement depuis le code Java, plus précisément depuis la méthode main(). Cette fois, c'est le client qui enverra les requêtes, c'est-à-dire vous :) La première chose que nous devons faire est d'ajouter de nouvelles dépendances à notre fichier 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>

Nous avons ajouté 3 dépendances :

1. La bibliothèque javax.servlet-api elle-même
2. La bibliothèque de balises JSTL. Il sera nécessaire de créer le côté client, à savoir les pages JSP
3. Spring-WebMVC. Nous aurons besoin d'un cours de printemps, dont nous parlerons un peu plus tard.

La gestion des servlets est assurée par le conteneur de servlets. Dans notre cas, nous utiliserons Apache Tomcat. C'est assez populaire — vous en avez probablement déjà entendu parler :) Le cycle de vie du servlet se compose des étapes suivantes :

1. S'il n'y a pas de servlet dans le conteneur :
   
   • La classe servlet est chargée par le conteneur.
   • Le conteneur crée une instance de la classe servlet.
   • Le conteneur appelle la méthode init(). Cette méthode initialise le servlet et est appelée en premier, avant que le servlet ne puisse traiter les requêtes. Sur l'ensemble du cycle de vie, la méthode init() n'est appelée qu'une seule fois.
2. Servir la demande du client. Chaque demande est traitée sur son propre thread séparé. Le conteneur appelle la méthode service() pour chaque requête. Cette méthode détermine le type de demande entrante et l'envoie à la méthode appropriée pour traitement. Le développeur de servlet doit fournir des implémentations pour ces méthodes. Si une demande arrive pour un gestionnaire qui n'est pas implémenté, la méthode de la classe parent est appelée et finit généralement par renvoyer une erreur au demandeur.


3. Si le conteneur doit supprimer le servlet, il appelle la méthode destroy(), qui met le servlet hors service. Comme la méthode init(), cette méthode est également appelée une fois pendant tout le cycle de la servlet.

Notre servlet semble assez simple :

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

Comme vous pouvez le voir, il contient la méthode init(), qui a été décrite ci-dessus, et implémente 4 méthodes qui coïncident avec quatre requêtes HTTP : doPost(), doGet(), doPut() et doDelete(). Ils nous permettent de créer, lire, mettre à jour et supprimer des utilisateurs. Les méthodes acceptent en entrée les instances des classes javax.servlet.http.HttpServletRequest et javax.servlet.http.HttpServletResponse, c'est-à-dire les requêtes envoyées au serveur et les réponses reçues par le client. En interne, les méthodes appellent les méthodes appropriées de la classe UserService, et une réponse pour le client est générée et redirigée vers l'URL /users. Par exemple, dans la méthode doGet(), nous obtenons une liste de tous les utilisateurs. Ensuite, nous créons un objet RequestDispatcher, qui nous permet d'inclure des objets dans une requête HTTP et de la rediriger vers une ressource spécifique (par exemple, vers une page JSP cliente). Dans la méthode doPut() (qui met à jour les données utilisateur), nous traitons une requête HTTP, extrayons les paramètres id, name et age, trouvons l'utilisateur avec l'identifiant spécifié, lui attribuons le nom et l'âge indiqués dans la requête, et retour à la page /utilisateurs. Mais pour que toutes ces méthodes fonctionnent correctement, nous devons configurer le servlet. Pour ce faire, nous utilisons le fichier web.xml dans le dossier 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>

Toutes les balises de ce fichier sont assez intuitives, mais passons-les en revue dans l'ordre. <welcome-file-list> - La page de démarrage JSP est indiquée, qui sera ouverte en premier au démarrage de l'application. Dans notre cas, il s'agit de index.jsp. <servlet> - Enregistrement de notre classe UserSimpleServlet en tant que servlet. <servlet-mapping> - une balise très importante. Il définit les URL qui seront traitées par la servlet. Dans notre cas, ce sont toutes des URL, nous indiquons donc simplement "/". Mais si nous avions une application impliquant des utilisateurs et leurs voitures (autos), alors nous pourrions créer un deuxième servlet (SimpleAutoServlet). Ensuite, le mappage du servlet utilisateur serait "/users" (c'est-à-dire les requêtes sur les utilisateurs), et le mappage du servlet automatique serait "/autos". Et enfin, <filtre>. En interne, il définit une instance de l'org. classe springframework.web.filter.HiddenHttpMethodFilter. Cet article ne concerne pas le printemps, je ne le décrirai donc pas en détail. Je dirai seulement qu'il est intégré à notre application uniquement en tant que fonctionnalité supplémentaire. Le fait est que nous allons utiliser des pages JSP pour créer le côté client. Nos données seront affichées sur la page sous forme de tableau avec une liste d'utilisateurs. Dans les pages JSP, les balises HTML <form/> seront utilisées. Mais seules les requêtes HTTP GET et POST peuvent être utilisées pour envoyer des données à partir d'un <form/>. En d'autres termes, pour les trois opérations - mise à jour, suppression et création d'un utilisateur - nous n'aurions à utiliser que des requêtes POST. L'utilisation des requêtes PUT et DELETE ne serait pas une option pour nous. En principe, c'est tout à fait normal et facile à mettre en œuvre, mais la classe HiddenHttpMethodFilter nous permet de les utiliser. De cette façon, le lecteur verra plus clairement la différence entre les opérations dans l'application. Enfin, passons au côté client. Il est représenté par cinq pages 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>

Une page JSP (JavaServer Page) contient deux types de texte : des données source statiques qui peuvent être formatées sous forme de texte (HTML, SVG, WML ou XML) et des éléments JSP utilisés pour construire un contenu dynamique. Pour vous aider à comprendre ce qu'est une page JSP, j'ai copié un passage d'un très bon article. « Fondamentalement, la première fois qu'une JSP est demandée, elle se transforme en servlet et fonctionne comme une servlet. Ceci est très important à comprendre. Une page JSP N'EST PAS comme une page HTML — un programmeur débutant doit clairement comprendre qu'il s'agit d'une autre servlet — c'est juste que vous n'avez pas besoin de programmer comment elle s'affiche. Elle peut simplement être dessinée. Et ajouter des données si nécessaire. Mais parce qu'une page JSP rappelle du HTML, un concepteur trouvera évidemment cela plus facile. Et encore une fois SOULIGNER FORTEMENT aux débutants,une page JSP est un SERVLET. Il est généré, y compris l'ajout de toutes les données, sur le serveur. C'est là que toutes les données sont insérées. Et dans le navigateur, l'utilisateur obtient la page HTML finie, qui n'a pas de signes de Java." Vous pouvez être sûr qu'une page JSP est vraiment un servlet, car chaque page a une méthode qui doit être exécutée. Par exemple, index .jsp indique que lorsque vous cliquez sur le bouton "Commencer à travailler avec la base de données", la méthode get sera exécutée (method = "get"). La page addUser.jsp, qui se charge de créer de nouveaux utilisateurs, exécute la méthode post (method = "post") lorsque vous cliquez sur le bouton Enregistrer. Le reste de la page JSP est constitué de balises HTML statiques régulières, nous ne nous attarderons donc pas dessus. C'est un sujet pour un autre article et il y en a beaucoup à ce sujet sujet sur Internet. Donc, nous avons créé notre application! Maintenant, nous devons le tester en action ! Pour ce faire, nous avons besoin du conteneur de servlet Apache Tomcat mentionné ci-dessus. Vous pouvez télécharger le conteneurdepuis le site officiel (j'utilise la version 8). Ensuite, nous devons créer une configuration dans IDEA pour exécuter notre application via Tomcat. Pour ce faire, ouvrez l'onglet "Modifier les configurations", créez une nouvelle configuration et sélectionnez "Tomcat Server Local". Dans l'onglet "Application Server", indiquez le chemin d'accès au dossier Tomcat Ensuite, allez dans l'onglet "Deployment". Ici, nous configurons le déploiement de notre application sur le serveur local. Appuyez sur "+", sélectionnez "Artefact" -> YourProjectName:war (nous allons construire l'application dans un fichier war). Et ça, ça résume! Sur la page "Serveur", vous pouvez voir que notre application s'exécutera sur http://localhost:8080/. Enregistrez la configuration et donnez-lui un nom (j'appelle ma config "Tommy"). Ensuite, sur l'onglet Maven dans IDEA (sur le côté droit), nous utiliserons le plugin war pour construire notre projet dans un fichier war (Plugins -> war -> war: war). Une fois la construction terminée, exécutez l'application et attendez. Succès! La page d'accueil a été lancée. Maintenant, nous cliquons sur le bouton "Commencer à travailler avec la base de données". Notre index.jsp va générer une requête GET qui sera traitée par le serveur. Le serveur générera une réponse et nous la renverra sous la forme d'une liste de tous les utilisateurs existants (en supposant qu'il y ait des utilisateurs dans la base de données, bien sûr). Et les voilà ! Ça y est, vous l'avez ! Vous avez écrit votre première application à l'aide de servlets Java. Ce n'était pas si mal, n'est-ce pas ? :) Pour les devoirs, vous pouvez restaurer la fonctionnalité de la voiture de l' article précédent. En d'autres termes, créez un servlet et des pages JSP distincts pour les voitures, et apprenez à l'application à répertorier les voitures d'un utilisateur, à ajouter de nouvelles voitures à un utilisateur, à les modifier et à les supprimer. Les servlets PS et les pages JavaServer sont des technologies plutôt anciennes. Sur Internet, vous pouvez souvent trouver des commentaires comme "Qui a besoin de ce vieux bric-à-brac ?" La réponse est assez simple : principalement des personnes qui vont travailler sur de vrais projets, où elles peuvent très probablement rencontrer beaucoup de code qui utilise ces technologies. Et même sans comprendre comment cela fonctionne, c'est toujours amusant de découper de "vieux bric-à-brac" en quelque chose de nouveau :) Pour une étude plus approfondie des JSP et des servlets, vous pouvez vous référer au livre "Head First Servlets and JSP ". Il a été écrit par les mêmes auteurs que le célèbre super livre "Head First Java", que beaucoup prendront comme un gage de qualité :) J'espère que cet article a été utile ! Merci pour votre attention et bonne chance dans l'apprentissage !