Exercício - Crie um aplicativo Web Java Tomcat simples

  • 10 minutos

Os aplicativos da Web são amplamente utilizados para lidar com tarefas do mundo real, como gerenciamento de inventário, formulários on-line e portais voltados para o cliente. Neste módulo, você aprenderá a criar e implantar uma aplicação web Java usando o Apache Tomcat, um popular servidor de código aberto.

Suponha que você seja um desenvolvedor trabalhando em um projeto para criar um aplicativo Web dinâmico onde os usuários possam inserir dados e interagir com sua plataforma em tempo real. Seu cliente quer que este aplicativo esteja disponível localmente para teste e na nuvem para fácil acesso. Esta configuração permite que tu testes na tua máquina local primeiro e, em seguida, implantes num ambiente ao vivo como uma transição sem falhas. A criação desta configuração a partir do zero dá-lhe flexibilidade para futuras atualizações e configurações.

Neste módulo, você explora as etapas essenciais para criar e implantar um aplicativo Web Java com o Tomcat. Você tem duas opções: clonar um repositório de projeto existente para implantação imediata ou criar um novo projeto do zero com o Maven. Este módulo aborda a configuração do seu projeto Maven, a configuração do Tomcat, a implantação do aplicativo localmente e o uso de ferramentas como o Maven para gerenciar dependências e pacotes.

Ao final deste módulo, você poderá criar e implantar aplicativos Web baseados em Java no Tomcat, preparando-o para dar suporte à implantação de aplicativos Web tanto localmente quanto em ambientes hospedados na nuvem.

Criar um aplicativo Web Java Tomcat

Neste exercício, você cria um aplicativo Web Java mínimo que recebe uma entrada e exibe o resultado na tela. Em seguida, você implanta o aplicativo Web localmente em seu computador usando o Tomcat. Você tem as duas opções a seguir:

  • Opção 1: clonar o repositório de exemplo e implantar imediatamente seu aplicativo Web.
  • Opção 2: Crie um projeto Maven Tomcat do zero.

Opção 1: clonar o repositório de exemplo e implantar imediatamente seu aplicativo Web

Para clonar o repositório, use as seguintes etapas:

  1. Clone o repositório de projeto de exemplo usando o seguinte comando:

    git clone https://github.com/MicrosoftDocs/simple-tomcat-maven-app.git

  2. Navegue até o repositório de projeto clonado usando o seguinte comando:

    cd simple-tomcat-app

Use as seguintes etapas para configurar o servidor Tomcat local para que você possa implantar localmente no Tomcat:

Advertência

Armazenar nomes de usuário e senhas diretamente em arquivos de configuração, como tomcat-users.xml e settings.xml do Maven, em texto sem formatação não é considerado seguro, e geralmente não recomendamos essa prática - especialmente para ambientes de produção. No entanto, outras alternativas estão fora do âmbito deste módulo de formação. Não use seu nome de usuário e senha reais!

  1. Edite o arquivo de configuração do Tomcat conf/tomcat-users.xml para que ele se pareça com o exemplo a seguir:

    <tomcat-users>
    <user username="your-tomcat-username" password="your-tomcat-password" roles="manager-script"/>
</tomcat-users>

  2. Adicione suas credenciais ao arquivo Maven ~/.m2/settings.xml usando o exemplo a seguir, onde você substitui your-tomcat-username por um nome de usuário e your-tomcat-password por uma senha:

    <servers>
    <server>
        <id>TomcatServer</id>
        <username>your-tomcat-username</username>
        <password>your-tomcat-password</password>
    </server>
</servers>

  3. Use o seguinte comando para empacotar e implantar seu aplicativo Web:

    mvn clean package cargo:deploy

Após a implantação, você pode acessar seu aplicativo em http://localhost:8080/simple-tomcat-app.

Opção 2: Criar um projeto Maven Tomcat do zero

Para criar um projeto Maven Tomcat do zero, você trabalha com vários procedimentos, começando com a criação do projeto Maven e terminando com a implantação de seu aplicativo Web no Tomcat.

