Quickstarters
Comment construire un backend pour le framework Play ?

37min
Introduction
Dans ce tutoriel, vous apprendrez à construire un backend complet pour le Play Framework en utilisant Back4App.
Nous passerons en revue les fonctionnalités essentielles pour les backends de serveur, y compris la configuration, la gestion de base de données, les fonctions Cloud Code, les API REST et GraphQL, l'authentification des utilisateurs, le stockage de fichiers et les requêtes en temps réel.
Vous verrez comment Back4App simplifie le processus de configuration, de mise à l'échelle et de maintenance d'un backend d'application web tout en vous permettant de vous concentrer sur votre code Play Framework.
En apprenant à construire un backend pour Play Framework avec Back4App, vous réduirez le temps de développement et minimiserez les maux de tête liés aux opérations de développement.
Vous ajouterez également des fonctionnalités robustes telles que la connexion sociale, la planification de tâches (Cloud Jobs) et les webhooks. Une fois que vous aurez terminé cela, vous pourrez étendre le système en une solution de niveau production, en intégrant des fonctionnalités plus avancées selon les besoins.
Lorsque vous aurez terminé, vous disposerez d'un plan solide pour créer votre prochaine application web Play Framework évolutive et sécurisée.
Vous serez prêt à plonger plus profondément dans les améliorations de performance, les intégrations ou les optimisations en mode développement pour répondre aux exigences du monde réel.
Conditions préalables
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.
Un environnement Play Framework fonctionnel
Assurez-vous d'avoir Java 8+ installé.
Installez sbt ou utilisez sbt via votre IDE.
Connaissances de base du Play Framework
Référez-vous à la Documentation Play si vous avez besoin de revoir les fondamentaux.
Familiarité avec REST ou GraphQL
Cela vous aidera à interagir avec Back4App, surtout si vous décidez de ne pas utiliser ou si vous ne pouvez pas utiliser le SDK Parse directement.
Assurez-vous d'avoir ces conditions préalables en place avant de commencer. Avoir votre projet Back4App configuré et votre environnement Play Framework prêt vous aidera à suivre facilement.
Étape 1 – Création d'un nouveau projet sur Back4App et connexion
Pourquoi vous avez besoin d'un nouveau projet Back4App
Un nouveau projet Back4App est la colonne vertébrale de votre backend car il gère les données de votre application, l'authentification et la logique cloud. Que vous construisiez un petit prototype ou une application web à grande échelle, il est facile de connecter votre application Play Framework à un nouveau projet Back4App.
Création d'un projet Back4App
Connectez-vous à votre compte Back4App.
Cliquez sur “Nouvelle application” dans votre tableau de bord Back4App.
Nommez votre application, par exemple, “Play-Framework-Backend”.
﻿
Une fois créé, votre nouveau projet apparaîtra dans le tableau de bord.
Connexion avec Back4App
Back4App utilise Parse Server. Si votre application Play Framework prévoit d'interagir avec Back4App via le SDK Java Parse, vous pouvez l'ajouter à votre build.sbt si nécessaire. Sinon, vous pouvez utiliser des points de terminaison REST ou GraphQL.
Récupérez vos clés Parse:
Dans votre tableau de bord Back4App, ouvrez Paramètres de l'application ou Sécurité et clés pour trouver votre ID d'application, clé API REST, clé JavaScript (si vous utilisez des appels front-end), ou clé client, ainsi que l’ URL du serveur, (généralement https://parseapi.back4app.com).
﻿
Utiliser le SDK Java/Parse (Optionnel):
Si vous souhaitez une intégration directe côté serveur en utilisant le SDK Parse, ajoutez une dépendance dans votre build.sbt:
Text
libraryDependencies += "com.parse" % "parse" % "1.0.40" // Example version
libraryDependencies += "com.parse" % "parse" % "1.0.40" // Example version
﻿
Ensuite, dans votre code Play Framework, vous pouvez initialiser 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()
    )
  }
}
﻿
Vous pouvez placer cela dans votre Global.scala ou l'appeler depuis un point d'initialisation approprié. Cela vous prépare à une interaction directe avec votre projet Back4App.
Si vous préférez, utilisez les points de terminaison REST ou GraphQL pour les opérations de données, surtout si vous souhaitez plus de contrôle sur vos requêtes HTTP ou si vous construisez des microservices.
Étape 2 – Configuration de la base de données
Le service de stockage de données de Back4App prend en charge un large éventail de types de données et la création de schémas dynamiques. Cela vous permet de stocker les données de votre application Play avec un minimum de tracas.
Création d'un modèle de données
Ouvrez la section “Base de données” dans votre tableau de bord Back4App.
Créez une nouvelle classe (par exemple, “Todo”) et ajoutez des colonnes (par exemple, titre en tant que chaîne, estTerminé en tant que booléen).
Enregistrez pour finaliser votre schéma de base de données.
Créer une nouvelle classe
﻿
Création d'un modèle de données avec l'agent IA
Si vous souhaitez définir rapidement votre structure de données :
Ouvrez l'agent IA dans votre tableau de bord d'application.
Décrivez votre modèle de données souhaité en langage simple (par exemple, “Créez un modèle ToDo simple.”).
L'agent génère automatiquement le schéma pour vous.
﻿
Lecture et écriture de données en utilisant le SDK Parse (Optionnel)
Si vous avez choisi d'inclure le SDK Java Parse dans votre application Play Framework, vous pouvez enregistrer et interroger des données :
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)
    }
  }
}
﻿
Lecture et écriture de données en utilisant REST
Vous pouvez envoyer des requêtes HTTP depuis vos contrôleurs ou services 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
﻿
Lecture et écriture de données en utilisant GraphQL
Back4App fournit également une API 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
    }
  }
}
﻿
C'est pratique si vous construisez des microservices ou si vous souhaitez une API flexible pour vos clients front-end.
Travailler avec des requêtes en direct
Si votre application web nécessite des données en temps réel, activez les requêtes en direct:
Activer les requêtes en direct dans le tableau de bord Back4App sous Paramètres du serveur.
Configurez votre abonnement dans le code. Si vous utilisez le SDK Parse ou un code personnalisé, assurez-vous de configurer le liveQueryServerURL.
Abonnez-vous aux changements pour des classes comme “Todo.”
Étape 3 – Appliquer la sécurité avec les ACL et les CLP
Aperçu des ACL et des CLP
Back4App fournit des Listes de contrôle d'accès (ACL) pour la sécurité au niveau des objets et des Permissions au niveau de la classe (CLP) pour des restrictions générales. Cela aide à garder vos serveurs en sécurité et garantit que seules des opérations autorisées se produisent.
﻿
Permissions au niveau de la classe
Dans la section Base de données de votre tableau de bord Back4App :
Sélectionnez une classe (par exemple, “Todo”).
Ouvrez les CLP pour limiter la lecture/écriture aux utilisateurs authentifiés, rôles ou au public.
Configurez selon vos besoins (par exemple, “Nécessite une authentification” pour toute écriture).
ACLs
Les ACL protègent des objets individuels. Par exemple, vous pouvez vous assurer qu'un utilisateur particulier peut lire ou écrire un enregistrement spécifique. Si vous utilisez le SDK Parse depuis le code 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
}
﻿
Étape 4 – Écriture de fonctions Cloud Code
Pourquoi Cloud Code
Le Cloud Code vous permet d'exécuter une logique personnalisée sur les serveurs de Back4App, ajoutant des règles commerciales ou des validations avant ou après les transactions de données. Vous n'aurez pas besoin de gérer votre propre approvisionnement de serveur ou de redémarrages en mode développement pour mettre en œuvre de telles fonctions.
Fonction d'exemple
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 };
});
﻿
Vous pouvez appeler cela depuis votre application Play via REST, GraphQL, ou si vous utilisez le SDK Parse, directement.
Déploiement
Utilisez le Back4App CLI ou le tableau de bord :
Installez le CLI (exemple Linux/MacOS) :
Configurez la clé de compte:
Déployez:
Ou déployez via le tableau de bord en collant votre fonction dans Cloud Code > Functions et en cliquant sur “Déployer”.
Utilisation des modules NPM
Le Cloud Code prend en charge les modules NPM. Par exemple, si vous avez besoin d'un client HTTP comme 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;
});
﻿
Étape 5 – Configuration de l'authentification
Activation de l'authentification des utilisateurs
Back4App utilise la Parse.User classe pour l'inscription, la connexion et la gestion des sessions. Dans votre paramètre de configuration, assurez-vous d'activer « Vérification par e-mail » et « Réinitialisation du mot de passe » si désiré.
Code d'exemple (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)
    }
  }
}
﻿
Connexion sociale
Si vous avez besoin de connexions sociales (Google, Apple ou Facebook), configurez-les dans votre tableau de bord Back4App. Parse fournit des méthodes utilitaires ou vous pouvez vous fier aux flux OAuth standard, selon vos besoins et votre approche.
Étape 6 – Gestion du stockage de fichiers
Back4App stocke des fichiers via Parse.File. Depuis Play Framework, vous pouvez télécharger avec REST ou 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)
  }
}
﻿
Considérations de sécurité: Vous pouvez configurer les autorisations de téléchargement de fichiers (activer pour le public, anonyme ou authentifié) dans les paramètres du serveur Back4App.
Étape 7 – Vérification par e-mail et réinitialisation du mot de passe
Naviguez vers les paramètres de messagerie dans le tableau de bord Back4App.
Activer la vérification par e-mail et configurer les modèles d'e-mail pour les réinitialisations de mot de passe.
Dans votre application Play, vous pouvez appeler:
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
﻿
Cela déclenchera Back4App pour envoyer des instructions de réinitialisation de mot de passe à l'email de l'utilisateur.
Étape 8 – Planification des tâches avec les Cloud Jobs
Cloud Jobs
Si vous avez besoin d'un tâche de démarrage pour un travail en arrière-plan (par exemple, nettoyage des données ou génération de rapports), vous pouvez planifier des Cloud Jobs sur 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);
  }
});
﻿
Planification:
Déployez votre Cloud Code.
Dans Paramètres de l'application > Paramètres du serveur > Tâches en arrière-plan, planifiez la tâche pour qu'elle s'exécute quotidiennement, hebdomadairement ou selon les besoins.
Planification d'un Cloud Job
﻿
Étape 9 – Intégration des Webhooks
Si vous souhaitez notifier des services externes chaque fois que les données changent, configurez Webhooks dans Back4App.
Allez à Plus > WebHooks dans votre tableau de bord Back4App.
Ajouter un Webhook avec un point de terminaison (par exemple, Slack ou Stripe).
Choisissez des déclencheurs, tels que “Nouvel enregistrement dans la classe Todo.”
Ajout d'un Webhook
﻿
Vous pouvez également créer des Webhooks dans les déclencheurs de Cloud Code, en effectuant des requêtes HTTP directes vers des services tiers.
Webhook AvantSauvegarde
﻿
Étape 10 – Exploration du panneau d'administration Back4App
Le Back4App Admin App est une interface conviviale pour la gestion des données et des enregistrements. Les utilisateurs non techniques peuvent effectuer des opérations CRUD sans plonger dans le code.
Activation de l'Admin App
Allez à App Dashboard > Plus > Admin App.
Activez-le et créez un utilisateur administrateur.
Choisissez un sous-domaine pour un accès pratique.
Activer l'Admin App
﻿
Une fois connecté, vous pouvez gérer les entrées de données sans vous mêler des tableaux de bord de bas niveau ou des outils CLI.
﻿
Conclusion
Félicitations ! Vous avez appris comment construire un backend pour Play Framework en utilisant les services de Back4App. Tout au long de ce tutoriel, vous avez :
Créé un backend sécurisé pour une application Play Framework sur Back4App.
Mis en place une base de données, y compris la conception du schéma, les relations et les requêtes en temps réel.
Appliqué des ACL et des CLP pour un accès sécurisé aux données.
Écrit du Cloud Code pour une logique personnalisée, des déclencheurs et des intégrations externes.
Configuré l'authentification des utilisateurs, la connexion sociale et les réinitialisations de mot de passe.
Géré les téléchargements de fichiers et ajouté une sécurité de fichier optionnelle.
Planifié des tâches en arrière-plan avec Cloud Jobs.
Intégré avec des services tiers via Webhooks.
Exploré le Panneau d'administration Back4App pour une gestion des données simplifiée.
Avec ces outils en place, vous pouvez optimiser le mode développement, évoluer selon vos besoins et construire des applications web robustes sur le Play Framework. 
Adoptez des intégrations supplémentaires, un réglage des performances et des mesures de sécurité avancées pour amener vos backends de serveur au niveau supérieur.
Prochaines étapes
Améliorez votre configuration de production avec des outils de mise en cache, de journalisation ou de surveillance.
Explorez la sécurité avancée avec des contrôles d'accès basés sur les rôles ou des configurations de confiance zéro.
Intégrez des passerelles de paiement ou d'autres API tierces pour le commerce ou l'analyse.
Consultez la documentation officielle de Back4App pour des informations plus approfondies sur les performances et le dépannage.
Revoyez plus de tutoriels sur les applications de chat en temps réel, les solutions IoT ou les services basés sur la localisation — dont beaucoup s'appuient sur les techniques de ce guide.
﻿
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour Elixir ?
Comment construire un backend pour Spring Boot ?