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

47min
Introducción
En este tutorial, aprenderás a construir un backend completo para una Android (Java) aplicación utilizando Back4App. 
Recorreremos la integración de características esenciales de Back4App, como la gestión de bases de datos, funciones de Cloud Code, APIs REST y GraphQL, autenticación de usuarios y consultas en tiempo real (Live Queries), para crear un backend seguro, escalable y robusto que se comunique sin problemas con tu cliente de Android.
También verás cómo la configuración rápida de Back4App y su entorno intuitivo pueden reducir drásticamente el tiempo y el esfuerzo en comparación con la configuración manual de servidores y bases de datos. 
A lo largo del camino, obtendrás experiencia práctica con funcionalidades clave, incluyendo características de seguridad avanzadas, programación de tareas con Cloud Jobs y configuración de webhooks para integraciones externas.
Al final de este tutorial, estarás bien preparado para mejorar esta configuración básica en una aplicación lista para producción, o incorporar fácilmente lógica personalizada y APIs de terceros según sea necesario.
Requisitos previos
Para completar este tutorial, necesitarás:
Una cuenta de Back4App y un nuevo proyecto de Back4App
Introducción a Back4App.
Si no tienes una cuenta, puedes crear una de forma gratuita. Sigue la guía anterior para preparar tu proyecto.
Entorno de desarrollo básico de Android (Java)
Puedes configurarlo utilizando Android Studio o una herramienta similar. Asegúrate de tener instalado el SDK de Android más reciente.
Java (versión 8 o superior)
Necesitarás Java para compilar y ejecutar tu proyecto de Android.
Familiaridad con Java y conceptos básicos de Android
Documentación para desarrolladores de Android.
Si eres nuevo en Android, revisa la documentación oficial o un tutorial para principiantes antes de comenzar.
Asegúrate de tener todos estos requisitos previos en su lugar antes de comenzar. Tener tu proyecto de Back4App configurado y tu entorno local de Android listo te ayudará a seguir más fácilmente.
Paso 1 – Configuración del proyecto de Back4App
Crear un nuevo proyecto
El primer paso para construir tu backend de Android en Back4App es crear un nuevo proyecto. Si aún no has creado uno, sigue estos pasos:
Inicia sesión en tu cuenta de Back4App.
Haz clic en el botón “Nueva App” en tu panel de Back4App.
Dale un nombre a tu app (por ejemplo, “Android-Backend-Tutorial”).
﻿
Una vez que se crea el proyecto, lo verás listado en tu panel de Back4App. Este proyecto será la base para todas las configuraciones de backend discutidas en este tutorial.
Conectar el SDK de Parse
Back4App se basa en la Plataforma Parse para gestionar tus datos, proporcionar características en tiempo real, manejar la autenticación de usuarios y más. Conectar tu aplicación de Android a Back4App implica instalar el SDK de Android de Parse e inicializarlo con las credenciales de tu panel de Back4App.
Recupera tus claves de Parse:
En tu panel de Back4App, navega a la sección “Configuraciones de la App” o “Seguridad y Claves” de tu app para encontrar tu ID de Aplicación y Clave de Cliente (o Clave de JavaScript si se indica). También encontrarás la URL del Servidor de Parse (a menudo en el formato https://parseapi.back4app.com).
﻿
Instala el SDK de Parse en tu proyecto de Android añadiendo estas líneas a tu module-level build.gradle:
Text
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
﻿
Si necesitas el repositorio de Jitpack en tu root build.gradle:
Text
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
﻿
Inicializa Parse en tu aplicación de Android:
Crea una clase Application personalizada (por ejemplo, App.java) y configura el AndroidManifest.xml:
Java
package com.example.app;

import android.app.Application;
import com.parse.Parse;

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Parse.initialize(new Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")       // from Back4App
                .clientKey("YOUR_CLIENT_KEY")       // from Back4App
                .server("https://parseapi.back4app.com/")
                .build()
        );
    }
}
package com.example.app;

import android.app.Application;
import com.parse.Parse;

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Parse.initialize(new Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")       // from Back4App
                .clientKey("YOUR_CLIENT_KEY")       // from Back4App
                .server("https://parseapi.back4app.com/")
                .build()
        );
    }
}
﻿
Luego, añade esta clase Application personalizada en tu AndroidManifest.xml:
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application
        android:name=".App"
        ... >
        ...
    </application>
