Quickstarters
Comment construire un backend pour Android ?

46min
Introduction
Dans ce tutoriel, vous apprendrez à construire un backend complet pour une Android (Java) application en utilisant Back4App. 
Nous allons passer en revue l'intégration des fonctionnalités essentielles de Back4App—telles que la gestion de base de données, les fonctions Cloud Code, les API REST et GraphQL, l'authentification des utilisateurs, et les requêtes en temps réel (Live Queries)—pour créer un backend sécurisé, évolutif et robuste qui communique sans effort avec votre client Android.
Vous verrez également comment la configuration rapide et l'environnement intuitif de Back4App peuvent réduire considérablement le temps et les efforts par rapport à la configuration manuelle des serveurs et des bases de données. 
En cours de route, vous acquerrez une expérience pratique avec des fonctionnalités clés, y compris des fonctionnalités de sécurité avancées, la planification de tâches avec Cloud Jobs, et la configuration de webhooks pour des intégrations externes.
À la fin de ce tutoriel, vous serez bien préparé à améliorer cette configuration de base en une application prête pour la production, ou à incorporer facilement une logique personnalisée et des API tierces selon vos besoins.
Prérequis
Pour compléter ce tutoriel, vous aurez besoin de :
Un compte Back4App et un nouveau projet Back4App
Commencer avec Back4App.
Si vous n'avez pas de compte, vous pouvez en créer un gratuitement. Suivez le guide ci-dessus pour préparer votre projet.
Environnement de développement Android (Java) de base
Vous pouvez le configurer en utilisant Android Studio ou un outil similaire. Assurez-vous d'avoir installé la dernière version du SDK Android.
Java (version 8 ou supérieure)
Vous aurez besoin de Java pour compiler et exécuter votre projet Android.
Familiarité avec Java et les concepts de base d'Android
Documentation des développeurs Android.
Si vous êtes nouveau sur Android, consultez la documentation officielle ou un tutoriel pour débutants avant de commencer.
Assurez-vous d'avoir tous ces prérequis en place avant de commencer. Avoir votre projet Back4App configuré et votre environnement Android local prêt vous aidera à suivre plus facilement.
Étape 1 – Configuration du projet Back4app
Créer un nouveau projet
La première étape pour construire votre backend Android sur Back4App consiste à créer un nouveau projet. Si vous ne l'avez pas encore fait, suivez ces étapes :
Connectez-vous à votre compte Back4App.
Cliquez sur le bouton “Nouvelle application” dans votre tableau de bord Back4App.
Donnez un nom à votre application (par exemple, “Android-Backend-Tutorial”).
﻿
Une fois le projet créé, vous le verrez listé dans votre tableau de bord Back4App. Ce projet sera la base de toutes les configurations backend discutées dans ce tutoriel.
Connecter le SDK Parse
Back4App s'appuie sur la plateforme Parse pour gérer vos données, fournir des fonctionnalités en temps réel, gérer l'authentification des utilisateurs, et plus encore. Connecter votre application Android à Back4App implique d'installer le SDK Android Parse et de l'initialiser avec les identifiants de votre tableau de bord Back4App.
Récupérez vos clés Parse:
Dans votre tableau de bord Back4App, accédez à la section “Paramètres de l'application” ou “Sécurité & Clés” de votre application pour trouver votre ID d'application et Clé client (ou Clé JavaScript si indiqué). Vous trouverez également l' URL du serveur Parse (souvent au format https://parseapi.back4app.com).
﻿
Installez le SDK Parse dans votre projet Android en ajoutant ces lignes à votre 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 vous avez besoin du dépôt Jitpack dans votre root build.gradle:
Text
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
﻿
Initialisez Parse dans votre application Android:
Créez une classe Application personnalisée (par exemple, App.java) et configurez le 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()
        );
    }
}
﻿
Ensuite, ajoutez cette classe Application personnalisée dans votre 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>
﻿
En complétant cette étape, vous avez établi une connexion sécurisée entre votre front-end Android et le backend Back4App. Toutes les demandes et transactions de données sont acheminées de manière sécurisée via ce SDK, réduisant la complexité des appels REST ou GraphQL manuels (bien que vous puissiez toujours les utiliser si nécessaire).
Étape 2 – Configuration de la base de données
Sauvegarde et requête de données
Avec votre projet Back4App configuré et le SDK Parse intégré dans votre application Android, vous pouvez maintenant commencer à sauvegarder et à récupérer des données. Une manière typique de créer et de sauvegarder un enregistrement est d'utiliser la ParseObject classe :
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
    }
});
﻿
Pour interroger les données :
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
    }
});
﻿
Alternativement, vous pouvez utiliser les points de terminaison REST API de Back4App :
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 fournit également une interface 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
    }
  }
}
﻿
Ces options diverses vous permettent d'intégrer des opérations de données de la manière qui convient le mieux à votre processus de développement—que ce soit via le SDK Android de Parse, REST ou GraphQL.
Conception de schéma et types de données
Par défaut, Parse permet la création de schéma à la volée, mais vous pouvez également définir vos classes et types de données dans le tableau de bord Back4App pour plus de contrôle :
Accédez à la section “Base de données” dans votre tableau de bord Back4App.
Créez une nouvelle classe (par exemple, “GameScore”) et ajoutez des colonnes pertinentes.
Créer une nouvelle classe
﻿
Back4App prend également en charge divers types de données : Chaîne, Nombre, Booléen, Objet, Date, Fichier, Pointeur, Tableau, Relation, GeoPoint, et Polygone. Vous pouvez choisir le type approprié pour chaque champ.
Créer une colonne
﻿
Back4App propose un Agent IA qui peut vous aider à concevoir votre modèle de données :
Ouvrez l'Agent IA depuis votre tableau de bord d'application ou dans le menu.
Décrivez votre modèle de données dans un langage simple (par exemple, “Veuillez créer une nouvelle application ToDo avec un schéma de classe complet.”).
Laissez l'Agent IA créer le schéma pour vous.
﻿
Données relationnelles
Si vous avez des données relationnelles—disons, un Catégorie objet qui pointe vers plusieurs ScoreDeJeu objets—vous pouvez utiliser Pointeurs ou Relations dans Parse. Par exemple:
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
        }
    });
}
﻿
Lorsque vous interrogez, vous pouvez inclure des données de pointeur :
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
    }
});
﻿
Requêtes en direct
Pour des mises à jour en temps réel, Back4App fournit des Requêtes en direct. Vous pouvez vous abonner aux changements dans une classe spécifique depuis votre application Android :
Activer les Requêtes en direct dans votre tableau de bord Back4App sous les Paramètres du serveur de votre application.
Initialiser la Requête en direct dans votre code.
Dans Android, vous vous appuyez généralement sur la bibliothèque Parse LiveQuery Android pour vous abonner. Les étapes sont similaires à celles des autres plateformes, mais vous intégrerez 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"
}
﻿
Alors:
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;
    }
});
﻿
En vous abonnant, vous recevez des notifications en temps réel chaque fois qu'un nouvel enregistrement est créé, mis à jour ou supprimé. Cette fonctionnalité est particulièrement précieuse pour les applications collaboratives ou dynamiques où plusieurs utilisateurs doivent voir les dernières données sans actualiser la page.
Étape 3 – Application de la sécurité avec les ACL et les CLP
Mécanisme de sécurité Back4app
Back4App prend la sécurité au sérieux en fournissant des listes de contrôle d'accès (ACL) et des autorisations au niveau de la classe (CLP). Ces fonctionnalités vous permettent de restreindre qui peut lire ou écrire des données sur une base par objet ou par classe, garantissant que seuls les utilisateurs autorisés peuvent modifier vos données.
﻿
Listes de contrôle d'accès (ACL)
Un ACL est appliqué à des objets individuels pour déterminer quels utilisateurs, rôles ou le public peuvent effectuer des opérations de lecture/écriture. Par exemple :
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
        }
    });
}
﻿
Modifier l'ACL
﻿
Permissions au niveau de la classe (CLP)
Les CLP régissent les permissions par défaut d'une classe entière, telles que si la classe est lisible ou écrivable publiquement, ou si seuls certains rôles peuvent y accéder.
Allez sur votre tableau de bord Back4app, sélectionnez votre application et ouvrez la base de données section.
Sélectionnez une classe (par exemple, “GameScore”).
Ouvrez l'onglet des permissions au niveau de la classe.
Configurez vos paramètres par défaut.
﻿
Ces permissions définissent la base, tandis que les ACL affinent les permissions pour des objets individuels. Un modèle de sécurité robuste combine généralement à la fois les CLP (restrictions larges) et les ACL (restrictions fines par objet). Pour plus d'informations, allez sur Directives de sécurité de l'application.
Étape 4 – Écriture et déploiement des fonctions de code cloud
Pourquoi Cloud Code
Cloud Code est une fonctionnalité de l'environnement Parse Server qui vous permet d'exécuter du code JavaScript personnalisé côté serveur—sans avoir besoin de gérer vos serveurs ou votre infrastructure. En écrivant du Cloud Code, vous pouvez étendre votre backend Back4App avec une logique métier supplémentaire, des validations, des déclencheurs et des intégrations qui s'exécutent de manière sécurisée et efficace sur le Parse Server.
Fonction d'exemple
Une simple fonction Cloud Code qui calcule la longueur d'une chaîne de texte envoyée par le client :
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 };
});
﻿
Déploiement
Back4App CLI:
Tableau de bord:
Dans le tableau de bord de votre application, allez à Cloud Code > Fonctions. Copiez/collez votre code dans main.js et cliquez sur Déployer.
﻿
Appeler votre fonction
Depuis Android (Java) en utilisant le SDK 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
    }
});
﻿
Vous pouvez également l'appeler via REST ou GraphQL. Cette flexibilité vous permet d'intégrer votre logique personnalisée dans votre frontend Android ou tout autre client qui prend en charge REST ou GraphQL.
Étape 5 – Configuration de l'authentification des utilisateurs
Authentification des utilisateurs dans Back4app
Back4App utilise la classe Parse User comme base pour l'authentification. Par défaut, Parse gère le hachage des mots de passe, les jetons de session et le stockage sécurisé. Cela signifie que vous n'avez pas à configurer manuellement des flux de sécurité complexes.
Configuration de l'authentification des utilisateurs
Dans une application Android utilisant Java, vous pouvez créer un nouvel utilisateur :
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
    }
});
﻿
Connectez un utilisateur existant :
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
    }
});
﻿
Via REST, une connexion pourrait ressembler à :
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
﻿
Gestion de session
Après une connexion réussie, Parse crée un jeton de session stocké sur l'objet utilisateur. Vous pouvez vérifier l'utilisateur actuellement connecté :
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
}
﻿
Vous pouvez vous déconnecter :
Java
ParseUser.logOut();
ParseUser.logOut();
﻿
Intégration de la connexion sociale
Back4app et Parse peuvent s'intégrer avec des fournisseurs OAuth populaires comme Google ou Facebook. Par exemple, vous pouvez configurer la connexion Facebook en configurant l' Facebook App ID et en utilisant les Parse FacebookUtils dédiés pour Android. Les instructions détaillées varient, alors référez-vous à Documentation de connexion sociale.
Vérification par e-mail et réinitialisation du mot de passe
Pour activer la vérification par e-mail et la réinitialisation du mot de passe :
Accédez aux paramètres d'e-mail dans votre tableau de bord Back4App.
Activez la vérification par e-mail.
Configurez l'adresse d'expédition et les modèles d'e-mail.
Cela aide à garantir que l'e-mail de votre utilisateur est valide et fournit une méthode de récupération de mot de passe sécurisée.
Étape 6 – Gestion du stockage de fichiers
Téléchargement et récupération de fichiers
Parse inclut la ParseFile classe pour gérer les téléchargements de fichiers, que Back4app stocke en toute sécurité :
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
    }
});
﻿
Attachez le fichier à un objet :
Java
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
﻿
Récupérer l'URL du fichier :
Java
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
﻿
Sécurité des fichiers
Parse Server fournit des configurations flexibles pour gérer la sécurité du téléchargement de fichiers, y compris le contrôle de l'autorisation des utilisateurs anonymes ou authentifiés à télécharger des fichiers. Assurez-vous de consulter la documentation pour des configurations plus avancées.
Étape 7 – Vérification des e-mails et réinitialisation du mot de passe
Aperçu
Vérifier les e-mails garantit que les nouveaux utilisateurs possèdent l'adresse e-mail utilisée pour s'inscrire. Les réinitialisations de mot de passe permettent aux utilisateurs de récupérer leurs comptes en toute sécurité.
Configuration du tableau de bord Back4App
Activer la vérification par e-mail: Dans le tableau de bord de votre application, allez à Paramètres de messagerie.
Activer la réinitialisation du mot de passe: Configurez le flux d'e-mail de réinitialisation du mot de passe.
Code/Implémentation
Déclencher la réinitialisation du mot de passe 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
    }
});
﻿
Étape 8 – Planification des tâches avec des travaux cloud
Travaux Cloud
Utilisez Travaux Cloud dans Back4App pour planifier des tâches récurrentes, comme nettoyer les anciennes données ou envoyer des e-mails quotidiens. Exemple :
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
  // ...
});
﻿
Planifiez-le dans le Tableau de bord Back4App > Paramètres de l'application > Paramètres du serveur > Travaux en arrière-plan.
Planification d'un travail dans le cloud
﻿
Étape 9 – Intégration des Webhooks
Webhooks permettent à votre application Back4App d'envoyer des requêtes HTTP à un service externe chaque fois que certains événements se produisent, par exemple, envoyer des données à un service tiers comme Stripe.
Naviguez vers Webhooks dans votre tableau de bord Back4App > Plus > WebHooks.
Ajouter un Webhook avec votre point de terminaison externe.
Configurer les déclencheurs pour les événements pertinents.
Ajout d'un Webhook
﻿
Étape 10 – Exploration du panneau d'administration Back4App
L' Application d'administration Back4app est une interface de gestion basée sur le web conçue pour les utilisateurs non techniques. Elle permet des opérations CRUD rapides et une gestion de données de routine sans écrire de code.
Activation de l'application d'administration
Allez à Tableau de bord de l'application > Plus > Application d'administration et cliquez sur Activer l'application d'administration.
Activer l'application Admin
﻿
Créer un premier utilisateur administrateur et un sous-domaine, et vous aurez une interface web pour l'administration des données.
Conclusion
En suivant ce tutoriel complet, vous avez :
Créé un backend sécurisé pour une application Android (Java) sur Back4App.
Configuré une base de données avec des schémas de classe, des types de données et des relations.
Intégré des requêtes en temps réel (Requêtes en direct) pour des mises à jour immédiates des données.
Appliqué des mesures de sécurité en utilisant des ACL et des CLP pour protéger et gérer l'accès aux données.
Implémenté des fonctions Cloud Code pour exécuter une logique métier personnalisée côté serveur.
Mis en place l'authentification des utilisateurs avec prise en charge de la vérification par e-mail et des réinitialisations de mot de passe.
Géré les téléchargements de fichiers et la récupération, avec des contrôles de sécurité des fichiers en option.
Planifié des tâches Cloud pour des tâches d'arrière-plan automatisées.
Utilisé des Webhooks pour s'intégrer à des services externes.
Exploré le panneau d'administration Back4App pour la gestion des données.
Avec un frontend Android solide (Java) et un backend Back4App robuste, vous êtes maintenant bien équipé pour développer des applications riches en fonctionnalités, évolutives et sécurisées. Continuez à explorer des fonctionnalités plus avancées, intégrez votre logique métier et exploitez la puissance de Back4App pour vous faire gagner d'innombrables heures dans l'administration des serveurs et des bases de données. Bon codage !
Prochaines étapes
Construisez une application Android prête pour la production en étendant ce backend pour gérer des modèles de données plus complexes, des stratégies de mise en cache et des optimisations de performance.
Intégrez des fonctionnalités avancées telles que des flux d'authentification spécialisés, un contrôle d'accès basé sur les rôles ou des API externes (comme des passerelles de paiement).
Consultez la documentation officielle de Back4app pour des plongées plus profondes dans la sécurité avancée, l'optimisation des performances et l'analyse des journaux.
Explorez d'autres tutoriels sur les applications de chat en temps réel, les tableaux de bord IoT ou les services basés sur la localisation. Vous pouvez combiner les techniques apprises ici avec des API tierces pour créer des applications complexes et réelles.
﻿
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour Kotlin ?
Comment créer un backend pour Remix ?