Iniciadores Rápidos
¿Cómo construir un backend para Play Framework?

37min
Introducción
En este tutorial, aprenderás cómo construir un backend completo para el Play Framework utilizando Back4App.
Recorreremos características esenciales para backends de servidor, incluyendo configuración, gestión de bases de datos, funciones de Cloud Code, APIs REST y GraphQL, autenticación de usuarios, almacenamiento de archivos y consultas en tiempo real.
Verás cómo Back4App simplifica el proceso de configuración, escalado y mantenimiento de un backend de aplicación web, permitiéndote concentrarte en tu código de Play Framework.
Al aprender a construir un backend para Play Framework con Back4App, reducirás el tiempo de desarrollo y minimizarás los dolores de cabeza de operaciones de desarrollo.
También agregarás características robustas como inicio de sesión social, programación de tareas (Cloud Jobs) y webhooks. Una vez que completes esto, podrás extender el sistema a una solución de grado de producción, integrando características más avanzadas según sea necesario.
Cuando termines, tendrás un sólido plano para crear tu próxima aplicación web escalable y segura con Play Framework.
Estarás listo para profundizar en mejoras de rendimiento, integraciones u optimizaciones en modo de desarrollo para manejar demandas del mundo real.
Requisitos previos
Para completar este tutorial, necesitarás:
Una cuenta de Back4App y un nuevo proyecto de Back4App
Comenzando con Back4App.
Si no tienes una cuenta, puedes crear una gratis. Sigue la guía anterior para preparar tu proyecto.
Un entorno de Play Framework en funcionamiento
Asegúrate de tener Java 8+ instalado.
Instala sbt o usa sbt a través de tu IDE.
Conocimientos básicos de Play Framework
Consulta la Documentación de Play si necesitas repasar los fundamentos.
Familiaridad con REST o GraphQL
Esto te ayudará a interactuar con Back4App, especialmente si decides no usar o si no puedes usar el SDK de Parse directamente.
Asegúrate de tener estos requisitos previos en su lugar antes de comenzar. Tener tu proyecto de Back4App configurado y tu entorno de Play Framework listo te ayudará a seguir sin problemas.
Paso 1 – Crear un nuevo proyecto en Back4App y conectar
Por qué necesitas un nuevo proyecto de Back4App
Un nuevo proyecto de Back4App es la columna vertebral de tu backend porque gestiona los datos de tu aplicación, la autenticación y la lógica en la nube. Ya sea que estés construyendo un pequeño prototipo o una aplicación web a gran escala, es fácil conectar tu aplicación de Play Framework a un nuevo proyecto de Back4App.
Creando un proyecto de Back4App
Inicia sesión en tu cuenta de Back4App.
Haz clic en “Nueva App” en tu panel de Back4App.
Nombra tu app, por ejemplo, “Play-Framework-Backend”.
﻿
Una vez creado, tu nuevo proyecto aparecerá en el panel.
Conectando con Back4App
Back4App aprovecha Parse Server. Si tu aplicación de Play Framework planea interactuar con Back4App a través del SDK de Java de Parse, puedes agregarlo a tu build.sbt si es necesario. De lo contrario, puedes usar puntos finales REST o GraphQL.
Recupera tus claves de Parse:
En tu panel de Back4App, abre Configuración de la App o Seguridad y Claves para encontrar tu ID de Aplicación, Clave API REST, Clave de JavaScript (si usas llamadas del front-end), o Clave de Cliente, además de la URL del Servidor (generalmente https://parseapi.back4app.com).
﻿
Usando el SDK de Java/Parse (Opcional):
Si deseas una integración directa del lado del servidor usando el SDK de Parse, agrega una dependencia en tu build.sbt:
Text
libraryDependencies += "com.parse" % "parse" % "1.0.40" // Example version
libraryDependencies += "com.parse" % "parse" % "1.0.40" // Example version
﻿
Luego, en tu código de Play Framework, puedes inicializar Parse:
Text
object ParseConfig {
  def init(): Unit = {
    Parse.initialize(new Parse.Configuration.Builder("YOUR_APP_ID")
      .server("https://parseapi.back4app.com")
      .clientKey("YOUR_CLIENT_KEY")
      .build()
    )
  }
}
object ParseConfig {
  def init(): Unit = {
    Parse.initialize(new Parse.Configuration.Builder("YOUR_APP_ID")
      .server("https://parseapi.back4app.com")
      .clientKey("YOUR_CLIENT_KEY")
      .build()
    )
  }
}
﻿
Puedes colocar esto en tu Global.scala o llamarlo desde un punto de inicialización adecuado. Esto te prepara para la interacción directa con tu proyecto de Back4App.
Si lo prefieres, utiliza los endpoints REST o GraphQL para operaciones de datos, especialmente si deseas más control sobre tus solicitudes HTTP o si estás construyendo microservicios.
Paso 2 – Configurando la Base de Datos
El servicio de almacenamiento de datos de Back4App admite una amplia gama de tipos de datos y creación de esquemas dinámicos. Esto te permite almacenar los datos de tu aplicación Play con un mínimo de complicaciones.
Creando un Modelo de Datos
Abre la sección “Base de datos” en tu panel de control de Back4App.
Crea una nueva clase (por ejemplo, “Todo”) y agrega columnas (por ejemplo, título como String, isCompleted como Boolean).
Guarda para finalizar el esquema de tu base de datos.
Crear Nueva Clase
﻿
Creando un Modelo de Datos con el Agente de IA
Si deseas definir rápidamente tu estructura de datos:
Abre el Agente de IA en tu panel de control de la aplicación.
Describe tu modelo de datos deseado en lenguaje sencillo (por ejemplo, “Crea un modelo de ToDo simple.”).
El agente genera el esquema automáticamente para ti.
﻿
Lectura y escritura de datos utilizando el SDK de Parse (Opcional)
Si has elegido incluir el SDK de Java de Parse en tu aplicación de Play Framework, puedes guardar y consultar datos:
Text
import com.parse.{ParseObject, ParseQuery}

object TodoService {
  def createTodo(title: String, isCompleted: Boolean): Either[Throwable, ParseObject] = {
    try {
      val todo = new ParseObject("Todo")
      todo.put("title", title)
      todo.put("isCompleted", isCompleted)
      Right(todo.save())
    } catch {
      case e: Throwable => Left(e)
    }
  }

  def fetchTodos(): Either[Throwable, java.util.List[ParseObject]] = {
    try {
      val query = ParseQuery.getQuery("Todo")
      val results = query.find()
      Right(results)
    } catch {
      case e: Throwable => Left(e)
    }
  }
}
import com.parse.{ParseObject, ParseQuery}

object TodoService {
  def createTodo(title: String, isCompleted: Boolean): Either[Throwable, ParseObject] = {
    try {
      val todo = new ParseObject("Todo")
      todo.put("title", title)
      todo.put("isCompleted", isCompleted)
      Right(todo.save())
    } catch {
      case e: Throwable => Left(e)
    }
  }

  def fetchTodos(): Either[Throwable, java.util.List[ParseObject]] = {
    try {
      val query = ParseQuery.getQuery("Todo")
      val results = query.find()
      Right(results)
    } catch {
      case e: Throwable => Left(e)
    }
  }
}
﻿
Lectura y escritura de datos utilizando REST
Puedes enviar solicitudes HTTP desde tus controladores o servicios de Play Framework:
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
﻿
Lectura y escritura de datos utilizando GraphQL
Back4App también proporciona una API 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
    }
  }
}
﻿
Esto es útil si estás construyendo microservicios o quieres una API flexible para tus clientes de front-end.
Trabajando con Consultas en Vivo
Si tu aplicación web necesita datos en tiempo real, habilita Consultas en Vivo:
Habilitar Consultas en Vivo en el panel de control de Back4App bajo Configuración del Servidor.
Configura tu suscripción en el código. Si usas el SDK de Parse o código personalizado, asegúrate de configurar el liveQueryServerURL.
Suscribirse a cambios para clases como “Todo.”
Paso 3 – Aplicando Seguridad con ACLs y CLPs
Descripción General de ACLs y CLPs
Back4App proporciona Listas de Control de Acceso (ACLs) para seguridad a nivel de objeto y Permisos a Nivel de Clase (CLPs) para restricciones amplias. Esto ayuda a mantener seguros tus servidores y asegura que solo ocurran operaciones autorizadas.
﻿
Permisos a Nivel de Clase
En la sección de Base de Datos de tu panel de control de Back4App:
Selecciona una clase (por ejemplo, “Todo”).
Abre CLPs para limitar la lectura/escritura a usuarios autenticados, roles o al público.
Configura según sea necesario (por ejemplo, “Requiere Autenticación” para cualquier escritura).
ACLs
Las ACL protegen objetos individuales. Por ejemplo, puedes asegurarte de que solo un usuario particular pueda leer o escribir un registro específico. Si estás utilizando el SDK de Parse desde código Scala:
Text
import com.parse.{ParseACL, ParseUser, ParseObject}

