# Java



--------------------------------------------------------------------------------
title: "Descripción General"
description: "Catalyst AppSail es un componente PaaS completamente gestionado de Catalyst Serverless que te permite desarrollar y desplegar servicios en Java, Node.js y Python en la nube con facilidad, y gestionar tus instancias de plataforma."
last_updated: "2026-07-30T07:10:05.826Z"
source: "https://docs.catalyst.zoho.com/es/serverless/help/appsail/help-guides/java/overview/"
service: "Serverless"
--------------------------------------------------------------------------------



# Java

### Descripción General

El entorno de programación Java incluye una variedad de frameworks que contienen clases pre-escritas, plantillas, paquetes y estructura sobre los cuales puedes construir tu propio código. Como se mencionó anteriormente, Catalyst te permite inicializar o agregar un servicio de AppSail en uno de estos dos formatos:

* Java- WAR
* Java- SE
 
Después de seleccionar el stack de Java al inicializar un servicio de aplicación, puedes seleccionar una de estas opciones. Sin embargo, aún puedes construir tu aplicación Java con cualquier framework; incorporar cualquier biblioteca, módulo o dependencia; generarla como cualquier paquete estándar; y seguir cualquier edición que necesites.

Note: Cuando usas la plantilla Java WAR para desplegar tu aplicación Java exportada como un archivo WAR, no necesitas incluir un servidor web Java en tu aplicación, ya que AppSail empaquetará tu aplicación con un servidor por defecto. Si eliges Java SE como tu plantilla para todos los demás formatos de aplicación Java, como un archivo JAR, necesitarás incluir un servidor embebido en tu aplicación.

La guía de ayuda de Java contiene instrucciones paso a paso sobre cómo construir aplicaciones de muestra básicas con algunos de los frameworks más populares, usando servidores web Java populares en ellas, y desplegando estas aplicaciones como servicios de AppSail, y configurando comandos de inicio según sea necesario.

<br>

### Prerrequisitos

Dependiendo del framework, servidor y edición que uses en estos ejemplos, necesitarás asegurarte de tener todos los prerrequisitos instalados en tu máquina local.


--------------------------------------------------------------------------------
title: "Embedded Jetty"
description: "Catalyst AppSail es un componente PaaS completamente gestionado de Catalyst Serverless que te permite desarrollar y desplegar servicios en Java, Node.js y Python en la nube con facilidad, y gestionar tus instancias de plataforma."
last_updated: "2026-07-30T07:10:05.826Z"
source: "https://docs.catalyst.zoho.com/es/serverless/help/appsail/help-guides/java/embedded-jetty/"
service: "Serverless"
--------------------------------------------------------------------------------


# Aplicación Java Simple con Embedded Jetty

Este ejemplo ilustra los pasos para construir una aplicación Java simple con un servidor Jetty embebido en ella. Eclipse Jetty es un servidor web Java ligero y también un contenedor de servlets. Esta aplicación será compilada, empaquetada y asociada con un servicio de AppSail como tipo Java SE, y desplegada en la consola.

1. Crea un nuevo proyecto Java desde un IDE de tu elección.

2. Incluye las siguientes bibliotecas en tu directorio de fuentes. Hemos creado una nueva carpeta en este ejemplo y la hemos llamado deps. Estos archivos JAR incluyen todos los servlets, archivos de utilidad y otras dependencias que embeben el servidor Jetty en tu aplicación. Puedes obtener estas dependencias del repositorio oficial de Maven. También puedes agregarlas como dependencias de Maven.

javax.servlet-api-3.1.0.jar
jetty-io-9.4.50.v20221201.jar
jetty-server-9.4.50.v20221201.jar
jetty-util-9.4.50.v20221201.jar
jetty-http-9.4.50.v20221201.jar
jetty-security-9.4.50.v20221201.jar
jetty-servlet-9.4.50.v20221201.jar
jetty-util-ajax-9.4.50.v20221201.jar

<br>

3. Para crear una aplicación Jetty embebida, necesitarás crear una instancia de la clase org.eclipse.jetty.server.Server y hacer referencia al puerto de escucha con la variable de entorno X_ZOHO_CATALYST_LISTEN_PORT en tu código principal. Debes agregar un handler de Servlet para manejar estas solicitudes. Crea los siguientes archivos Java en tu directorio principal y agrega los fragmentos de código de muestra que se proporcionan a continuación:

**CustomJettyServer.java**

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
public class CustomJettyServer 
{
    public static void main( String[] args ) throws Exception
    {
 String port = System.getenv("X_ZOHO_CATALYST_LISTEN_PORT");
 int listenPort;
        if(port != null && !port.isEmpty()) {
            listenPort = Integer.parseInt(System.getenv("X_ZOHO_CATALYST_LISTEN_PORT"));
        } else {
            listenPort = 9000;
        }
 Server server = new Server(listenPort);
        ServletContextHandler handler = new ServletContextHandler();
        handler.addServlet(ServletHandler.class.getName(), "/");
        server.setHandler(handler);
        server.start();
    }
}

