Seu primeiro aplicativo usando servlets Java

Olá pessoal! Você se familiarizará com os servlets como um conceito básico de desenvolvimento da Web e será capaz de escrever um aplicativo simples que os utilize. Para evitar ações desnecessárias, não começaremos do zero. Continuaremos trabalhando em nosso aplicativo do meu artigo anterior sobre Hibernate . Mas como estamos começando a nos familiarizar com os servlets, removi da aplicação tudo relacionado à classe Auto e deixei apenas a classe User e as ações que a envolvem. O projeto será estruturado assim: Então, servlets! A Wikipedia afirma: "Um servlet Java é um componente de software Java que estende os recursos de um servidor. Embora os servlets possam responder a muitos tipos de solicitações, eles geralmente implementam contêineres da Web para hospedar aplicativos da Web em servidores da Web e, portanto, qualificam-se como um servidor- API da Web do servlet lateral." Isso é exatamente verdade. Aqui, pela primeira vez, encontramos o conceito de uma "arquitetura de aplicativo cliente-servidor". É bastante simples em seu núcleo. O cliente acessa o servidor enviando uma solicitação HTTP. O servidor gera os dados necessários (por exemplo, busca-os em um banco de dados) e os devolve ao cliente. O exemplo mais simples é quando você clica no botão "Amigos" em uma determinada rede social, enviando assim uma solicitação ao servidor. O servidor atualiza a lista de seus amigos no banco de dados e a retorna para você (o cliente). A lista de solicitações HTTP é bastante grande, portanto, se você nunca as encontrou antes, seria melhor ler sobre elas em outro lugar, por exemplo,aqui . Nosso objetivo é: Criar um aplicativo CRUD usando servlets. O aplicativo deve ser capaz de criar, ler, atualizar e excluir usuários do banco de dados usando um servlet que processa solicitações HTTP. Nossa aplicação do artigo Hibernate já podia fazer isso, mas era controlada diretamente do código Java, mais precisamente, do método main(). Desta vez, é o cliente quem enviará as requisições, 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. A biblioteca de tags JSTL. Será necessário criar o lado do cliente, ou seja, as páginas JSP
3. Spring-WebMVC. Vamos precisar de uma aula de primavera, sobre a qual falaremos um pouco mais tarde.

O gerenciamento de servlet é tratado pelo contêiner de servlet. No nosso caso, usaremos o Apache Tomcat. É bastante popular — você provavelmente já ouviu falar dele :) O ciclo de vida do 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(). Esse método inicializa o servlet e é chamado primeiro, antes que o servlet possa atender às solicitações. Durante todo o ciclo de vida, o método init() é chamado apenas uma vez.
2. Atender a 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 envia para o método apropriado para processamento. O desenvolvedor do servlet deve fornecer implementações para esses métodos. Se chega uma requisição para um handler que não está implementado, o método da classe pai é chamado e normalmente acaba retornando um erro para o requisitante.


3. Se o container precisar remover o servlet, ele chama o método destroy(), que tira o servlet de operação. Assim como o método init(), esse método também é chamado uma vez durante todo o ciclo do servlet.

Nosso servlet parece bem 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: doPost(), doGet(), doPut() e doDelete(). Eles nos permitem criar, ler, atualizar e excluir usuários. Os métodos aceitam instâncias das classes javax.servlet.http.HttpServletRequest e javax.servlet.http.HttpServletResponse como entrada, ou seja, solicitações enviadas ao servidor e respostas recebidas pelo cliente. Internamente, os métodos chamam os métodos relevantes da classe UserService e uma resposta para o cliente é gerada e redirecionada para a URL /users. Por exemplo, no método doGet(), obtemos uma lista de todos os usuários. Em seguida, criamos um objeto RequestDispatcher, que nos permite incluir objetos em uma solicitação HTTP e redirecioná-la para um recurso específico (por exemplo, para uma página JSP do cliente). No método doPut() (que atualiza os dados do usuário), processamos uma solicitação HTTP, extraímos os parâmetros id, name e age, localizamos o usuário com o id especificado, atribuímos a ele o nome e a idade que constam na solicitação e retornamos para a página /users. Mas para que todos esses métodos funcionem corretamente, precisamos configurar o servlet. Para fazer isso, usamos 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 bastante intuitivas, mas vamos analisá-las em ordem. <lista de arquivos de boas-vindas> - A página inicial do JSP é indicada, que será aberta primeiro quando o aplicativo for iniciado. No nosso caso, é index.jsp. <servlet> - Registro de nossa classe UserSimpleServlet como um servlet. <servlet-mapping> - uma tag muito importante. Ele define as URLs que serão processadas pelo servlet. No nosso caso, são todas as URLs, então simplesmente indicamos "/". Mas se tivéssemos um aplicativo envolvendo usuários e seus carros (autos), poderíamos criar um segundo servlet (SimpleAutoServlet). Em seguida, o mapeamento do servlet do usuário seria "/users" (ou seja, solicitações sobre usuários) e o mapeamento do servlet automático seria "/autos". E, finalmente, <filtro>. Internamente, define uma instância do org. classe springframework.web.filter.HiddenHttpMethodFilter. Este artigo não é sobre o Spring, então não vou descrevê-lo em detalhes. Direi apenas que ele está embutido em nosso aplicativo apenas como um recurso adicional. O problema é que vamos usar 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, serão utilizadas tags HTML <form/>. Mas apenas solicitações HTTP GET e POST podem ser usadas para enviar dados de um <form/>. Em outras palavras, para todas as três operações — atualizar, excluir e criar um usuário — teríamos que usar apenas solicitações POST. Usar solicitações PUT e DELETE não seria uma opção para nós. Em princípio, isso é bastante normal e fácil de implementar, mas a classe HiddenHttpMethodFilter nos permite usá-los. Desta maneira, o leitor verá com mais clareza a diferença entre as operações no aplicativo. Finalmente, vamos prosseguir 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>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>