def createPrivateTodo(title: String, owner: ParseUser): ParseObject = {
  val todo = new ParseObject("Todo")
  todo.put("title", title)

  val acl = new ParseACL(owner)
  acl.setPublicReadAccess(false)
  acl.setPublicWriteAccess(false)

  todo.setACL(acl)
  todo.save()
  todo
}
import com.parse.{ParseACL, ParseUser, ParseObject}

def createPrivateTodo(title: String, owner: ParseUser): ParseObject = {
  val todo = new ParseObject("Todo")
  todo.put("title", title)

  val acl = new ParseACL(owner)
  acl.setPublicReadAccess(false)
  acl.setPublicWriteAccess(false)

  todo.setACL(acl)
  todo.save()
  todo
}
﻿
Paso 4 – Escribiendo Funciones de Cloud Code
Por qué Cloud Code
Cloud Code te permite ejecutar lógica personalizada en los servidores de Back4App, añadiendo reglas de negocio o validaciones antes o después de las transacciones de datos. No necesitarás manejar tu propia provisión de servidores o reinicios en modo de desarrollo para implementar tales funciones.
Función de Ejemplo
JS
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Puedes llamar a esto desde tu aplicación Play a través de REST, GraphQL, o si usas el SDK de Parse, directamente.
Despliegue
Usa el Back4App CLI o el panel de control:
Instalar el CLI (ejemplo de Linux/MacOS):
Configurar la clave de cuenta:
Desplegar:
O desplegar a través del Panel de Control pegando tu función en Cloud Code > Functions y presionando “Desplegar”.
Uso de Módulos NPM
Cloud Code soporta módulos NPM. Por ejemplo, si necesitas un cliente HTTP como axios:
JS
const axios = require('axios');
Parse.Cloud.define('fetchData', async (req) => {
  const response = await axios.get(req.params.url);
  return response.data;
});
const axios = require('axios');
Parse.Cloud.define('fetchData', async (req) => {
  const response = await axios.get(req.params.url);
  return response.data;
});
﻿
Paso 5 – Configuración de la Autenticación
Habilitando la Autenticación de Usuarios
Back4App utiliza la Parse.User clase para el registro, inicio de sesión y gestión de sesiones. En tu configuration setting, asegúrate de activar “Habilitar Verificación de Correo Electrónico” y “Habilitar Restablecimiento de Contraseña” si lo deseas.
Código de Ejemplo (Parse SDK)
Text
import com.parse.{ParseUser}

