Votre première application utilisant des servlets Java

Salut tout le monde! Dans cet article, vous vous familiariserez avec le concept de base du développement Web des servlets et serez capable d'écrire une application simple en les utilisant. Pour éviter des étapes inutiles, nous ne repartirons pas de zéro, et continuerons à travailler sur notre application à partir de mon précédent article sur Hibernate . Cependant, comme nous ne faisons que commencer avec les servlets, j'ai supprimé de l'application tout ce qui concernait la classe Auto et n'ai laissé que la classe User et ses actions. La structure du projet ressemblera à ceci : Alors, les servlets ! Wikipédia dit : "Une servlet est une interface Java dont l'implémentation étend les fonctionnalités du serveur. Une servlet interagit avec les clients via un principe requête-réponse." Et c’est effectivement le cas. Nous rencontrons ici pour la première fois le concept d'« architecture d'application client-serveur ». Son essence est assez simple et tient dans une seule image (prise à partir d'ici ). Le client contacte le serveur en envoyant une requête HTTP. Le serveur génère les données nécessaires (par exemple, les reçoit de la base de données) et les renvoie au client. L'exemple le plus simple : sur un certain réseau social vous cliquez sur le bouton « Amis » et envoyez ainsi une requête au serveur. Le serveur vérifie 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, mais si vous ne les avez jamais rencontrées, pour une meilleure compréhension, il est préférable de les lire, par exemple ici . Notre tâche est de : Créer une application CRUD à l'aide de servlets. L'application doit être capable de créer, modifier 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 sur Hibernate savait déjà comment faire cela, mais elle était contrôlée directement depuis le code Java, plus précisément depuis la méthode main(). Ici, les requêtes seront envoyées par le client, 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. Bibliothèque de balises JSTL. Il en faudra pour créer le côté client, à savoir les pages JSP ;
3. Printemps-WebMVC. Nous aurons besoin d'un cours de printemps, dont nous parlerons un peu plus tard.

Le fonctionnement des servlets est géré par le conteneur de servlets. Dans notre cas, nous utiliserons Apache Tomcat. C'est une chose assez populaire, et vous en avez probablement déjà entendu parler :) Le cycle de vie d'une servlet comprend les é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 puisse répondre aux requêtes. La méthode init() n'est appelée qu'une seule fois pendant tout son cycle de vie.
2. Servir une demande client. Chaque demande est traitée dans son propre thread distinct. Le conteneur appelle la méthode service() pour chaque requête. Cette méthode détermine le type de la requête entrante et la distribue à la méthode correspondant à ce type pour traiter la requête. Le développeur de servlet doit fournir des implémentations pour ces méthodes. Si une requête est reçue pour laquelle aucune méthode n'est implémentée, la méthode de la classe parent est appelée et se termine généralement par une erreur renvoyée au demandeur.
3. Si le conteneur doit supprimer un servlet, il appelle la méthode destroy(), qui supprime le servlet du service. Comme la méthode init(), cette méthode est également appelée une fois pendant tout le cycle du servlet.

Notre servlet aura l'air 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(), décrite ci-dessus, et implémente 4 méthodes qui coïncident avec quatre requêtes HTTP - doGet(), doPost(), doPut() et doDelete(). Chacun d'eux nous permettra respectivement de recevoir, créer, modifier et supprimer des utilisateurs. Les méthodes prennent comme objets d'entrée les classes javax.servlet.http.HttpServletRequest et javax.servlet.http.HttpServletResponse - c'est-à-dire la demande envoyée au serveur et la réponse que le client reçoit. A l'intérieur des méthodes, les méthodes nécessaires de la classe UserService sont exécutées, une réponse est générée pour le client, puis redirigée vers l'adresse /users. Par exemple, dans la méthode doGet(), nous obtenons une liste de tous les utilisateurs. Ensuite, nous créons un objet de la classe RequestDispatcher, qui nous permet d'inclure des objets dans une requête Http, ainsi que de le rediriger vers une ressource spécifique (par exemple, une page JSP client). Dans la méthode doPut() (mise à jour des données utilisateur), nous traitons la requête HTTP, en extrayons les paramètres d'identifiant, de nom et d'âge, trouvons l'utilisateur avec l'identifiant spécifié, lui attribuons le nom et l'âge qui l'accompagnent dans le demande, et revenez à la page /users. Cependant, pour que toutes ces méthodes fonctionnent correctement, nous devons configurer le servlet. Pour cela 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, en principe, intuitives, mais parcourons-les séquentiellement. <welcome-file-list> - la page JSP de départ est spécifiée, qui sera ouverte en premier au lancement de l'application. Dans notre cas, il s'agit de la page index.jsp. <servlet> - enregistrement de notre classe UserSimpleServlet en tant que servlet. <servlet-mapping> est une balise très importante. Il définit les URL qui seront traitées par le servlet. Dans notre cas, ce sont toutes des URL, nous indiquons donc simplement « / ». Mais, par exemple, si nous avions une application avec des utilisateurs et leurs machines, nous pourrions alors créer un deuxième servlet - SimpleAutoServlet. Ensuite, le mappage pour le servlet utilisateur serait « /users » (c'est-à-dire les requêtes liées au traitement des utilisateurs), et pour le servlet automatique, ce serait « /autos ». Et enfin, <filtre>. Il définit en interne un objet de la classe org.springframework.web.filter.HiddenHttpMethodFilter. L’article ne concerne pas Spring, je n’en parlerai donc pas en détail. Permettez-moi simplement de dire qu'il est joint à notre application uniquement à titre de fonctionnalité supplémentaire. Le fait est que nous utiliserons 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. Et seules les requêtes HTTP GET et POST peuvent être utilisées pour envoyer des données depuis <form/>. Autrement dit, pour les trois opérations - mise à jour, suppression et création d'un utilisateur - nous devrons utiliser uniquement des requêtes POST. L’utilisation des requêtes PUT et DELETE ne nous serait pas disponible. Et, en principe, c'est tout à fait normal et facile à mettre en œuvre, mais la classe HiddenHttpMethodFilter nous permet de les utiliser. Cela rendra les différences entre les opérations dans l’application plus claires pour le lecteur. Enfin, passons du 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>Здравствуйте!</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>