Criar um projeto Maven

Para criar um projeto Maven para sua aplicação Web Java, use o seguinte comando:

mvn archetype:generate \
    -DgroupId=com.example \
    -DartifactId=simple-tomcat-app \
    -DarchetypeArtifactId=maven-archetype-webapp \
    -DinteractiveMode=false

A seguinte saída é típica:

[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: basedir, Value: /home/XXXXXXXX/LearnProjects/simple-tomcat-maven-app
[INFO] Parameter: package, Value: com.microsoft.azure.samples
[INFO] Parameter: groupId, Value: com.microsoft.azure.samples
[INFO] Parameter: artifactId, Value: azure-javaweb-app-simple
[INFO] Parameter: packageName, Value: com.microsoft.azure.samples
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: /private/tmp/TMP/azure-javaweb-app
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  1.657 s
[INFO] Finished at: 2024-10-18T12:39:41-07:00
[INFO] ------------------------------------------------------------------------

Agora você tem um novo projeto Web Maven em uma pasta chamada simple-tomcat-app. Ficaram disponíveis os seguintes ficheiros e diretórios:

└── simple-tomcat-app
    ├── pom.xml
    └── src
        ├── main
        │   ├── java
        │   ├── resources
        │   └── webapp
        │       ├── index.jsp
        │       └── WEB-INF
        │           └── web.xml
        └── test
            ├── java
            └── resources

Modificar o arquivo Maven pom.xml

Modifique o arquivo pom.xml usando as seguintes etapas:

  1. Abra opom.xml e defina a versão do Java como 21 usando o seguinte exemplo:

    <java.version>21</java.version>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>

  2. Adicione plug-ins de implantação do Tomcat e do Azure usando o exemplo a seguir:

    <!-- Tomcat 10 Maven Plugin -->
<plugin>
  <groupId>org.codehaus.cargo</groupId>
  <artifactId>cargo-maven3-plugin</artifactId>
  <version>1.9.9</version>
  <configuration>
    <!-- Container Configuration -->
    <container>
      <containerId>tomcat10x</containerId>
      <type>remote</type>
    </container>
    <!-- Configuration for Remote Deployment -->
    <configuration>
      <type>runtime</type>
      <properties>
        <cargo.remote.uri>http://localhost:8080/manager/text</cargo.remote.uri>
        <cargo.remote.username>cargo</cargo.remote.username>
        <cargo.remote.password>your-cargo-password</cargo.remote.password>
      </properties>
    </configuration>
    <!-- Deployable Artifact Configuration -->
    <deployables>
      <deployable>
        <groupId>${project.groupId}</groupId>
        <artifactId>${project.artifactId}</artifactId>
        <type>war</type>
        <properties>
          <context>${project.artifactId}</context>
        </properties>
      </deployable>
    </deployables>
  </configuration>
</plugin>

Aqui está o conteúdo completo do arquivo pom.xml :

<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.example</groupId>
  <artifactId>simple-tomcat-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>simple-tomcat-app</name>
  <properties>
    <java.version>21</java.version>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>jakarta.servlet</groupId>
      <artifactId>jakarta.servlet-api</artifactId>
      <version>6.0.0</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>simple-tomcat-app</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.10.1</version>
        <configuration>
          <source>${java.version}</source>
          <target>${java.version}</target>
        </configuration>
      </plugin>
      <!-- Tomcat 10 Maven Plugin -->
      <plugin>
        <groupId>org.codehaus.cargo</groupId>
        <artifactId>cargo-maven3-plugin</artifactId>
        <version>1.9.9</version>
        <configuration>
          <!-- Container Configuration -->
          <container>
            <containerId>tomcat10x</containerId>
            <type>remote</type>
          </container>
          <!-- Configuration for Remote Deployment -->
          <configuration>
            <type>runtime</type>
            <properties>
              <cargo.remote.uri>http://localhost:8080/manager/text</cargo.remote.uri>
              <cargo.remote.username>cargo</cargo.remote.username>
              <cargo.remote.password>your-cargo-password</cargo.remote.password>
            </properties>
          </configuration>
          <!-- Deployable Artifact Configuration -->
          <deployables>
            <deployable>
              <groupId>${project.groupId}</groupId>
              <artifactId>${project.artifactId}</artifactId>
              <type>war</type>
              <properties>
                <context>${project.artifactId}</context>
              </properties>
            </deployable>
          </deployables>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Criar uma interface web

Para adicionar uma página da Web, edite o arquivo src/main/webapp/index.jsp usando o seguinte exemplo:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Simple Tomcat App</title>
</head>
<body>
    <h1>Welcome to the Simple Tomcat App</h1>
    <form action="hello" method="get">
        <label for="name">Enter your name:</label>
        <input type="text" id="name" name="name">
        <button type="submit">Submit</button>
    </form>
</body>
</html>

Criar um servlet

Um servlet é uma classe de programação Java usada para estender os recursos de um servidor manipulando solicitações e gerando conteúdo dinâmico. Os servlets são executados no lado do servidor dentro de um contêiner da Web - como o Apache Tomcat - e são usados principalmente para processar solicitações HTTP em aplicativos da Web. Quando um cliente - por exemplo, um navegador da Web - envia uma solicitação para um servidor da Web, o servlet processa a solicitação. O servlet executa qualquer lógica de negócios necessária - por exemplo, acessando bancos de dados ou chamando outros serviços - e, em seguida, gera uma resposta - muitas vezes na forma de HTML - para enviar de volta ao cliente. Os servlets permitem que os desenvolvedores criem aplicativos Web dinâmicos e independentes de plataforma usando Java.

Para criar um servlet, use as seguintes etapas:

  1. Atualize a estrutura do arquivo para adicionar um servlet usando o seguinte comando:

    mkdir -p src/main/java/com/example && touch src/main/java/com/example/HelloServlet.java

  2. Atualize o conteúdo do arquivo HelloSeverlet.java usando o exemplo de código a seguir:

    package com.example;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String name = request.getParameter("name");
        response.setContentType("text/html");
        response.getWriter().write("<h1>Hello, " + name + "!</h1>");
    }
}