object AuthService {
  def signUpUser(username: String, password: String, email: String): Either[Throwable, ParseUser] = {
    try {
      val user = new ParseUser()
      user.setUsername(username)
      user.setPassword(password)
      user.setEmail(email)

      Right(user.signUp())
    } catch {
      case e: Throwable => Left(e)
    }
  }

  def logInUser(username: String, password: String): Either[Throwable, ParseUser] = {
    try {
      Right(ParseUser.logIn(username, password))
    } catch {
      case e: Throwable => Left(e)
    }
  }
}
import com.parse.{ParseUser}

object AuthService {
  def signUpUser(username: String, password: String, email: String): Either[Throwable, ParseUser] = {
    try {
      val user = new ParseUser()
      user.setUsername(username)
      user.setPassword(password)
      user.setEmail(email)

      Right(user.signUp())
    } catch {
      case e: Throwable => Left(e)
    }
  }

  def logInUser(username: String, password: String): Either[Throwable, ParseUser] = {
    try {
      Right(ParseUser.logIn(username, password))
    } catch {
      case e: Throwable => Left(e)
    }
  }
}
﻿
Inicio de Sesión Social
Si necesitas inicios de sesión sociales (Google, Apple o Facebook), configúralos en tu panel de Back4App. Parse proporciona métodos de utilidad o puedes confiar en flujos estándar de OAuth, dependiendo de tus necesidades y enfoque.
Paso 6 – Manejo del Almacenamiento de Archivos
Back4App almacena archivos a través de Parse.File. Desde Play Framework, puedes subir con REST o Parse SDK.
Text
// Example with Parse SDK
import com.parse.{ParseFile, ParseObject}
import java.nio.file.{Files, Paths}

def uploadImage(filePath: String): Either[Throwable, String] = {
  try {
    val data = Files.readAllBytes(Paths.get(filePath))
    val parseFile = new ParseFile("myImage.jpg", data)
    parseFile.save()
    Right(parseFile.getUrl)
  } catch {
    case e: Throwable => Left(e)
  }
}
// Example with Parse SDK
import com.parse.{ParseFile, ParseObject}
import java.nio.file.{Files, Paths}