Une page JSP (Java Server Page) contient deux types de texte : des données sources statiques, qui peuvent être dans l'un des formats de texte (HTML, SVG, WML ou XML), et des éléments JSP, qui construisent du contenu dynamique. Pour comprendre ce qu'est JSP, je vais me permettre de copier et coller un morceau d'un très bon article d'un auteur ( d'ici ). "Essentiellement, JSP est converti en servlet lors du premier accès et fonctionne comme un servlet. Ceci est très important à comprendre. JSP N'EST PAS une page comme une page HTML - il est important pour un programmeur novice de comprendre clairement que cela est une autre servlet - vous n'avez tout simplement pas besoin de programmer sa sortie. Vous pouvez simplement la dessiner. Et remplacer les données aux bons endroits. Mais comme la page JSP ressemble au moins d'une manière ou d'une autre au HTML, ce sera évidemment plus facile pour le concepteur. Et je dis encore une fois FORTEMENT aux débutants - JSP est un SERVLET . Il est préparé avec toutes les données sur le serveur. C'est ici que toutes les données sont insérées. Et l'utilisateur reçoit une page HTML prête à l'emploi dans le navigateur, qui ne présentez aucun signe de JAVA." Vous pouvez constater par vous-même que la page JSP est bien une servlet, car chaque page contient une méthode qui doit être exécutée. Par exemple, la page de démarrage index.jsp indique que lorsque vous cliquez sur le bouton "Commencer à travailler avec la base de données", method="get" sera exécuté. Sur la page addUser.jsp, chargée de créer un nouvel utilisateur, lorsque vous cliquez sur le bouton Enregistrer, method="post" sera exécuté. Le reste du JSP est constitué de balises HTML statiques ordinaires, nous ne nous y attarderons donc pas en détail - c'est le sujet d'un article séparé, dont il existe de nombreux sur Internet. Nous avons donc créé notre application, il ne reste plus qu'à la tester en action ! Pour ce faire, nous aurons besoin du conteneur de servlet Apache Tomcat mentionné ci-dessus. Vous pouvez télécharger le chat depuis 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 Serveur d'applications, précisez le chemin d'accès au dossier où se trouve Tomcat. Ensuite, allez dans l'onglet Déploiement. Ici nous configurons le déploiement de notre application sur un serveur local. Cliquez sur "+", sélectionnez "Artefact" -> Nom de votre projet : war (nous assemblerons l'application dans un fichier war). C'est en gros ça ! Sur la page "Serveur", vous pouvez voir que la même application s'exécutera sur "http://localhost:8080/". Enregistrez cette configuration et nommez-la quelque chose (mon nom de configuration est « Tommy »). Ensuite, dans l'onglet Maven d'IDEA (sur le côté droit), nous utiliserons le plugin war pour construire notre projet dans un fichier war (Plugins -> war -> war: war). Succès! La page de démarrage est lancée. Cliquez maintenant sur le bouton « Commencer à travailler avec la base de données ». Notre page JSP index.jsp générera 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 (si, bien sûr, ils sont dans la base de données). Et les voici ! Essayons de supprimer un des utilisateurs : ça marche aussi ! Nous avons donc écrit notre première application en utilisant des servlets. Comme vous pouvez le constater, tout s'est avéré pas si difficile :) Comme devoir, vous pouvez, par exemple, restituer la fonctionnalité de travail avec les voitures de l'article précédent à l'application. Ceux. créez un servlet et des pages jsp séparés pour les voitures et apprenez à notre application à afficher une liste des voitures de l'utilisateur, à lui ajouter de nouvelles voitures, ainsi qu'à les modifier et à les supprimer. Les servlets PS et JSP sont des technologies assez anciennes, et sur Internet, vous pouvez souvent trouver des commentaires du genre « qui a besoin de ces déchets ? La réponse est assez simple : elle est principalement nécessaire à ceux qui travailleront sur des projets réels, dans lesquels il est fort possible qu'il y ait beaucoup de code écrit à l'aide d'eux. Et scier du « vieux truc » en quelque chose de nouveau, sans comprendre comment ça marche, est toujours un plaisir :) Pour une étude plus approfondie du sujet JSP et servlets, vous pouvez utiliser le livre « Head First Servlets and JSP » (en Que l'anglais). Il a été écrit par les mêmes auteurs que le célèbre super-livre "Head First Java", ce qui pour beaucoup peut être un gage de qualité :) J'espère que cet article a été utile aux lecteurs ! Si vous souhaitez voir de nouveaux articles, n'oubliez pas de soutenir l'auteur du concours en le "Likant". Ou mieux encore - "Je l'aime beaucoup" :) Merci pour votre attention et bonne chance dans vos études !