Ejercicio: Creación de una sencilla aplicación web de Java de Tomcat

10 minutos

Las aplicaciones web se usan ampliamente para controlar tareas del mundo real, como la administración del inventario, los formularios en línea y los portales orientados al cliente. En este módulo, aprenderá a crear e implementar una aplicación web de Java mediante Apache Tomcat, un popular servidor de código abierto.

Supongamos que es un desarrollador que trabaja en un proyecto para crear una aplicación web dinámica donde los usuarios pueden escribir datos e interactuar con su plataforma en tiempo real. El cliente quiere que esta aplicación esté disponible localmente para realizar pruebas y en la nube para facilitar el acceso. Esta configuración le permite probar primero en la máquina local y, a continuación, se implementa en un entorno activo como una transición sin problemas. La creación de esta configuración desde cero ofrece flexibilidad para futuras actualizaciones y configuraciones.

En este módulo, explorará los pasos esenciales para compilar e implementar una aplicación web de Java con Tomcat. Tiene dos opciones: clonar un repositorio de proyecto existente para la implementación inmediata o compilar un nuevo proyecto desde cero con Maven. En este módulo se explica cómo configurar el proyecto de Maven, configurar Tomcat, implementar la aplicación localmente y usar herramientas como Maven para administrar dependencias y paquetes.

Al final de este módulo, podrá crear e implementar aplicaciones web basadas en Java en Tomcat, preparándole para admitir la implementación de aplicaciones web tanto localmente como en entornos hospedados en la nube.

Creación de una aplicación web de Java Tomcat

En este ejercicio, creará una aplicación web java mínima que toma una entrada y muestra el resultado en la pantalla. A continuación, implemente la aplicación web localmente en el equipo mediante Tomcat. Dispone de las siguientes dos opciones:

Opción 1: Clone el repositorio de ejemplo e implemente inmediatamente la aplicación web.
Opción 2: Crear un proyecto de Maven Tomcat desde cero.

Opción 1: Clonar el repositorio de ejemplo e implementar inmediatamente la aplicación web

Para clonar el repositorio, siga estos pasos:

Clone el repositorio de proyecto de ejemplo mediante el comando siguiente:

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

Vaya al repositorio de proyectos clonado mediante el comando siguiente:
```
cd simple-tomcat-app
```

Siga estos pasos para configurar el servidor de Tomcat local para que pueda implementarlo localmente en Tomcat:

Advertencia

El almacenamiento de nombres de usuario y contraseñas directamente en archivos de configuración como tomcat-users.xml y la settings.xml de Maven en texto sin formato no se considera seguro y, por lo general, no se recomienda este procedimiento, especialmente para entornos de producción. Sin embargo, otras alternativas están fuera del ámbito de este módulo de entrenamiento. ¡No uses tu nombre de usuario y contraseña reales!

Edite el archivo de configuración de Tomcat conf/tomcat-users.xml para que tenga un aspecto similar al ejemplo siguiente:

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

Agregue sus credenciales al archivo ~/.m2 de Maven/settings.xml mediante el ejemplo siguiente, donde reemplace your-tomcat-username por un nombre de usuario y your-tomcat-password por una contraseña:
```
<servers>
    <server>
        <id>TomcatServer</id>
        <username>your-tomcat-username</username>
        <password>your-tomcat-password</password>
    </server>
</servers>
```
Use el siguiente comando para empaquetar e implementar la aplicación web:
```
mvn clean package cargo:deploy
```

Después de la implementación, puede acceder a la aplicación en http://localhost:8080/simple-tomcat-app.

Opción 2: Creación de un proyecto de Maven Tomcat desde cero

Para crear un proyecto de Maven Tomcat desde cero, se trabaja con varios procedimientos, empezando por la creación del proyecto de Maven y terminando con la implementación de la aplicación web en Tomcat.

Creación de un proyecto de Maven

Para crear un proyecto de Maven para la aplicación web de Java, use el siguiente comando:

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

La salida siguiente es 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] ------------------------------------------------------------------------

Ahora tiene un nuevo proyecto web de Maven en una carpeta denominada simple-tomcat-app. Ahora están disponibles los archivos y directorios siguientes:

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

Modificación del archivo pom.xml de Maven

Modifique el archivo pom.xml mediante los pasos siguientes:

Abra pom.xml y establezca la versión de Java en 21 mediante el ejemplo siguiente:

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

Agregue complementos de implementación de Tomcat y Azure mediante el ejemplo siguiente:

<!-- 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>

Este es el contenido completo del archivo 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>

Creación de una interfaz web

Para agregar una página web, edite el archivo src/main/webapp/index.jsp mediante el ejemplo siguiente:

<!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>

Creación de un servlet

Un servlet es una clase de programación java que se usa para ampliar las funcionalidades de un servidor mediante el control de solicitudes y la generación de contenido dinámico. Los Servlets se ejecutan en el lado servidor dentro de un contenedor web , como Apache Tomcat, y se usan principalmente para procesar solicitudes HTTP en aplicaciones web. Cuando un cliente , por ejemplo, un explorador web, envía una solicitud a un servidor web, el servlet procesa la solicitud. El servlet realiza cualquier lógica de negocios necesaria (por ejemplo, el acceso a bases de datos o la llamada a otros servicios) y, a continuación, genera una respuesta ( a menudo en forma de HTML) para devolver al cliente. Servlets permite a los desarrolladores crear aplicaciones web dinámicas independientes de la plataforma mediante Java.

Para crear un servlet, siga estos pasos:

Actualice la estructura de archivos para agregar un servlet mediante el siguiente comando:
```
mkdir -p src/main/java/com/example && touch src/main/java/com/example/HelloServlet.java
```

Actualice el contenido del archivo HelloSeverlet.java mediante el ejemplo de código siguiente:

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>");
    }
}

La nueva estructura de archivos tiene este aspecto:

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

Desplegar localmente en Tomcat

Siga estos pasos para configurar el servidor de Tomcat local para que pueda implementarlo:

Advertencia

El almacenamiento de nombres de usuario y contraseñas directamente en archivos de configuración como tomcat-users.xml y lasettings.xml de Maven en texto sin formato no es seguro y no se recomienda generalmente, especialmente para entornos de producción. Sin embargo, otras alternativas están fuera del ámbito de este módulo de entrenamiento. ¡No uses tu nombre de usuario y contraseña reales!

Edite el archivo de configuración de Tomcat conf/tomcat-users.xml mediante el ejemplo siguiente:

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

Agregue sus credenciales al archivo ~/.m2/ de Mavensettings.xmlmediante el ejemplo siguiente, reemplazando your-tomcat-username por un nombre de usuario y your-tomcat-password con una contraseña:
```
<servers>
    <server>
        <id>TomcatServer</id>
        <username>your-tomcat-username</username>
        <password>your-tomcat-password</password>
    </server>
</servers>
```

Implementación de la aplicación web en Tomcat

Use el siguiente comando para empaquetar e implementar la aplicación web:

mvn clean package cargo:deploy

Después de la implementación, la aplicación está disponible en http://localhost:8080/simple-tomcat-app.

Comentarios

¿Le ha resultado útil esta página?