def uploadImage(filePath: String): Either[Throwable, String] = {
  try {
    val data = Files.readAllBytes(Paths.get(filePath))
    val parseFile = new ParseFile("myImage.jpg", data)
    parseFile.save()
    Right(parseFile.getUrl)
  } catch {
    case e: Throwable => Left(e)
  }
}
﻿
Consideraciones de Seguridad: Puedes configurar los permisos de carga de archivos (habilitar para público, anónimo o autenticado) en la configuración del servidor Back4App.
Paso 7 – Verificación de Correo Electrónico y Restablecimiento de Contraseña
Navega a Configuración de Correo Electrónico en el panel de control de Back4App.
Habilita la verificación de correo electrónico y configura las plantillas de correo electrónico para restablecimientos de contraseña.
En tu aplicación Play, puedes llamar a:
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: application/json" \
  -d '{"email":"[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Esto hará que Back4App envíe instrucciones para restablecer la contraseña al correo electrónico del usuario.
Paso 8 – Programación de Tareas con Cloud Jobs
Cloud Jobs
Si necesitas un tarea de inicio para trabajos en segundo plano (por ejemplo, limpiar datos o generar informes), puedes programar Cloud Jobs en Back4App.
JS
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
Programación:
Despliega tu Cloud Code.
En Configuración de la Aplicación > Configuración del Servidor > Trabajos en Segundo Plano, programa el trabajo para que se ejecute diariamente, semanalmente o según sea necesario.
Programación de un Cloud Job
﻿
Paso 9 – Integrando Webhooks
Si deseas notificar a servicios externos cada vez que los datos cambian, configura Webhooks en Back4App.
Ve a Más > WebHooks en tu panel de control de Back4App.
Agregar Webhook con un endpoint (por ejemplo, Slack o Stripe).
Elige desencadenadores, como “Nuevo registro en la clase Todo.”
Agregando un Webhook
﻿
También puedes crear Webhooks en desencadenadores de Cloud Code, haciendo solicitudes HTTP directas a servicios de terceros.
Webhook BeforeSave
﻿
Paso 10 – Explorando el Panel de Administración de Back4App
El Back4App Admin App es una interfaz fácil de usar para la gestión de datos y registros. Los usuarios no técnicos pueden manejar operaciones CRUD sin profundizar en el código.
Habilitando la Admin App
Ve a App Dashboard > Más > Admin App.
Habilítalo y crea un usuario administrador.
Elige un subdominio para un acceso conveniente.
Habilitar Admin App
﻿
Una vez que inicies sesión, puedes gestionar las entradas de datos sin complicarte con los paneles de control de nivel inferior o herramientas de CLI.
﻿
Conclusión
¡Felicidades! Has aprendido cómo construir un backend para Play Framework utilizando los servicios de Back4App. A lo largo de este tutorial, has:
Creado un backend seguro para una aplicación de Play Framework en Back4App.
Configurado una base de datos, incluyendo diseño de esquema, relaciones y consultas en tiempo real.
Aplicado ACLs y CLPs para acceso seguro a los datos.
Escrito Cloud Code para lógica personalizada, disparadores e integraciones externas.
Configurado la autenticación de usuarios, inicio de sesión social y restablecimientos de contraseña.
Manejado cargas de archivos y añadido seguridad opcional para archivos.
Programado tareas en segundo plano con Cloud Jobs.
Integrado con servicios de terceros a través de Webhooks.
Explorado el Panel de Administración de Back4App para una gestión de datos simplificada.
Con estas herramientas en su lugar, puedes optimizar el modo de desarrollo, escalar según sea necesario y construir aplicaciones web robustas en el Play Framework. 
Adopta más integraciones, ajuste de rendimiento y medidas de seguridad avanzadas para llevar tus backends de servidor al siguiente nivel.
Próximos Pasos
Mejora tu configuración de producción con herramientas de caché, registro o monitoreo.
Explora la seguridad avanzada con controles de acceso basados en roles o configuraciones de confianza cero.
Integra pasarelas de pago u otras API de terceros para comercio o análisis.
Consulta la documentación oficial de Back4App para obtener información más profunda sobre rendimiento y solución de problemas.
Revisa más tutoriales sobre aplicaciones de chat en tiempo real, soluciones IoT o servicios basados en ubicación, muchos de los cuales se basan en las técnicas de esta guía.
﻿
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para Elixir?
¿Cómo construir un backend para Spring Boot?