</manifest>
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application
        android:name=".App"
        ... >
        ...
    </application>
</manifest>
﻿
Al completar este paso, has establecido una conexión segura entre tu front-end de Android y el backend de Back4App. Todas las solicitudes y transacciones de datos se enrutan de forma segura a través de este SDK, reduciendo la complejidad de las llamadas manuales REST o GraphQL (aunque aún puedes usarlas cuando sea necesario).
Paso 2 – Configuración de la Base de Datos
Guardar y Consultar Datos
Con tu proyecto de Back4App configurado y el SDK de Parse integrado en tu aplicación de Android, ahora puedes comenzar a guardar y recuperar datos. Una forma típica de crear y guardar un registro es usar la ParseObject clase:
Java
ParseObject gameScore = new ParseObject("GameScore");
gameScore.put("score", 1337);
gameScore.put("playerName", "Sean Plott");
gameScore.put("cheatMode", false);
gameScore.saveInBackground(e -> {
    if (e == null) {
        // Success!
    } else {
        // Failed
    }
});
ParseObject gameScore = new ParseObject("GameScore");
gameScore.put("score", 1337);
gameScore.put("playerName", "Sean Plott");
gameScore.put("cheatMode", false);
gameScore.saveInBackground(e -> {
    if (e == null) {
        // Success!
    } else {
        // Failed
    }
});
﻿
Para consultar los datos:
Java
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.whereEqualTo("playerName", "Sean Plott");
query.findInBackground((objects, e) -> {
    if (e == null) {
        // objects now contains the results
    } else {
        // something went wrong
    }
});
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.whereEqualTo("playerName", "Sean Plott");
query.findInBackground((objects, e) -> {
    if (e == null) {
        // objects now contains the results
    } else {
        // something went wrong
    }
});
﻿
Alternativamente, puedes usar los puntos finales de la API REST:
Curl
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 '{"score": 1337, "playerName": "Sean Plott", "cheatMode": false}' \
  https://parseapi.back4app.com/classes/GameScore
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 '{"score": 1337, "playerName": "Sean Plott", "cheatMode": false}' \
  https://parseapi.back4app.com/classes/GameScore
