Seu primeiro aplicativo usando servlets Java

Olá a todos! Neste artigo, você se familiarizará com o conceito básico de desenvolvimento web de servlets e será capaz de escrever um aplicativo simples usando-os. Para evitar etapas desnecessárias, não começaremos do zero e continuaremos trabalhando em nosso aplicativo do artigo anterior sobre o Hibernate . Porém, como estamos apenas começando com servlets, removi tudo relacionado à classe Auto da aplicação e deixei apenas a classe User e suas ações. A estrutura do projeto ficará assim: Então, servlets! A Wikipedia diz: "Um servlet é uma interface Java cuja implementação estende a funcionalidade do servidor. Um servlet interage com os clientes através de um princípio de solicitação-resposta." E de fato é. Aqui encontramos pela primeira vez o conceito de “arquitetura de aplicação cliente-servidor”. Sua essência é bastante simples e cabe em uma imagem (tirada daqui ). O cliente entra em contato com o servidor enviando uma solicitação HTTP. O servidor gera os dados necessários (por exemplo, recebe-os do banco de dados) e os retorna ao cliente. O exemplo mais simples: em uma determinada rede social você clica no botão “Amigos” e assim envia uma solicitação ao servidor. O servidor verifica a lista de seus amigos no banco de dados e a retorna para você (o cliente). A lista de solicitações HTTP é bastante grande, mas se você nunca as encontrou, para uma melhor compreensão é melhor ler sobre elas, por exemplo, aqui . Nossa tarefa é: Criar uma aplicação CRUD usando servlets. O aplicativo deve ser capaz de criar, modificar e excluir usuários do banco de dados usando um servlet que processe solicitações HTTP. Nossa aplicação do artigo sobre Hibernate já sabia fazer isso, mas era controlada diretamente pelo código Java, mais precisamente, pelo método main(). Aqui as solicitações serão enviadas pelo cliente, ou seja, você :) A primeira coisa que precisamos fazer é adicionar novas dependências ao nosso arquivo 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>

Adicionamos 3 dependências:

1. A própria biblioteca javax.servlet-api;
2. Biblioteca de tags JSTL. Será necessário criar o lado do cliente, nomeadamente páginas JSP;
3. Spring-WebMVC. Precisaremos de uma aula Spring, da qual falaremos um pouco mais tarde.

A operação dos servlets é gerenciada pelo contêiner do servlet. No nosso caso usaremos Apache Tomcat. Algo bastante popular e provavelmente você já ouviu falar :) O ciclo de vida de um servlet consiste nas seguintes etapas:

1. Se não houver servlet no contêiner.
   
   • A classe servlet é carregada pelo contêiner.
   • O contêiner cria uma instância da classe servlet.
   • O contêiner chama o método init(). Este método inicializa o servlet e é chamado primeiro, antes que o servlet possa atender às solicitações. O método init() é chamado apenas uma vez durante todo o seu ciclo de vida.
2. Atendendo a uma solicitação do cliente. Cada solicitação é processada em seu próprio thread separado. O contêiner chama o método service() para cada solicitação. Este método determina o tipo de solicitação recebida e a distribui ao método correspondente a esse tipo para processar a solicitação. O desenvolvedor do servlet deve fornecer implementações para esses métodos. Se for recebida uma solicitação para a qual um método não está implementado, o método da classe pai é chamado e geralmente termina com um erro sendo retornado ao solicitante.
3. Caso o container precise deletar um servlet, ele chama o método destroy(), que remove o servlet de serviço. Assim como o método init(), esse método também é chamado uma vez durante todo o ciclo do servlet.

Nosso servlet parecerá bastante simples:

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 você pode ver, ele contém o método init(), descrito acima, e implementa 4 métodos que coincidem com quatro solicitações HTTP - doGet(), doPost(), doPut() e doDelete(). Cada um deles nos permitirá, respectivamente, receber, criar, editar e excluir usuários. Os métodos tomam como entrada objetos das classes javax.servlet.http.HttpServletRequest e javax.servlet.http.HttpServletResponse - ou seja, a solicitação enviada ao servidor e a resposta que o cliente recebe. Dentro dos métodos, são executados os métodos necessários da classe UserService, uma resposta é gerada para o cliente e então redirecionada para o endereço /users. Por exemplo, no método doGet() obtemos uma lista de todos os usuários. A seguir, criamos um objeto da classe RequestDispatcher, que nos permite incluir objetos em uma solicitação Http, bem como redirecioná-la para um recurso específico (por exemplo, uma página JSP do cliente). No método doPut() (atualização dos dados do usuário), processamos a solicitação HTTP, extraímos dela os parâmetros id, nome e idade, encontramos o usuário com o id especificado, atribuímos a ele o nome e a idade que veio com ele no solicitação e retorne à página /users. Porém, para que todos esses métodos funcionem corretamente, precisamos configurar o servlet. Para isso utilizamos o arquivo web.xml na pasta 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 as tags neste arquivo são, em princípio, intuitivas, mas vamos examiná-las sequencialmente. <welcome-file-list> - é especificada a página JSP inicial, que será aberta primeiro quando o aplicativo for iniciado. No nosso caso, esta é a página index.jsp. <servlet> - registrando nossa classe UserSimpleServlet como um servlet. <servlet-mapping> é uma tag muito importante. Define as URLs que serão processadas pelo servlet. No nosso caso, são todos URLs, então simplesmente indicamos “/”. Mas, por exemplo, se tivéssemos uma aplicação com usuários e suas máquinas, poderíamos criar um segundo servlet - SimpleAutoServlet. Então o mapeamento para o servlet de usuário seria “/users” (ou seja, solicitações relacionadas ao processamento de usuários), e para o servlet automático seria “/autos”. E finalmente, <filtro>. Define internamente um objeto da classe org.springframework.web.filter.HiddenHttpMethodFilter. O artigo não diz respeito ao Spring, então não vou falar sobre isso em detalhes. Deixe-me apenas dizer que ele está anexado ao nosso aplicativo apenas como um recurso adicional. A questão é que usaremos páginas JSP para criar o lado do cliente. Nossos dados serão exibidos na página como uma tabela com uma lista de usuários. Dentro das páginas JSP, tags HTML <form/> serão usadas. E apenas solicitações HTTP GET e POST podem ser usadas para enviar dados de <form/>. Ou seja, para todas as três operações – atualizar, excluir e criar um usuário – teríamos que usar apenas solicitações POST. O uso de solicitações PUT e DELETE não estaria disponível para nós. E, em princípio, isso é bastante normal e fácil de implementar, mas a classe HiddenHttpMethodFilter nos permite utilizá-los. Isso tornará as diferenças entre as operações do aplicativo mais claras para o leitor. Finalmente, vamos passar para o lado do cliente. É representado por cinco páginas 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>

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