<br>

**ServletHandler.java**

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ServletHandler extends HttpServlet{
 @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String path = req.getServletPath();
        System.out.println(path);

        try {
            resp.getWriter().write("Hello ABC");
            resp.getWriter().close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
    @Override
    protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
    @Override
    protected void doPut(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
    @Override
    protected void doHead(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
    @Override
    protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
}

<br>

4. Compila la aplicación ejecutando el comando que se proporciona a continuación:

javac -cp ".:./*:./deps/*" *.java

<br>

5. Ahora puedes inicializar un servicio de AppSail en el mismo directorio desde el CLI o agregarlo en un directorio de proyecto existente. La fuente de la aplicación debe ser el directorio de tu aplicación. Proporciona los siguientes valores al inicializar el servicio de aplicación:

    **Stack:** Java 8 <br>
    **Platform:** Java SE


6. Asegúrate de que el archivo compilado, junto con los archivos JAR en la carpeta deps, se agreguen en el directorio de compilación que especifiques durante la inicialización. Catalyst comprimirá automáticamente los archivos de tu aplicación durante el despliegue a la consola remota. 


7. Despliega el servicio de aplicación en la consola.  

8. Luego puedes configurar el comando de inicio que se proporciona a continuación desde la consola:

java -cp ".:./*:./deps/*" *.java

También puedes configurar esto en el archivo app-config.json antes de desplegar.

<br>

Accede al servicio de aplicación desplegado desde su URL de endpoint.


--------------------------------------------------------------------------------
title: "Spring MVC"
description: "Catalyst AppSail es un componente PaaS completamente gestionado de Catalyst Serverless que te permite desarrollar y desplegar servicios en Java, Node.js y Python en la nube con facilidad, y gestionar tus instancias de plataforma."
last_updated: "2026-07-30T07:10:05.826Z"
source: "https://docs.catalyst.zoho.com/es/serverless/help/appsail/help-guides/java/spring-mvc/"
service: "Serverless"
--------------------------------------------------------------------------------


# Spring- MVC

El framework Spring Web MVC es un módulo del popular framework Spring que sigue una arquitectura Modelo-Vista-Controlador. Este framework permite la creación de aplicaciones web, incorporando las ventajas del framework Spring junto con el acoplamiento débil de componentes en el patrón de diseño MVC. Está construido alrededor de un DispatcherServlet que maneja solicitudes y respuestas HTTP, y despacha las solicitudes a los handlers y controladores necesarios.

Este ejemplo explica los pasos para construir una aplicación de muestra en el framework Spring MVC, exportarla como un archivo WAR y desplegarla en AppSail. 

1. Crea un nuevo proyecto Maven usando un IDE de tu elección. Debes seleccionar el siguiente Archetype para el proyecto: org.apache.maven.archetypes maven-archetype-webapp.

2. En el archivo pom.xml de tu proyecto, agrega las dependencias de Spring que se proporcionan a continuación.

<dependency>
 	<groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>5.2.19.RELEASE</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.19.RELEASE</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>5.2.19.RELEASE</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.2.19.RELEASE</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>5.2.19.RELEASE</version>
 </dependency>
 <dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
 </dependency>

<br>

3. Agrega las dependencias a continuación en un encapsulado de compilación para compilar y generar el archivo WAR.

<plugins>
	<plugin>
 	<artifactId>maven-compiler-plugin</artifactId>
  <version>3.8.0</version>
  <configuration>
  	<source>1.8</source>
   <target>1.8</target>
  </configuration>
 </plugin>
 <plugin>
 	<artifactId>maven-war-plugin</artifactId>
 	<version>3.2.1</version>
  <configuration>
  	<warSourceDirectory>WebContent</warSourceDirectory>
  </configuration>
 </plugin>
</plugins>

<br>

4. Crea un archivo de configuración XML de Spring en tu proyecto, y agrega las configuraciones de beans que se proporcionan a continuación. 

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
">

Tu archivo de configuración de Spring debería verse algo así:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
">
<mvc:annotation-driven/>
<mvc:default-servlet-handler/>
<context:component-scan base-package="com.amelia.example.controller" />	
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
</beans>


<br>

5. Agrega un runtime de servidor al proyecto. Por ejemplo, si estás trabajando en el IDE Eclipse, puedes agregar un runtime objetivo para el servidor Apache Tomcat de la siguiente manera: Haz clic derecho en el **project -> Properties -> Targeted Runtime**. Aquí, puedes agregar el runtime requerido, luego haz clic en **Apply**.

6. Ahora puedes agregar el controlador requerido y el manejo de páginas de error, así como un mapeo de servlet en el archivo web.xml de tu proyecto. Por ejemplo, puedes usar la configuración que se proporciona a continuación:

<welcome-file-list>
 <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>
 <servlet>
 <servlet-name>helloworld</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
 <servlet-name>helloworld</servlet-name>
 <url-pattern>/</url-pattern>
 </servlet-mapping>
 <error-page>
  <error-code>404</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>401</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>500</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>400</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>403</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>408</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>413</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>414</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>505</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>405</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <error-code>409</error-code>
  <location>/error.jsp</location>
 </error-page>
 <error-page>
  <exception-type>
   java.lang.Throwable
  </exception-type>
  <location>/error.jsp</location>
 </error-page>

<br>

7. Puedes subir la aplicación a Catalyst exportándola como un archivo WAR. En el ejemplo de Eclipse, puedes hacer clic derecho en el proyecto y elegir **Export As -> WAR**. Debes hacer lo siguiente:

    a. Elige un destino con el nombre de archivo como ROOT.war <br>
    b. Desmarca la opción Optimize for specific server runtime. 

<br>

8. Ahora puedes inicializar un servicio de AppSail en el mismo directorio desde el CLI o agregarlo en un directorio de proyecto existente. La fuente de la aplicación debe ser el directorio de tu aplicación. Proporciona los siguientes valores al inicializar el servicio de aplicación:

    **Stack:** Java 8 <br>
    **Platform:** Java WAR


9. Asegúrate de que los archivos compilados se agreguen en el directorio de compilación que especifiques durante la inicialización. Catalyst comprimirá automáticamente los archivos de tu aplicación durante el despliegue a la consola remota. 

10. Despliega el servicio de aplicación en la consola.   

<br>

Accede al servicio de aplicación desplegado desde su URL de endpoint.


--------------------------------------------------------------------------------
title: "Spring Boot"
description: "Catalyst AppSail es un componente PaaS completamente gestionado de Catalyst Serverless que te permite desarrollar y desplegar servicios en Java, Node.js y Python en la nube con facilidad, y gestionar tus instancias de plataforma."
last_updated: "2026-07-30T07:10:05.826Z"
source: "https://docs.catalyst.zoho.com/es/serverless/help/appsail/help-guides/java/spring-boot/"
service: "Serverless"
--------------------------------------------------------------------------------


# Spring Boot

Spring Boot está construido sobre el popular framework Spring, e incluye una amplia gama de mejoras que te permiten construir fácilmente microservicios de nivel de producción, aplicaciones web y proyectos Spring independientes con esfuerzos de desarrollo reducidos. Spring Boot típicamente incluye servidores HTTP embebidos como Jetty o Apache Tomcat, sin las complejas configuraciones XML de Spring. 

Note: Cuando exportas una aplicación Spring Boot como un archivo JAR en el ejemplo a continuación, puedes conservar el servidor embebido incluido en ella. Sin embargo, cuando exportas la aplicación Spring Boot como un archivo WAR, necesitarás excluir el servidor embebido incluido en ella, si la inicializas como Java WAR en AppSail. Esto se debe a que AppSail ofrece soporte nativo para archivos WAR y los empaqueta con el servidor Jetty por defecto.



### Spring Boot- JAR

Este ejemplo ilustra los pasos para construir una aplicación Spring Boot de muestra, exportarla como un archivo JAR y desplegarla en AppSail. 

1. Abre Spring Initializr para crear un nuevo proyecto. 

2. Elige las siguientes configuraciones para tu proyecto:<br><br>
    a. Project - Maven Project<br>
    b. Language - Java<br>
    c. Spring Boot Version - 2.7.10<br>
    d. Package - JAR<br>
    e. Java Version - 8<br>
    f. Haz clic en **Add Dependencies** y selecciona **Spring Web**.

3. Haz clic en **Generate**.

4. Descomprime el proyecto y ábrelo en cualquier IDE de tu elección.

5. Agrega los controladores necesarios al proyecto. Por ejemplo, crea un archivo llamado DemoController.java en el directorio del archivo Java principal de tu proyecto, y agrega el controlador especificado a continuación en el archivo.

package com.example.demo;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class DemoController {
    @GetMapping("/")
    public String index() {
        return "Greetings from Spring Boot!";
    }
}

<br>

6. Catalyst verificará el puerto configurado para escucha con la variable de entorno X_ZOHO_CATALYST_LISTEN_PORT y la aplicación debe escuchar en ese puerto en todas las interfaces (host 0.0.0.0). Por lo tanto, necesitarás personalizar el puerto. Puedes hacer esto creando un archivo llamado ServerPortCustomizer.java en el directorio del archivo Java principal de tu proyecto, y agregando el código especificado a continuación:

package com.example.demo;
import org.springframework.boot.web.server.ConfigurableWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.stereotype.Component;
@Component
public class ServerPortCustomizer implements WebServerFactoryCustomizer<ConfigurableWebServerFactory> {
    @Override
    public void customize(ConfigurableWebServerFactory factory) {
        String port = System.getenv("X_ZOHO_CATALYST_LISTEN_PORT");
        int listenPort;
        if(port != null && !port.isEmpty()) {
            listenPort = Integer.parseInt(System.getenv("X_ZOHO_CATALYST_LISTEN_PORT"));
        } else {
            listenPort = 9000;
        }
        factory.setPort(listenPort);
    }
}

Ahora puedes guardar la aplicación y ejecutarla en Catalyst. 

7. Puedes ejecutar esta aplicación en tu máquina local ejecutando el siguiente comando desde tu terminal:

./mvnw spring-boot:run

8. Luego puedes compilar el código fuente, ejecutar pruebas y empaquetar el código compilado ejecutando el siguiente comando:


./mvnw clean package

Esto generará el archivo JAR de la aplicación en la carpeta target.

9. Ahora puedes inicializar un servicio de AppSail en el mismo directorio desde el CLI o agregarlo en un directorio de proyecto existente. La fuente de la aplicación debe ser el directorio de tu aplicación. Proporciona los siguientes valores al inicializar el servicio de aplicación:

    **Stack:** Java 8 <br>
    **Platform:** Java SE

10. Asegúrate de que el archivo JAR se agregue en el directorio de compilación que especificaste durante la inicialización. Catalyst comprimirá automáticamente tu archivo de aplicación durante el despliegue a la consola remota. 

11. Despliega el servicio de aplicación en la consola.   

12. Luego puedes configurar el comando de inicio que se proporciona a continuación desde la consola:

java -jar demo-0.0.1-SNAPSHOT.jar

También puedes configurar esto en el archivo app-config.json antes de desplegar.

<br>

Accede al servicio de aplicación desplegado desde su URL de endpoint.

<br>
<br>

### Spring Boot - WAR

Este ejemplo explica los pasos para construir una aplicación Spring Boot de muestra, exportarla como un archivo WAR y desplegarla en AppSail:

1. Abre Spring Initializr para crear un nuevo proyecto. 

2. Elige las siguientes configuraciones para tu proyecto:<br><br>
    a. Project - Maven Project<br>
    b. Language - Java<br>
    c. Spring Boot Version - 2.7.10<br>
    d. Package - WAR<br>
    e. Java Version - 8<br>
    f. Haz clic en **Add Dependencies** y selecciona **Spring Web**.

3. Haz clic en **Generate**.

4. Descomprime el proyecto y ábrelo en cualquier IDE de tu elección.

5. Ahora debes agregar los controladores necesarios al proyecto. Por ejemplo, crea un archivo llamado DemoController.java en el directorio del archivo Java principal de tu proyecto, y agrega el controlador especificado a continuación en el archivo.

package com.example.demo;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class DemoController {
    @GetMapping("/")
    public String index() {
        return "Greetings from Spring Boot WAR!";
    }
}

<br>

6. Ahora debes modificar el archivo pom.xml en tu proyecto para excluir el servidor Tomcat embebido al generar el archivo WAR, como se explicó en la descripción general. Puedes hacer esto agregando el fragmento que se proporciona a continuación en el encapsulado spring-boot-maven-plugin en el archivo XML:

<configuration>
<mainClass>${main_class_name}</mainClass>
<classifier>exec</classifier>
</configuration>

<br>

7. Puedes ejecutar esta aplicación en tu máquina local ejecutando el siguiente comando desde tu terminal:

./mvnw spring-boot:run

<br>

8. Puedes subir la aplicación a Catalyst con este comando:

./mvnw clean package

Esto generará el archivo WAR de la aplicación en la carpeta target.

9. Ahora puedes inicializar un servicio de AppSail en el mismo directorio desde el CLI o agregarlo en un directorio de proyecto existente. La fuente de la aplicación debe ser el directorio de tu aplicación. Proporciona los siguientes valores al inicializar el servicio de aplicación:

    **Stack:** Java 8 <br>
    **Platform:** Java WAR

10. Asegúrate de que el archivo WAR se agregue en el directorio de compilación que especifiques durante la inicialización. Catalyst comprimirá automáticamente tu archivo de aplicación durante el despliegue a la consola remota. 

11. Despliega el servicio de aplicación en la consola.    

<br>

Accede al servicio de aplicación desplegado desde su URL de endpoint.