Uma página JSP (JavaServer Page) contém dois tipos de texto: dados de origem estáticos que podem ser formatados como texto (HTML, SVG, WML ou XML) e elementos JSP usados ​​para construir conteúdo dinâmico. Para ajudá-lo a entender o que é uma página JSP, copiei uma passagem de um artigo muito bom. "Basicamente, a primeira vez que um JSP é solicitado, ele se transforma em um servlet e opera como um servlet. É muito importante entender isso. Uma página JSP NÃO É como uma página HTML — um programador iniciante deve entender claramente que este é outro servlet — é só que você não precisa programar como ele é exibido. Ele pode simplesmente ser desenhado. E adicionar dados quando necessário. Mas como uma página JSP é uma reminiscência de HTML, um designer obviamente achará isso mais fácil. E mais uma vez ENfatize fortemente para iniciantes,uma página JSP é um SERVLET. Ele é gerado, incluindo a adição de todos os dados, no servidor. É aqui que todos os dados são inseridos. E no navegador, o usuário obtém a página HTML finalizada, que não possui sinais de Java." Pode ter certeza que uma página JSP é realmente um servlet, pois cada página possui um método que precisa ser executado. Por exemplo, index .jsp indica que ao clicar no botão "Começar a trabalhar com o banco de dados" o método get será executado (method = "get") A página addUser.jsp, responsável por criar novos usuários, executa o método post (method = "post") quando você clicar no botão salvar. O resto da página JSP é feito de marcação HTML estática regular, então não vamos nos deter nisso. Esse é um tópico para outro artigo e há muitos sobre isso tópico na Internet. Então, nós criamos nosso aplicativo! Agora precisamos testá-lo em ação! Para fazer isso, precisamos do contêiner do servlet Apache Tomcat mencionado acima. Você pode baixar o contêinerdo site oficial (eu uso a versão 8). Em seguida, precisamos criar uma configuração no IDEA para executar nosso aplicativo através do Tomcat. Para fazer isso, abra a guia "Editar configurações", crie uma nova configuração e selecione "Tomcat Server Local". Na guia "Application Server", especifique o caminho para a pasta Tomcat Em seguida, vá para a guia "Deployment". Aqui, configuramos a implantação de nosso aplicativo no servidor local. Pressione "+", selecione "Artifact" -> YourProjectName:war (iremos construir o aplicativo para um arquivo war). E isso resume tudo! Na página "Servidor", você pode ver que nosso aplicativo será executado em http://localhost:8080/. Salve a configuração e dê um nome a ela (eu chamo minha configuração de "Tommy"). A seguir, na aba Maven do IDEA (lado direito), usaremos o plugin war para compilar nosso projeto em um arquivo war (Plugins -> war -> war: war). Após a conclusão da compilação, execute o aplicativo e aguarde. Sucesso! A página inicial foi lançada. Agora clicamos no botão "Começar a trabalhar com o banco de dados". Nosso index.jsp irá gerar uma requisição GET que será processada pelo servidor. O servidor gerará uma resposta e a retornará para nós na forma de uma lista de todos os usuários existentes (supondo que existam usuários no banco de dados, é claro). E lá estão eles! Aí está! Você escreveu seu primeiro aplicativo usando servlets Java. Isso não foi tão ruim, foi? :) Como lição de casa, você pode restaurar a funcionalidade do carro do artigo anterior. Em outras palavras, crie um servlet separado e páginas JSP para carros e ensine o aplicativo a listar os carros de um usuário, adicionar novos carros a um usuário e editá-los e excluí-los. PS Servlets e JavaServer Pages são tecnologias bastante antigas. Na Internet, muitas vezes você pode encontrar comentários como "Quem precisa desse lixo velho?" A resposta é bem simples: principalmente pessoas que irão trabalhar em projetos reais, onde possivelmente poderão encontrar muitos códigos que utilizam essas tecnologias. E mesmo sem entender como funciona, ainda é divertido cortar "velho lixo" em algo novo :) Para um estudo mais aprofundado de JSP e servlets, você pode consultar o livro "Head First Servlets and JSP ". Foi escrito pelos mesmos autores do famoso super livro "Head First Java", que muitos tomarão como garantia de qualidade :) Espero que este artigo tenha sido útil! Obrigado pela atenção e boa sorte no aprendizado!