Exercício – Criar um aplicativo Web Java simples do Tomcat

10 minutos

Os aplicativos Web são amplamente usados para lidar com tarefas reais, como gerenciamento de inventário, formulários online e portais voltados para o cliente. Neste módulo, você aprenderá a criar e implantar um aplicativo Web Java usando o Apache Tomcat, um servidor de software livre popular.

Suponha que você seja um desenvolvedor trabalhando em um projeto para criar um aplicativo Web dinâmico em que os usuários possam inserir dados e interagir com sua plataforma em tempo real. Seu cliente deseja que esse aplicativo esteja disponível localmente para teste e na nuvem para facilitar o acesso. Essa configuração permite que você teste primeiro em seu computador local e, em seguida, implanta em um ambiente dinâmico como uma transição perfeita. Criar essa configuração do zero oferece flexibilidade para atualizações e configurações futuras.

Neste módulo, você explorará 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 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 localmente e em ambientes hospedados na nuvem.

Criar um aplicativo Web Java Tomcat

Neste exercício, você cria um aplicativo Web Java mínimo que usa 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: clone o repositório de exemplo e implante imediatamente seu aplicativo Web.
Opção 2: criar um projeto Tomcat do Maven 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:

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

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

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:

Aviso

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 escopo deste módulo de treinamento. Não use seu nome de usuário e senha reais!

Edite a configuração do arquivo de configuração do Tomcattomcat-users.xmlpara que ele se pareça com o seguinte exemplo:

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

Adicione suas credenciais ao arquivo desettings.xmldo Maven ~/.m2/ usando o exemplo a seguir, em que 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>
```
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 Tomcat do Maven do zero

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

Criar um projeto do Maven

Para criar um projeto Maven para seu aplicativo Web Java, use o seguinte comando:

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

A saída a seguir é 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. Os seguintes arquivos e diretórios agora estão disponíveis:

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

Modificar o arquivo de pom.xml do Maven

Modifique o arquivo pom.xml usando as seguintes etapas:

Abra pom.xml e defina a versão 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>

Adicione plug-ins de implantação do Tomcat e do Azure usando o seguinte exemplo:

<!-- 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 da 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 Web. Quando um cliente - por exemplo, um navegador da Web - envia uma solicitação para um servidor 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:

Atualize a estrutura de arquivos para adicionar um servlet usando o seguinte comando:

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

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

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

Implantar localmente no Tomcat

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

Aviso

Armazenar nomes de usuário e senhas diretamente em arquivos de configuração como tomcat-users.xml e osettings.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 escopo deste módulo de treinamento. Não use seu nome de usuário e senha reais!

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

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

Adicione suas credenciais ao arquivo desettings.xml~/.m2/ 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>
```

Implantar seu aplicativo Web no Tomcat

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

mvn clean package cargo:deploy

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

Comentários

Esta página foi útil?