Su primera aplicación usando servlets Java

¡Hola a todos! En este artículo, se familiarizará con el concepto básico de desarrollo web de los servlets y podrá escribir una aplicación sencilla usándolos. Para evitar pasos innecesarios, no comenzaremos desde cero y continuaremos trabajando en nuestra aplicación de mi artículo anterior sobre Hibernate . Sin embargo, como recién estamos comenzando con los servlets, eliminé todo lo relacionado con la clase Auto de la aplicación y dejé solo la clase Usuario y sus acciones. La estructura del proyecto se verá así: ¡ Entonces, servlets! Wikipedia dice: "Un servlet es una interfaz Java cuya implementación amplía la funcionalidad del servidor. Un servlet interactúa con los clientes a través de un principio de solicitud-respuesta". Y efectivamente lo es. Aquí encontramos por primera vez el concepto de "arquitectura de aplicaciones cliente-servidor". Su esencia es bastante simple y encaja en una imagen (tomada de aquí ). El cliente contacta al servidor enviando una solicitud HTTP. El servidor genera los datos necesarios (por ejemplo, los recibe de la base de datos) y los devuelve al cliente. El ejemplo más simple: en una determinada red social haces clic en el botón “Amigos” y así envías una solicitud al servidor. El servidor verifica la lista de tus amigos en la base de datos y te la devuelve (el cliente). La lista de solicitudes HTTP es bastante grande, pero si nunca las ha encontrado, para comprenderlas mejor es mejor leer sobre ellas, por ejemplo, aquí . Nuestra tarea es: Crear una aplicación CRUD usando servlets. La aplicación debe poder crear, modificar y eliminar usuarios de la base de datos mediante un servlet que procese solicitudes HTTP. Nuestra aplicación del artículo sobre Hibernate ya sabía cómo hacer esto, pero se controlaba directamente desde el código Java, más precisamente, desde el método main(). Aquí las solicitudes serán enviadas por el cliente, es decir, usted :) Lo primero que debemos hacer es agregar nuevas dependencias a nuestro archivo 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>

Hemos agregado 3 dependencias:

1. La propia biblioteca javax.servlet-api;
2. Biblioteca de etiquetas JSTL. Será necesario para crear el lado del cliente, es decir, páginas JSP;
3. Primavera-WebMVC. Necesitaremos una clase de primavera, de la que hablaremos un poco más adelante.

El funcionamiento de los servlets lo gestiona el contenedor de servlets. En nuestro caso usaremos Apache Tomcat. Algo bastante popular y probablemente ya hayas oído hablar de él :) El ciclo de vida de un servlet consta de los siguientes pasos:

1. Si no hay ningún servlet en el contenedor.
   
   • La clase de servlet la carga el contenedor.
   • El contenedor crea una instancia de la clase de servlet.
   • El contenedor llama al método init(). Este método inicializa el servlet y se llama primero antes de que el servlet pueda atender las solicitudes. El método init() se llama sólo una vez durante todo su ciclo de vida.
2. Atender una solicitud de un cliente. Cada solicitud se procesa en su propio hilo independiente. El contenedor llama al método service() para cada solicitud. Este método determina el tipo de solicitud entrante y lo distribuye al método correspondiente a este tipo para procesar la solicitud. El desarrollador de servlets debe proporcionar implementaciones para estos métodos. Si se recibe una solicitud para la cual no se implementa un método, se llama al método de la clase principal y generalmente finaliza con un error que se devuelve al solicitante.
3. En caso de que el contenedor necesite eliminar un servlet, llama al método destroy(), que elimina el servlet del servicio. Al igual que el método init(), este método también se llama una vez durante todo el ciclo del servlet.

Nuestro servlet se verá bastante 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");
    }
}