Uma página JSP (Java Server Page) contém dois tipos de texto: dados de origem estáticos, que podem estar em um dos formatos de texto (HTML, SVG, WML ou XML), e elementos JSP, que constroem conteúdo dinâmico. Para entender o que é JSP, permitir-me-ei copiar e colar um trecho de um artigo muito bom de um autor ( daqui ). "Essencialmente, JSP é convertido em um servlet na primeira vez que é acessado e funciona como um servlet. É muito importante entender isso. JSP NÃO É uma página como uma página HTML - é importante para um programador iniciante entender claramente que isso é outro servlet - você simplesmente não precisa programar sua saída. Você pode simplesmente desenhá-lo. E substituir os dados nos lugares certos. Mas como a página JSP pelo menos de alguma forma se assemelha ao HTML, obviamente será mais fácil para o designer. E mais uma vez digo FORTEMENTE aos iniciantes - JSP é um SERVLET . Ele é preparado com todos os dados no servidor. É onde todos os dados são inseridos. E o usuário recebe uma página HTML pronta no navegador, o que não acontece tem algum sinal de JAVA." Você pode ver por si mesmo que a página JSP é de fato um servlet, porque cada página contém um método que precisa ser executado. Por exemplo, a página inicial index.jsp informa que ao clicar no botão "Começar a trabalhar com o banco de dados", o método = "get" será executado. Na página addUser.jsp, responsável por criar um novo usuário, ao clicar no botão salvar, será executado o método = "post". O resto do JSP consiste em marcação HTML estática comum, portanto não vamos nos alongar sobre eles - este é o tópico de um artigo separado, dos quais existem muitos na Internet. Então, criamos nosso aplicativo, só falta testá-lo em ação! Para fazer isso, precisaremos do contêiner de servlet Apache Tomcat mencionado acima. Você pode baixar o gato no site oficial (eu uso a versão 8). A seguir, precisamos criar uma configuração no IDEA para executar nossa aplicação via Tomcat. Para isso, abra a aba “Editar Configurações”, crie uma nova configuração e selecione Tomcat Server Local. Na aba Application Server especifique o caminho para a pasta onde o Tomcat está localizado e em seguida vá para a aba Deployment. Aqui configuramos a implantação de nossa aplicação em um servidor local. Clique em "+", selecione "Artefato" -> Nome do seu projeto: war (montaremos o aplicativo em um arquivo war). É basicamente isso! Na página "Servidor" você pode ver que a mesma aplicação será executada em "http://localhost:8080/". Salve esta configuração e dê um nome a ela (meu nome de configuração é “Tommy”). A seguir, na aba Maven no IDEA (no lado direito) usaremos o plugin war para construir nosso projeto em um arquivo war (Plugins -> war -> war:war). Sucesso! A página inicial foi lançada. Agora clique no botão “Começar a trabalhar com o banco de dados”. Nossa página JSP index.jsp irá gerar uma solicitação GET que será processada pelo servidor. O servidor irá gerar uma resposta e devolvê-la para nós na forma de uma lista de todos os usuários existentes (se, é claro, eles estiverem no banco de dados). E aqui estão eles! Vamos tentar deletar um dos usuários: Também funciona! Então escrevemos nossa primeira aplicação usando servlets. Como você pode ver, tudo acabou não sendo tão difícil :) Como lição de casa, você pode, por exemplo, devolver ao aplicativo a funcionalidade de trabalhar com carros do artigo anterior. Aqueles. crie páginas servlet e jsp separadas para carros e ensine nosso aplicativo a exibir uma lista de carros do usuário, adicionar novos carros a ele, bem como editá-los e excluí-los. Servlets PS e JSP são tecnologias bastante antigas e, na Internet, muitas vezes você pode encontrar comentários com o espírito de “quem precisa desse lixo?” A resposta é bastante simples - ela é necessária principalmente para aqueles que trabalharão em projetos reais, nos quais é bem possível que haja muito código escrito com eles. E transformar “coisas antigas” em algo novo, sem entender como funciona, ainda é um prazer :) Para um estudo mais aprofundado do tópico JSP e servlets, você pode usar o livro “Head First Servlets and JSP” (em Apenas inglês). Foi escrito pelos mesmos autores do famoso superlivro “Head First Java”, o que para muitos pode ser uma garantia de qualidade :) Espero que este artigo tenha sido útil aos leitores! Se você gostaria de ver novos artigos, não se esqueça de apoiar o autor no concurso dando um "Curtir" nele. Ou melhor ainda - “Gostei muito” :) Obrigado pela atenção e boa sorte nos estudos!