Quickstarters
¿Cómo construir un backend para Spring Boot?

33min
Introducción
En este tutorial, aprenderás cómo construir un backend para Spring Boot utilizando Back4App.
Recorreremos la conexión de tu aplicación Spring Boot (una aplicación web basada en Java que aprovecha el marco de trabajo Spring) a las características esenciales de Back4App, como la gestión de bases de datos, Cloud Code, APIs REST y GraphQL, autenticación de usuarios, almacenamiento de archivos y consultas en tiempo real.
Siguiendo estos pasos, podrás integrar sin problemas la funcionalidad de Spring Boot con la poderosa Plataforma Parse proporcionada por Back4App.
Aprovechar Back4App como tu backend simplifica enormemente la conexión de tu base de datos, la configuración de seguridad y el proceso de implementación.
Te ahorra de las complejidades de la configuración del servidor y la administración manual de bases de datos, para que puedas concentrarte en escribir la lógica de negocio de tu aplicación Spring Boot.
Al final de este tutorial, tendrás un backend sólido y escalable que puede formar la base para tus aplicaciones web o aplicaciones Java que se ejecutan en Spring Web y expandirse fácilmente a implementaciones listas para producción.
Requisitos previos
Para completar esta guía, asegúrate de tener lo siguiente en su lugar:
Una cuenta de Back4App y un nuevo proyecto de Back4App
Comenzando con Back4app.
Regístrate gratis si no tienes una cuenta.
Un entorno de desarrollo Java
Necesitarás instalar Java SE 8 o superior y Maven o Gradle. Esto es esencial para configurar tu entorno de desarrollo.
Conceptos básicos de Spring Boot
Familiaridad con la creación de una aplicación spring boot. Si es necesario, consulta la Documentación oficial de Spring Boot para aprender sobre seguridad de spring, controladores, servicios y más.
Conocimientos básicos de Parse/Back4App
Conocer cómo funciona la plataforma Parse es beneficioso. Si eres nuevo, revisa la documentación de Back4App.
Tener estos requisitos previos listos asegura una experiencia de tutorial fluida. ¡Comencemos a construir tu backend usando Back4App!
Paso 1 – Crear un nuevo proyecto en Back4App y conectar
Por qué se necesita este paso
Crear un nuevo proyecto de Back4App es la base de tu backend. Esto contendrá tu base de datos, configuraciones, reglas de seguridad y te permitirá gestionar tus datos de la aplicación spring boot a través de la plataforma Parse.
Creando un Proyecto de Back4App
Inicia sesión en tu cuenta de Back4App.
Haz clic en “Nueva App” en tu panel de Back4App.
Proporciona un nombre para tu proyecto (por ejemplo, “SpringBoot-Backend-Tutorial”) y completa la configuración.
﻿
Una vez hecho, verás tu nuevo proyecto listado en el panel de Back4App.
Instalando y Configurando el SDK de Java de Parse (Opcional)
Back4App utiliza la Plataforma Parse, que proporciona un SDK de Java que puede integrarse con tu aplicación de Spring Boot. Si lo prefieres, también puedes hacer llamadas REST/GraphQL directamente desde tu código de desarrollador de java . Sin embargo, usar el SDK puede simplificar operaciones como el guardado de datos, consultas y autenticación de usuarios.
Dependencia de Maven (ejemplo):
XML
<dependency>
  <groupId>com.parse</groupId>
  <artifactId>parse</artifactId>
  <version>1.26.0</version>
</dependency>
<dependency>
  <groupId>com.parse</groupId>
  <artifactId>parse</artifactId>
  <version>1.26.0</version>
</dependency>
﻿
En tu Spring Boot clase principal de aplicación o en una clase de configuración, inicializa Parse:
Java
@SpringBootApplication
public class SpringBootBackendTutorialApplication {
    public static void main(String[] args) {
        // Initialize Parse before running the application
        Parse.initialize(new Parse.Configuration.Builder("YOUR_APP_ID")
            .server("https://parseapi.back4app.com/")
            .clientKey("YOUR_CLIENT_KEY")
            .build()
        );
        
        SpringApplication.run(SpringBootBackendTutorialApplication.class, args);
    }
}
@SpringBootApplication
public class SpringBootBackendTutorialApplication {
    public static void main(String[] args) {
        // Initialize Parse before running the application
        Parse.initialize(new Parse.Configuration.Builder("YOUR_APP_ID")
            .server("https://parseapi.back4app.com/")
            .clientKey("YOUR_CLIENT_KEY")
            .build()
        );
        
        SpringApplication.run(SpringBootBackendTutorialApplication.class, args);
    }
}
﻿
Asegúrate de reemplazar “YOUR_APP_ID” y “YOUR_CLIENT_KEY” con las credenciales que se encuentran en tu panel de Back4App. Puedes verlas en Configuración de la App o Seguridad y Claves.
Paso 2 – Configurando la Base de Datos
1. Creando un Modelo de Datos
Tu conexión a la base de datos es manejada por Back4App. Puedes crear modelos de datos (clases) en el panel de control o dejarlos ser creados sobre la marcha al guardar objetos a través del SDK de Parse. Para un mejor control, ve al Panel de Control de Back4App y:
Haz clic en “Base de datos”
Crea una Nueva Clase (por ejemplo, “Todo”)
Agrega columnas (campos) como título (String) y estáCompletado (Booleano)
Crear Nueva Clase
﻿
2. Creando un Modelo de Datos Usando el Agente de IA
Back4App ofrece un Agente de IA que puede generar un esquema para ti:
Abre el Agente de IA desde el Panel de Control o el menú.
Describe tu modelo de datos en lenguaje sencillo.
Deja que el Agente de IA maneje la creación de clases y campos relevantes.
﻿
3. Lectura y escritura de datos usando SDK
Si has añadido el SDK de Java de Parse a tu spring framework proyecto, puedes interactuar con las clases de la siguiente manera:
Java
@Service
public class TodoService {