﻿
Back4App también proporciona una interfaz GraphQL:
GraphQL
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
﻿
GraphQL
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
﻿
Estas diversas opciones te permiten integrar operaciones de datos de la manera que mejor se adapte a tu proceso de desarrollo, ya sea a través del SDK de Android de Parse, REST o GraphQL.
Diseño de Esquema y Tipos de Datos
Por defecto, Parse permite la creación de esquemas sobre la marcha, pero también puedes definir tus clases y tipos de datos en el panel de control de Back4App para tener más control:
Navega a la sección “Base de Datos” en tu panel de control de Back4App.
Crea una nueva clase (por ejemplo, “GameScore”) y añade columnas relevantes.
Crear Nueva Clase
﻿
Back4App también admite varios tipos de datos: Cadena, Número, Booleano, Objeto, Fecha, Archivo, Puntero, Array, Relación, GeoPoint, y Polígono. Puedes elegir el tipo apropiado para cada campo.
Crear Columna
﻿
Back4App ofrece un Agente de IA que puede ayudarte a diseñar tu modelo de datos:
Abre el Agente de IA desde tu panel de control de la aplicación o en el menú.
Describe tu modelo de datos en un lenguaje simple (por ejemplo, “Por favor, crea una nueva aplicación ToDo con un esquema de clase completo.”).
Deja que el Agente de IA cree el Esquema por ti.
﻿
Datos Relacionales
Si tienes datos relacionales—digamos, un Categoría objeto que apunta a múltiples GameScore objetos—puedes usar Punteros o Relaciones en Parse. Por ejemplo:
Java
// Linking a GameScore to a Category with a pointer
public void createGameScoreForCategory(String categoryObjectId, int scoreValue) {
    ParseObject gameScore = new ParseObject("GameScore");
    // Construct a pointer to the category
    ParseObject categoryPointer = ParseObject.createWithoutData("Category", categoryObjectId);
    // Set fields
    gameScore.put("score", scoreValue);
    gameScore.put("category", categoryPointer);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // Success
        } else {
            // Error
        }
    });
}
// Linking a GameScore to a Category with a pointer
public void createGameScoreForCategory(String categoryObjectId, int scoreValue) {
    ParseObject gameScore = new ParseObject("GameScore");
    // Construct a pointer to the category
    ParseObject categoryPointer = ParseObject.createWithoutData("Category", categoryObjectId);
    // Set fields
    gameScore.put("score", scoreValue);
    gameScore.put("category", categoryPointer);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // Success
        } else {
            // Error
        }
    });
}
﻿
Cuando consultas, puedes incluir datos de punteros:
Java
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.include("category");
query.findInBackground((scores, e) -> {
    if (e == null) {
        // scores now has category details
    }
});
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.include("category");
query.findInBackground((scores, e) -> {
    if (e == null) {
        // scores now has category details
    }
});
﻿
Consultas en Vivo
Para actualizaciones en tiempo real, Back4App proporciona Consultas en Vivo. Puedes suscribirte a cambios en una clase específica desde tu aplicación de Android:
Habilitar Consultas en Vivo en tu panel de Back4App bajo la Configuración del Servidor de tu aplicación.
Inicializar la Consulta en Vivo en tu código.
En Android, normalmente confías en la biblioteca Parse LiveQuery para Android para suscribirte. Los pasos son similares a otras plataformas, pero integrarás un LiveQueryClient:
Text
dependencies {
    implementation "com.github.parse-community:ParseLiveQuery-Android:latest.version.here"
}
dependencies {
    implementation "com.github.parse-community:ParseLiveQuery-Android:latest.version.here"
}
﻿
Entonces:
Java
LiveQueryClient liveQueryClient = new LiveQueryClient.Builder("wss://YOUR_SUBDOMAIN_HERE.b4a.io", 443)
        .build();
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
SubscriptionHandling<ParseObject> subscriptionHandling = liveQueryClient.subscribe(query);

subscriptionHandling.handleEvents((query1, event, gameScore) -> {
    switch (event) {
        case CREATE:
            // a new GameScore object was created
            break;
        case UPDATE:
            // existing GameScore updated
            break;
        case DELETE:
            // existing GameScore deleted
            break;
        default:
            break;
    }
});
LiveQueryClient liveQueryClient = new LiveQueryClient.Builder("wss://YOUR_SUBDOMAIN_HERE.b4a.io", 443)
        .build();
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
SubscriptionHandling<ParseObject> subscriptionHandling = liveQueryClient.subscribe(query);