Como puede ver, contiene el método init(), que se describió anteriormente, e implementa 4 métodos que coinciden con cuatro solicitudes HTTP: doGet(), doPost(), doPut() y doDelete(). Cada uno de ellos nos permitirá, respectivamente, recibir, crear, editar y eliminar usuarios. Los métodos toman como entrada objetos de las clases javax.servlet.http.HttpServletRequest y javax.servlet.http.HttpServletResponse, es decir, la solicitud enviada al servidor y la respuesta que recibe el cliente. Dentro de los métodos, se ejecutan los métodos necesarios de la clase UserService, se genera una respuesta para el cliente y luego se redirige a la dirección /users. Por ejemplo, en el método doGet() obtenemos una lista de todos los usuarios. A continuación, creamos un objeto de la clase RequestDispatcher, que nos permite incluir objetos en una solicitud Http, así como redirigirlo a un recurso específico (por ejemplo, una página JSP del cliente). En el método doPut() (actualización de datos del usuario), procesamos la solicitud HTTP, extraemos de ella los parámetros de identificación, nombre y edad, buscamos al usuario con la identificación especificada, le asignamos el nombre y la edad que vino con él en el solicitar y volver a la página /usuarios. Sin embargo, para que todos estos métodos funcionen correctamente, necesitamos configurar el servlet. Para ello utilizamos el archivo web.xml en la carpeta 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>

Todas las etiquetas de este archivo son, en principio, intuitivas, pero repasémoslas secuencialmente. <lista-de-archivos-de-bienvenida>: se especifica la página JSP inicial, que se abrirá primero cuando se inicie la aplicación. En nuestro caso, esta es la página index.jsp. <servlet>: registrar nuestra clase UserSimpleServlet como servlet. <servlet-mapping> es una etiqueta muy importante. Define las URL que serán procesadas por el servlet. En nuestro caso, todas estas son URL, por lo que simplemente indicamos “/”. Pero, por ejemplo, si tuviéramos una aplicación con usuarios y sus máquinas, entonces podríamos crear un segundo servlet: SimpleAutoServlet. Entonces, la asignación para el servlet de usuario sería “/users” (es decir, solicitudes relacionadas con el procesamiento de usuarios), y para el servlet automático sería “/autos”. Y finalmente, <filtro>. Define internamente un objeto de la clase org.springframework.web.filter.HiddenHttpMethodFilter. El artículo no trata sobre Spring, por lo que no hablaré de ello en detalle. Permítanme decirles que se adjunta a nuestra aplicación solo como una característica adicional. El punto es que usaremos páginas JSP para crear el lado del cliente. Nuestros datos se mostrarán en la página como una tabla con una lista de usuarios. Dentro de las páginas JSP, se utilizarán etiquetas HTML <form/>. Y solo se pueden utilizar solicitudes HTTP GET y POST para enviar datos desde <form/>. Es decir, para las tres operaciones (actualizar, eliminar y crear un usuario), tendríamos que usar solo solicitudes POST. El uso de solicitudes PUT y DELETE no estaría disponible para nosotros. Y, en principio, esto es bastante normal y fácil de implementar, pero la clase HiddenHttpMethodFilter nos permite usarlos. Esto hará que las diferencias entre las operaciones en la aplicación sean más claras para el lector. Finalmente, pasemos al lado del cliente. Está representado por cinco páginas JSP. índice.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>

agregarUsuario.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="Nombre">
    <input required type="text" name="age" placeholder="Возраст">
    <input type="submit" value="Сохранить">
</form>
</body>
</html>

eliminarUser.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>

mostrarUsuarios.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>Nombre</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>