    public ParseObject createTodoItem(String title, boolean isCompleted) throws ParseException {
        ParseObject todo = new ParseObject("Todo");
        todo.put("title", title);
        todo.put("isCompleted", isCompleted);
        return todo.save(); // Throws ParseException if something goes wrong
    }

    public List<ParseObject> fetchTodos() throws ParseException {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Todo");
        return query.find(); 
    }
}
@Service
public class TodoService {

    public ParseObject createTodoItem(String title, boolean isCompleted) throws ParseException {
        ParseObject todo = new ParseObject("Todo");
        todo.put("title", title);
        todo.put("isCompleted", isCompleted);
        return todo.save(); // Throws ParseException if something goes wrong
    }

    public List<ParseObject> fetchTodos() throws ParseException {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Todo");
        return query.find(); 
    }
}
﻿
4. Lectura y escritura de datos usando REST API
Alternativamente, puedes interactuar con la base de datos de Back4App a través de puntos finales REST:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
5. Lectura y Escritura de Datos usando la API de GraphQL
Back4App también tiene un endpoint de GraphQL:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
6. Trabajando con Consultas en Vivo (Opcional)
Si tus aplicaciones web necesitan actualizaciones en tiempo real, puedes habilitar Consultas en Vivo en el Panel de Control de Back4App y conectar tu aplicación spring web. Típicamente, te suscribirías a eventos en un cliente Java o usarías herramientas de front-end que soporten Consultas en Vivo.
Paso 3 – Aplicando Seguridad con ACLs y CLPs
Resumen Breve
Las ACLs (Listas de Control de Acceso) y CLPs (Permisos a Nivel de Clase) de Back4App protegen tus datos. Esto puede complementar o complementar la seguridad de spring para proteger aún más tu aplicación java.
Paso a Paso
Permisos a Nivel de Clase (CLPs): Configúralos en la pestaña “Base de Datos” bajo “Permisos a Nivel de Clase.”
ACLs: Establece permisos a nivel de objeto en el código o desde el panel.
﻿
Para más detalles, consulta las Directrices de Seguridad de la Aplicación.
Paso 4 – Escribiendo Funciones de Código en la Nube
Por qué Cloud Code
Cloud Code te permite mover o proteger lógica de negocios sensible en el servidor, ejecutándose en un entorno controlado. Esto es particularmente útil si deseas lógica que no debería estar expuesta en el lado del cliente o si deseas integrar APIs externas.
Ejemplo de Función
JS
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) throw new Error('No text provided');
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) throw new Error('No text provided');
  return { length: text.length };
});
﻿
Despliegue
Usa el Back4App CLI o el Dashboard de Back4App para desplegar tu código. Luego puedes llamar a la función directamente desde Spring Boot a través del SDK de Java, REST o GraphQL.
Paso 5 – Configurando la Autenticación
Autenticación de Usuario
La clase Parse User maneja el registro de usuarios, inicio de sesión y tokens de sesión. Puedes integrar esto en tu aplicación de spring boot llamando al SDK de Java o utilizando llamadas REST.
Registro (ejemplo de SDK de Java):
Java
public ParseUser signUpUser(String username, String password, String email) throws ParseException {
    ParseUser user = new ParseUser();
    user.setUsername(username);
    user.setPassword(password);
    user.setEmail(email);
    return user.signUp(); // returns the newly created user
}
public ParseUser signUpUser(String username, String password, String email) throws ParseException {
    ParseUser user = new ParseUser();
    user.setUsername(username);
    user.setPassword(password);
    user.setEmail(email);
    return user.signUp(); // returns the newly created user
}
﻿
Inicio de Sesión Social
Para proveedores como Google o Facebook, parse admite inicios de sesión basados en OAuth. Consulta la Documentación de Inicio de Sesión Social para detalles adicionales de configuración.
Paso 6 – Manejo del Almacenamiento de Archivos
Configurando el Almacenamiento de Archivos
Usa la ParseFile clase para subir archivos. O, puedes usar REST si lo prefieres:
Java
// Example using Java SDK
ParseFile file = new ParseFile("myImage.png", fileBytes);
file.save(); // uploads to Back4App

ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", file);
photo.save();
// Example using Java SDK
ParseFile file = new ParseFile("myImage.png", fileBytes);
file.save(); // uploads to Back4App

ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", file);
photo.save();
﻿
Ejemplo
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: text/plain" \
  --data-binary '@myImage.png' \
  https://parseapi.back4app.com/files/myImage.png
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: text/plain" \
  --data-binary '@myImage.png' \
  https://parseapi.back4app.com/files/myImage.png