subscriptionHandling.handleEvents((query1, event, gameScore) -> {
    switch (event) {
        case CREATE:
            // a new GameScore object was created
            break;
        case UPDATE:
            // existing GameScore updated
            break;
        case DELETE:
            // existing GameScore deleted
            break;
        default:
            break;
    }
});
﻿
Al suscribirte, recibes notificaciones en tiempo real cada vez que se crea, actualiza o elimina un nuevo registro. Esta función es particularmente valiosa para aplicaciones colaborativas o dinámicas donde múltiples usuarios necesitan ver los últimos datos sin refrescar la página.
Paso 3 – Aplicando Seguridad con ACLs y CLPs
Mecanismo de Seguridad de Back4app
Back4App toma la seguridad en serio al proporcionar Listas de Control de Acceso (ACLs) y Permisos a Nivel de Clase (CLPs). Estas características te permiten restringir quién puede leer o escribir datos a nivel de objeto o de clase, asegurando que solo los usuarios autorizados puedan modificar tus datos.
﻿
Listas de Control de Acceso (ACLs)
Un ACL se aplica a objetos individuales para determinar qué usuarios, roles o el público pueden realizar operaciones de lectura/escritura. Por ejemplo:
Java
public void createPrivateScore(int scoreValue, ParseUser ownerUser) {
    ParseObject gameScore = new ParseObject("GameScore");
    gameScore.put("score", scoreValue);
    ParseACL acl = new ParseACL(ownerUser);
    acl.setPublicReadAccess(false);
    acl.setPublicWriteAccess(false);
    gameScore.setACL(acl);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // success
        } else {
            // failed
        }
    });
}
public void createPrivateScore(int scoreValue, ParseUser ownerUser) {
    ParseObject gameScore = new ParseObject("GameScore");
    gameScore.put("score", scoreValue);
    ParseACL acl = new ParseACL(ownerUser);
    acl.setPublicReadAccess(false);
    acl.setPublicWriteAccess(false);
    gameScore.setACL(acl);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // success
        } else {
            // failed
        }
    });
}
﻿
Editar ACL
﻿
Permisos a Nivel de Clase (CLPs)
CLPs gobiernan los permisos predeterminados de toda una clase, como si la clase es legible o escribible públicamente, o si solo ciertos roles pueden acceder a ella.
Ve a tu Panel de Control de Back4app, selecciona tu aplicación y abre la Base de Datos sección.
Selecciona una clase (por ejemplo, “GameScore”).
Abre la pestaña de Permisos a Nivel de Clase. 
Configura tus predeterminados.
﻿
Estos permisos establecen la línea base, mientras que los ACL ajustan los permisos para objetos individuales. Un modelo de seguridad robusto combina típicamente tanto CLPs (restricciones amplias) como ACLs (restricciones detalladas por objeto). Para más información, ve a Directrices de Seguridad de la Aplicación.
Paso 4 – Escribir y Desplegar Funciones de Código en la Nube
Por qué Cloud Code
Cloud Code es una característica del entorno de Parse Server que te permite ejecutar código JavaScript personalizado en el lado del servidor, sin necesidad de gestionar tus servidores o infraestructura. Al escribir Cloud Code, puedes extender tu backend de Back4App con lógica de negocio adicional, validaciones, disparadores e integraciones que se ejecutan de manera segura y eficiente en el Parse Server.
Función de ejemplo
Una función simple de Cloud Code que calcula la longitud de una cadena de texto enviada desde el cliente:
main.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
Back4App CLI:
Tablero:
En el tablero de tu aplicación, ve a Cloud Code > Funciones. Copia/pega tu código en main.js y haz clic en Desplegar.
﻿
Llamando a tu función
Desde Android (Java) usando el SDK de Parse:
Java
HashMap<String, Object> params = new HashMap<>();
params.put("text", "Hello Back4App");
ParseCloud.callFunctionInBackground("calculateTextLength", params, (result, e) -> {
    if (e == null) {
        // result is a HashMap; get the length
        Map<?, ?> mapResult = (Map<?, ?>) result;
        Object lengthVal = mapResult.get("length");
        // cast to number, etc.
    } else {
        // handle error
    }
});
HashMap<String, Object> params = new HashMap<>();
params.put("text", "Hello Back4App");
ParseCloud.callFunctionInBackground("calculateTextLength", params, (result, e) -> {
    if (e == null) {
        // result is a HashMap; get the length
        Map<?, ?> mapResult = (Map<?, ?>) result;
        Object lengthVal = mapResult.get("length");
        // cast to number, etc.
    } else {
        // handle error
    }
});
﻿
También puedes llamarlo a través de REST o GraphQL. Esta flexibilidad te permite integrar tu lógica personalizada en tu frontend de Android o cualquier otro cliente que soporte REST o GraphQL.
Paso 5 – Configuración de la Autenticación de Usuario
Autenticación de Usuario en Back4app
Back4App aprovecha la Clase Parse User como base para la autenticación. Por defecto, Parse maneja el hash de contraseñas, tokens de sesión y almacenamiento seguro. Esto significa que no tienes que configurar flujos de seguridad complejos manualmente.
Configurando la Autenticación de Usuario
En una aplicación de Android usando Java, puedes crear un nuevo usuario:
Java
ParseUser user = new ParseUser();
user.setUsername("myUsername");
user.setPassword("myPassword");
user.setEmail("[email protected]");
user.signUpInBackground(e -> {
    if (e == null) {
        // Sign up success
    } else {
        // Sign up failed
    }
});
ParseUser user = new ParseUser();
user.setUsername("myUsername");
user.setPassword("myPassword");
user.setEmail("email@example.com");
user.signUpInBackground(e -> {
    if (e == null) {
        // Sign up success
    } else {
        // Sign up failed
    }
});
﻿
Iniciar sesión con un usuario existente:
Java
ParseUser.logInInBackground("myUsername", "myPassword", (parseUser, e) -> {
    if (e == null) {
        // Logged in successfully
    } else {
        // Login failed
    }
});
ParseUser.logInInBackground("myUsername", "myPassword", (parseUser, e) -> {
    if (e == null) {
        // Logged in successfully
    } else {
        // Login failed
    }
});
﻿
A través de REST, un inicio de sesión podría verse así:
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
﻿
Gestión de Sesiones
Después de un inicio de sesión exitoso, Parse crea un token de sesión almacenado en el objeto de usuario. Puedes verificar el usuario que ha iniciado sesión actualmente:
Java
ParseUser currentUser = ParseUser.getCurrentUser();
if (currentUser != null) {
    // user is logged in
} else {
    // no user is logged in
}
ParseUser currentUser = ParseUser.getCurrentUser();
if (currentUser != null) {
    // user is logged in
} else {
    // no user is logged in
}
﻿
Puedes cerrar sesión:
Java
ParseUser.logOut();
ParseUser.logOut();
﻿
Integración de Inicio de Sesión Social
Back4app y Parse pueden integrarse con proveedores de OAuth populares como Google o Facebook. Por ejemplo, puedes configurar el inicio de sesión de Facebook configurando el Facebook App ID y utilizando Parse FacebookUtils dedicados para Android. Las instrucciones detalladas varían, así que consulta Documentación de Inicio de Sesión Social.
Verificación de Correo Electrónico y Restablecimiento de Contraseña
Para habilitar la verificación de correo electrónico y el restablecimiento de contraseña:
Navega a la Configuración de Correo Electrónico en tu panel de Back4App.
Habilita la verificación de correo electrónico.
Configura la dirección del remitente y las plantillas de correo electrónico.
Esto ayuda a asegurar que el correo electrónico de tu usuario sea válido y proporciona un método seguro de recuperación de contraseña.
Paso 6 – Manejo del Almacenamiento de Archivos
Subiendo y Recuperando Archivos
Parse incluye la clase ParseFile para manejar las subidas de archivos, que Back4app almacena de forma segura:
Java
File file = new File("/path/to/image.jpg");
byte[] data = ... // read file as bytes
ParseFile parseFile = new ParseFile("image.jpg", data);
parseFile.saveInBackground(e -> {
    if (e == null) {
        // File saved
    } else {
        // error
    }
});
File file = new File("/path/to/image.jpg");
byte[] data = ... // read file as bytes
ParseFile parseFile = new ParseFile("image.jpg", data);
parseFile.saveInBackground(e -> {
    if (e == null) {
        // File saved
    } else {
        // error
    }
});
﻿
Adjuntar el archivo a un objeto:
Java
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
﻿
Recuperar la URL del archivo:
Java
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
﻿
Seguridad de Archivos
Parse Server proporciona configuraciones flexibles para gestionar la seguridad de la carga de archivos, incluyendo el control sobre si los usuarios anónimos o autenticados pueden cargar archivos. Asegúrate de consultar la documentación para configuraciones más avanzadas.
Paso 7 – Verificación de Correo Electrónico y Restablecimiento de Contraseña
Descripción General
Verificar correos electrónicos asegura que los nuevos usuarios son propietarios de la dirección de correo electrónico utilizada para registrarse. Los restablecimientos de contraseña permiten a los usuarios recuperar sus cuentas de manera segura.
Configuración del Panel de Control de Back4App
Habilitar verificación de correo electrónico: En el Panel de Control de tu aplicación, ve a Configuraciones de Correo Electrónico.
Habilitar restablecimiento de contraseña: Configura el flujo de correo electrónico para el restablecimiento de contraseña.
Código/Implementación
Activar el restablecimiento de contraseña en Java:
Java
ParseUser.requestPasswordResetInBackground("[email protected]", e -> {
    if (e == null) {
        // Email sent
    } else {
        // Something went wrong
    }
});
ParseUser.requestPasswordResetInBackground("email@example.com", e -> {
    if (e == null) {
        // Email sent
    } else {
        // Something went wrong
    }
});
﻿
Paso 8 – Programación de Tareas con Cloud Jobs
Cloud Jobs
Usa Cloud Jobs en Back4App para programar tareas recurrentes, como limpiar datos antiguos o enviar correos electrónicos diarios. Ejemplo:
JS
Parse.Cloud.job('cleanupOldScores', async (request) => {
  const GameScore = Parse.Object.extend('GameScore');
  const query = new Parse.Query(GameScore);
  // e.g., remove scores older than 30 days
  // ...
});
Parse.Cloud.job('cleanupOldScores', async (request) => {
  const GameScore = Parse.Object.extend('GameScore');
  const query = new Parse.Query(GameScore);
  // e.g., remove scores older than 30 days
  // ...
});
﻿
Programarlo en el Panel de Control de Back4App > Configuraciones de la Aplicación > Configuraciones del Servidor > Tareas en Segundo Plano.
Programando un trabajo en la nube
﻿
Paso 9 – Integrando Webhooks
Webhooks permiten que tu aplicación Back4App envíe solicitudes HTTP a un servicio externo cada vez que ocurren ciertos eventos, por ejemplo, enviar datos a un servicio de terceros como Stripe.
Navega a Webhooks en tu panel de control de Back4App > Más > WebHooks.
Agregar Webhook con tu endpoint externo.
Configurar disparadores para eventos relevantes.
Agregando un Webhook
﻿
Paso 10 – Explorando el Panel de Administración de Back4App
La Aplicación de Administración de Back4app es una interfaz de gestión basada en la web diseñada para usuarios no técnicos. Permite operaciones CRUD rápidas y gestión de datos rutinaria sin necesidad de escribir código.
Habilitando la Aplicación de Administración
Ve a Panel de la Aplicación > Más > Aplicación de Administración y haz clic en Habilitar Aplicación de Administración.
Habilitar la aplicación de administración
﻿
Crear un primer usuario administrador y subdominio, y tendrás una interfaz web para la administración de datos.
Conclusión
Siguiendo este tutorial completo, has:
Creado un backend seguro para una aplicación Android (Java) en Back4App.
Configurado una base de datos con esquemas de clase, tipos de datos y relaciones.
Integrado consultas en tiempo real (Consultas en vivo) para actualizaciones de datos inmediatas.
Aplicado medidas de seguridad utilizando ACLs y CLPs para proteger y gestionar el acceso a los datos.
Implementado Cloud Code funciones para ejecutar lógica de negocio personalizada en el lado del servidor.
Configurado la autenticación de usuarios con soporte para verificación de correo electrónico y restablecimiento de contraseñas.
Gestionado cargas de archivos y recuperación, con controles de seguridad de archivos opcionales.
Programado trabajos en la nube para tareas automatizadas en segundo plano.
Usado Webhooks para integrarse con servicios externos.
Explorado el panel de administración de Back4App para la gestión de datos.
Con un sólido frontend de Android (Java) y un robusto backend de Back4App, ahora estás bien equipado para desarrollar aplicaciones ricas en funciones, escalables y seguras. Continúa explorando funcionalidades más avanzadas, integra tu lógica de negocio y aprovecha el poder de Back4App para ahorrarte innumerables horas en la administración de servidores y bases de datos. ¡Feliz codificación!
Próximos Pasos
Construye una aplicación de Android lista para producción extendiendo este backend para manejar modelos de datos más complejos, estrategias de caché y optimizaciones de rendimiento.
Integra características avanzadas como flujos de autenticación especializados, control de acceso basado en roles o APIs externas (como pasarelas de pago).
Consulta la documentación oficial de Back4app para profundizar en seguridad avanzada, ajuste de rendimiento y análisis de registros.
Explora otros tutoriales sobre aplicaciones de chat en tiempo real, paneles de IoT o servicios basados en ubicación. Puedes combinar las técnicas aprendidas aquí con APIs de terceros para crear aplicaciones complejas del mundo real.
﻿
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para Kotlin?
Cómo construir un backend para Remix.