Sua nova estrutura de arquivos tem esta aparência:

└── simple-tomcat-app
    ├── pom.xml
    └── src
        ├── main
        │   ├── java
        │   │   └── com
        │   │       └── example
        │   │           └── HelloServlet.java
        │   ├── resources
        │   └── webapp
        │       ├── index.jsp
        │       └── WEB-INF
        │           └── web.xml
        └── test
            ├── java
            └── resources

Implante localmente no Tomcat

Use as seguintes etapas para configurar seu servidor Tomcat local para que você possa implantá-lo:

Advertência

Armazenar nomes de usuário e senhas diretamente em arquivos de configuração, como tomcat-users.xml e settings.xml do Maven, em texto sem formatação não é seguro e geralmente não é recomendado, especialmente para ambientes de produção. No entanto, outras alternativas estão fora do âmbito deste módulo de formação. Não use seu nome de usuário e senha reais!

  1. Edite o arquivo de configuração do Tomcat conf/tomcat-users.xml usando o seguinte exemplo:

    <tomcat-users>
    <user username="your-tomcat-username" password="your-tomcat-password" roles="manager-script"/>
</tomcat-users>

  2. Adicione suas credenciais ao arquivo ~/.m2/settings.xml do Maven usando o exemplo a seguir, substituindo your-tomcat-username por um nome de usuário e your-tomcat-password por uma senha:

    <servers>
    <server>
        <id>TomcatServer</id>
        <username>your-tomcat-username</username>
        <password>your-tomcat-password</password>
    </server>
</servers>

Implante seu aplicativo Web no Tomcat

Use o seguinte comando para empacotar e implantar seu aplicativo Web:

mvn clean package cargo:deploy

Após a implementação, a sua aplicação estará disponível em http://localhost:8080/simple-tomcat-app.