﻿
Paso 7 – Verificación de Correo Electrónico y Restablecimiento de Contraseña
Descripción General
Para asegurar cuentas de usuario seguras en tu java developer flujo de trabajo, habilita la Verificación de Correo Electrónico y el Restablecimiento de Contraseña en tu panel de Back4App.
Configuración
Habilitar la Verificación de Correo Electrónico en la Configuración de Correo de tu aplicación.
Configurar plantillas de correo electrónico para una mejor experiencia del usuario.
Paso 8 – Programando Tareas con Cloud Jobs
Qué Hacen los Cloud Jobs
Trabajos en la Nube te permiten automatizar tareas como la limpieza periódica de datos, el envío de notificaciones diarias o el mantenimiento a nivel de sistema. Aquí hay un ejemplo de trabajo:
JS
Parse.Cloud.job('cleanupOldTodos', async () => {
  const query = new Parse.Query('Todo');
  // Example: remove todos older than 30 days
  // ...
  // implement the job logic here
});
Parse.Cloud.job('cleanupOldTodos', async () => {
  const query = new Parse.Query('Todo');
  // Example: remove todos older than 30 days
  // ...
  // implement the job logic here
});
﻿
Programalo desde tu panel de control de Back4App en Configuración del Servidor > Trabajos en Segundo Plano.
Programando un Trabajo en la Nube
﻿
Paso 9 – Integrando Webhooks
Definición y Configuración
Webhooks permiten que tu aplicación java envíe o reciba solicitudes HTTP impulsadas por eventos. Por ejemplo, puedes notificar a un servicio externo cada vez que se crea un objeto en tu base de datos de Back4App.
Ve al panel de control de Back4App > Más > WebHooks
Agregar Webhook con el endpoint objetivo
Configurar disparadores para eventos (crear, actualizar, eliminar)
Agregando un Webhook
﻿
Paso 10 – Explorando el Panel de Administración de Back4App
Dónde Encontrarlo
La Aplicación de Administración de Back4App es una interfaz centrada en el modelo, fácil de usar para los miembros del equipo no técnicos para ver y modificar datos. Ve a Panel de la Aplicación > Más > Aplicación de Administración para habilitarla.
Habilitar Aplicación de Administración
﻿
Elige un subdominio y crea tu primer usuario administrador. Luego inicia sesión para gestionar tus datos sin tocar código.
﻿
Conclusión
¡Felicidades por completar tu integración de Spring Boot con Back4App! Has visto cómo construir un backend para Spring Boot que gestiona datos, autenticación, archivos, suscripciones en tiempo real y trabajos programados, todo con un mínimo de sobrecarga.
Este enfoque robusto y escalable te permite concentrarte en escribir la lógica de negocio en lugar de preocuparte por los detalles de bajo nivel del servidor o la base de datos.
Tienes:
Creó un proyecto de Back4App y lo conectó a su marco de trabajo Spring.
Aprendió a gestionar la conexión de su base de datos con clases y modelos de datos.
Implementó ACLs, CLPs, funciones de Cloud Code y programación con Cloud Jobs.
Configuró el almacenamiento de archivos, la autenticación de usuarios y características avanzadas como webhooks.
Con estos fundamentos, su aplicación de Spring Boot está lista para crecer hacia un sistema listo para producción con seguridad de Spring completa o relaciones de datos más intrincadas.
Le animamos a explorar otras capacidades de Back4App y la característica de Spring Boot que acelera el desarrollo de aplicaciones web modernas.
Próximos Pasos
Escalar para Producción: Optimizar el rendimiento, agregar caché y configurar roles avanzados en CLPs.
Agregar Más Integraciones: Conectar a servicios externos (pasarelas de pago, análisis, etc.) a través de Cloud Code o Webhooks.
Consultar Documentación Oficial: Profundizar su comprensión de la documentación de Back4App y técnicas avanzadas de Parse.
Explorar Tutoriales: Buscar tutoriales especializados sobre chat en tiempo real, notificaciones push o servicios basados en ubicación. Combínelos con su configuración de Spring Boot para construir aplicaciones web, de vanguardia.
Al aprovechar la sinergia entre Spring Boot y Back4App, puede desarrollar, mantener y escalar rápidamente su aplicación Java mientras mantiene el código limpio y el proceso de implementación sencillo.
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para Play Framework?
¿Cómo construir un backend para Java?