actualizarUser.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 página JSP (página de servidor Java) contiene dos tipos de texto: datos de origen estáticos, que pueden estar en uno de los formatos de texto (HTML, SVG, WML o XML), y elementos JSP, que construyen contenido dinámico. Para entender qué es JSP, me permitiré copiar y pegar una parte de un muy buen artículo de un autor ( desde aquí ). "Esencialmente, JSP se convierte en un servlet la primera vez que se accede a él y funciona como un servlet. Es muy importante entender esto. JSP NO ES una página como una página HTML ; es importante que un programador novato entienda claramente que esto es otro servlet, simplemente no necesita programar su salida. Puede simplemente dibujarlo y sustituir los datos en los lugares correctos. Pero como la página JSP al menos de alguna manera se parece a HTML, obviamente será más fácil para el diseñador. Y una vez más les digo ENCARECIDAMENTE a los principiantes: JSP es un SERVLET . Está preparado con todos los datos en el servidor. Aquí es donde se insertan todos los datos. Y el usuario recibe una página HTML lista para usar en el navegador, que no tiene algún signo de JAVA." Puede comprobar usted mismo que la página JSP es de hecho un servlet, porque cada página contiene un método que debe ejecutarse. Por ejemplo, la página de inicio index.jsp indica que cuando hace clic en el botón "Comenzar a trabajar con la base de datos", se ejecutará método="get". En la página addUser.jsp, que es responsable de crear un nuevo usuario, al hacer clic en el botón Guardar, se ejecutará método="post". El resto del JSP consiste en marcado HTML estático ordinario, por lo que no nos detendremos en ellos en detalle; este es el tema de un artículo separado, de los cuales hay muchos en Internet. Entonces, hemos creado nuestra aplicación, ¡solo queda probarla en acción! Para hacer esto, necesitaremos el contenedor de servlets Apache Tomcat mencionado anteriormente. Puedes descargar el gato desde el sitio web oficial (yo uso la versión 8). A continuación, necesitamos crear una configuración en IDEA para ejecutar nuestra aplicación a través de Tomcat. Para hacer esto, abra la pestaña "Editar configuraciones", cree una nueva configuración y seleccione Tomcat Server Local. En la pestaña Servidor de aplicaciones, especifique la ruta a la carpeta donde se encuentra Tomcat y luego vaya a la pestaña Implementación. Aquí configuramos el despliegue de nuestra aplicación en un servidor local. Haga clic en "+", seleccione "Artefacto" -> Nombre de su proyecto: war (ensamblaremos la aplicación en un archivo war). ¡Eso es básicamente todo! En la página "Servidor" puede ver que la misma aplicación se ejecutará en "http://localhost:8080/". Guarde esta configuración y asígnele un nombre (mi nombre de configuración es "Tommy"). A continuación, en la pestaña Maven en IDEA (en el lado derecho) usaremos el complemento war para construir nuestro proyecto en un archivo war (Complementos -> guerra -> guerra:guerra). ¡Éxito! Se ha lanzado la página de inicio. Ahora haga clic en el botón "Comenzar a trabajar con la base de datos". Nuestra página JSP index.jsp generará una solicitud GET que será procesada por el servidor. El servidor generará una respuesta y nos la devolverá en forma de una lista de todos los usuarios existentes (si, por supuesto, están en la base de datos). ¡Y aquí están! Intentemos eliminar a uno de los usuarios: ¡ también funciona! Entonces escribimos nuestra primera aplicación usando servlets. Como puede ver, todo resultó no ser tan difícil :) Como tarea, puede, por ejemplo, devolver a la aplicación la funcionalidad de trabajar con automóviles del artículo anterior. Aquellos. cree un servlet y páginas jsp separadas para automóviles y enseñe a nuestra aplicación a mostrar una lista de los automóviles del usuario, agregarle automóviles nuevos, así como editarlos y eliminarlos. PS Servlets y JSP son tecnologías bastante antiguas y en Internet a menudo se pueden encontrar comentarios del tipo "¿quién necesita esta basura?". La respuesta es bastante simple: lo necesitan principalmente aquellos que trabajarán en proyectos reales, en los que es muy posible que se escriba mucho código con ellos. Y convertir "cosas viejas" en algo nuevo, sin entender cómo funciona, sigue siendo un placer :) Para un estudio más profundo del tema de JSP y servlets, puede utilizar el libro "Head First Servlets and JSP" (en Solo inglés). Fue escrito por los mismos autores que el famoso superlibro "Head First Java", que para muchos puede ser garantía de calidad :) ¡Espero que este artículo haya sido útil para los lectores! Si desea ver nuevos artículos, no olvide apoyar al autor en el concurso dándole "Me gusta". O mejor aún: “Me gusta mucho” :) ¡Gracias por su atención y buena suerte en sus estudios!