Quickstarters
Come costruire un backend per Play Framework?

37min
Introduzione
In questo tutorial, imparerai come costruire un backend completo per il Play Framework utilizzando Back4App.
Esploreremo le funzionalità essenziali per i backend server, inclusi impostazioni di configurazione, gestione del database, Cloud Code Functions, API REST e GraphQL, autenticazione degli utenti, archiviazione dei file e query in tempo reale.
Vedrai come Back4App semplifica il processo di configurazione, scalabilità e manutenzione di un backend per applicazioni web, permettendoti di concentrarti sul tuo codice del Play Framework.
Imparando a costruire un backend per il Play Framework con Back4App, ridurrai il tempo di sviluppo e minimizzerai i problemi di dev ops.
Aggiungerai anche funzionalità robuste come il login sociale, la pianificazione di attività (Cloud Jobs) e i webhook. Una volta completato, potrai estendere il sistema in una soluzione di livello produzione, integrando funzionalità più avanzate secondo necessità.
Quando avrai finito, avrai un solido schema per creare la tua prossima applicazione web scalabile e sicura con il Play Framework.
Sarai pronto per approfondire miglioramenti delle prestazioni, integrazioni o ottimizzazioni in modalità dev per gestire le richieste del mondo reale.
Requisiti
Per completare questo tutorial, avrai bisogno di:
Un account Back4App e un nuovo progetto Back4App
Iniziare con Back4App.
Se non hai un account, puoi crearne uno gratuitamente. Segui la guida sopra per preparare il tuo progetto.
Un ambiente di lavoro Play Framework
Assicurati di avere Java 8+ installato.
Installa sbt o usa sbt attraverso il tuo IDE.
Conoscenze di base del Play Framework
Fai riferimento alla Documentazione di Play se hai bisogno di rinfrescare le basi.
Familiarità con REST o GraphQL
Questo ti aiuterà a interagire con Back4App, specialmente se decidi di non usare o se non puoi usare direttamente il Parse SDK.
Assicurati di avere questi requisiti in atto prima di iniziare. Avere il tuo progetto Back4App configurato e il tuo ambiente Play Framework pronto ti aiuterà a seguire senza intoppi.
Passo 1 – Creare un Nuovo Progetto su Back4App e Connettersi
Perché hai bisogno di un nuovo progetto Back4App
Un nuovo progetto Back4App è la spina dorsale del tuo backend perché gestisce i dati della tua applicazione, l'autenticazione e la logica cloud. Che tu stia costruendo un piccolo prototipo o un'applicazione web su larga scala, è facile connettere la tua app Play Framework a un nuovo progetto Back4App.
Creare un Progetto Back4App
Accedi al tuo account Back4App.
Clicca su “Nuova App” nel tuo dashboard di Back4App.
Dai un nome alla tua app, ad esempio, “Play-Framework-Backend”.
﻿
Una volta creata, la tua nuova app apparirà nel dashboard.
Collegarsi a Back4App
Back4App sfrutta Parse Server. Se la tua app Play Framework prevede di interagire con Back4App tramite il Parse Java SDK, puoi aggiungerlo al tuo build.sbt se necessario. In caso contrario, puoi utilizzare gli endpoint REST o GraphQL.
Recupera le tue chiavi Parse:
Nel tuo dashboard di Back4App, apri Impostazioni App o Sicurezza e Chiavi per trovare il tuo ID Applicazione, Chiave API REST, Chiave JavaScript (se utilizzi chiamate front-end), o Chiave Client, più il URL Server (di solito https://parseapi.back4app.com).
﻿
Utilizzando il Java/Parse SDK (Opzionale):
Se desideri un'integrazione diretta lato server utilizzando il Parse SDK, aggiungi una dipendenza nel tuo build.sbt:
Text
libraryDependencies += "com.parse" % "parse" % "1.0.40" // Example version
libraryDependencies += "com.parse" % "parse" % "1.0.40" // Example version
﻿
Quindi, nel tuo codice Play Framework, puoi inizializzare 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()
    )
  }
}
﻿
Potresti posizionarlo nel tuo Global.scala o chiamarlo da un punto di inizializzazione appropriato. Questo ti prepara per un'interazione diretta con il tuo progetto Back4App.
Se preferisci, utilizza gli endpoint REST o GraphQL per le operazioni sui dati, specialmente se desideri un maggiore controllo sulle tue richieste HTTP o se stai costruendo microservizi.
Passo 2 – Configurazione del Database
Il servizio di archiviazione dati di Back4App supporta un'ampia gamma di tipi di dati e la creazione di schemi dinamici. Questo ti consente di memorizzare i dati della tua app Play con il minimo sforzo.
Creare un Modello di Dati
Apri la sezione “Database” nel tuo dashboard di Back4App.
Crea una nuova classe (ad esempio, “Todo”) e aggiungi colonne (ad esempio, title come String, isCompleted come Boolean).
Salva per finalizzare il tuo schema di database.
Crea Nuova Classe
﻿
Creare un Modello di Dati con l'Agente AI
Se desideri definire rapidamente la tua struttura dati:
Apri l'Agente AI nel tuo Dashboard dell'App.
Descrivi il tuo modello di dati desiderato in linguaggio semplice (ad esempio, “Crea un modello ToDo semplice.”).
L'agente genera automaticamente lo schema per te.
﻿
Lettura e Scrittura di Dati Utilizzando il Parse SDK (Opzionale)
Se hai scelto di includere il Parse Java SDK nella tua app Play Framework, puoi salvare e interrogare i dati:
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)
    }
  }
}
﻿
Lettura e Scrittura di Dati Utilizzando REST
Puoi inviare richieste HTTP dai tuoi controller o servizi 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
﻿
Lettura e Scrittura di Dati Utilizzando GraphQL
Back4App fornisce anche un'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
    }
  }
}
﻿
Questo è utile se stai costruendo microservizi o vuoi un'API flessibile per i tuoi client front-end.
Lavorare con le Query Live
Se la tua applicazione web ha bisogno di dati in tempo reale, abilita le Query Live:
Abilita le Query Live nel dashboard di Back4App sotto Impostazioni del Server.
Configura la tua sottoscrizione nel codice. Se utilizzi il Parse SDK o codice personalizzato, assicurati di configurare il liveQueryServerURL.
Iscriviti ai cambiamenti per classi come “Todo.”
Passo 3 – Applicare la Sicurezza con ACL e CLP
Panoramica su ACL e CLP
Back4App fornisce Liste di Controllo degli Accessi (ACL) per la sicurezza a livello di oggetto e Permessi a Livello di Classe (CLP) per restrizioni ampie. Questo aiuta a mantenere i tuoi backend server sicuri e garantisce che si verifichino solo operazioni autorizzate.
﻿
Permessi a Livello di Classe
Nella sezione Database del tuo dashboard di Back4App:
Seleziona una classe (ad esempio, “Todo”).
Apri i CLP per limitare la lettura/scrittura a utenti autenticati, ruoli o al pubblico.
Configura come necessario (ad esempio, “Richiede Autenticazione” per qualsiasi scrittura).
ACL
Le ACL proteggono oggetti individuali. Ad esempio, puoi assicurarti che solo un particolare utente possa leggere o scrivere un record specifico. Se stai utilizzando il Parse SDK dal codice 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
}
﻿
Passo 4 – Scrivere Funzioni di Cloud Code
Perché Cloud Code
Il Cloud Code ti consente di eseguire logica personalizzata sui server di Back4App, aggiungendo regole aziendali o validazioni prima o dopo le transazioni di dati. Non dovrai gestire la tua propria fornitura di server o riavvii in modalità sviluppo per implementare tali funzioni.
Funzione di Esempio
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 };
});
﻿
Puoi chiamare questo dalla tua app Play tramite REST, GraphQL, o se utilizzi il Parse SDK, direttamente.
Distribuzione
Usa il Back4App CLI o il dashboard:
Installa il CLI (esempio Linux/MacOS):
Configura la chiave dell'account:
Distribuisci:
Oppure distribuisci tramite il Dashboard incollando la tua funzione in Cloud Code > Funzioni e premendo “Distribuisci”.
Utilizzo dei Moduli NPM
Il Cloud Code supporta i moduli NPM. Ad esempio, se hai bisogno di un client HTTP come 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;
});
﻿
Passo 5 – Configurazione dell'autenticazione
Abilitazione dell'autenticazione utente
Back4App utilizza la Parse.User classe per la registrazione, il login e la gestione delle sessioni. Nelle tue impostazioni di configurazione, assicurati di abilitare “Verifica Email” e “Reimposta Password” se desiderato.
Codice di esempio (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)
    }
  }
}
﻿
Accesso sociale
Se hai bisogno di accessi sociali (Google, Apple o Facebook), configurali nel tuo dashboard di Back4App. Parse fornisce metodi di utilità oppure puoi fare affidamento sui flussi OAuth standard, a seconda delle tue esigenze e del tuo approccio.
Passo 6 – Gestione dello Storage dei File
Back4App memorizza i file tramite Parse.File. Da Play Framework, puoi caricare 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)
  }
}
﻿
Considerazioni sulla Sicurezza: Puoi configurare le autorizzazioni per il caricamento dei file (abilitare per pubblico, anonimo o autenticato) nelle impostazioni del server Back4App.
Passo 7 – Verifica Email e Ripristino Password
Naviga verso le Impostazioni Email nel dashboard di Back4App.
Abilita la verifica email e imposta i modelli email per il ripristino delle password.
Nella tua app Play, puoi chiamare:
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
﻿
Questo attiverà Back4App per inviare istruzioni per il ripristino della password all'email dell'utente.
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
Cloud Jobs
Se hai bisogno di un compito di avvio per lavori in background (ad esempio, pulizia dei dati o generazione di report), puoi pianificare Cloud Jobs su 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);
  }
});
﻿
Pianificazione:
Distribuisci il tuo Cloud Code.
In Impostazioni App > Impostazioni Server > Lavori in Background, pianifica il lavoro per essere eseguito quotidianamente, settimanalmente o secondo necessità.
Pianificazione di un Cloud Job
﻿
Passo 9 – Integrazione dei Webhook
Se desideri notificare servizi esterni ogni volta che i dati cambiano, configura Webhook in Back4App.
Vai su Altro > WebHooks nel tuo dashboard di Back4App.
Aggiungi Webhook con un endpoint (ad esempio, Slack o Stripe).
Scegli i trigger, come “Nuovo record nella classe Todo.”
Aggiunta di un Webhook
﻿
Puoi anche creare Webhook nei trigger del Cloud Code, effettuando richieste HTTP dirette a servizi di terze parti.
Webhook BeforeSave
﻿
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
Il Back4App Admin App è un'interfaccia user-friendly per la gestione di dati e registrazioni. Gli utenti non tecnici possono gestire operazioni CRUD senza immergersi nel codice.
Abilitare l'Admin App
Vai a App Dashboard > Altro > Admin App.
Abilitalo e crea un utente admin.
Scegli un sottodominio per un accesso conveniente.
Abilita l'Admin App
﻿
Una volta effettuato l'accesso, puoi gestire le voci di dati senza dover toccare i dashboard di livello inferiore o gli strumenti CLI.
﻿
Conclusione
Congratulazioni! Hai imparato come costruire un backend per Play Framework utilizzando i servizi di Back4App. Durante questo tutorial, hai:
Creato un backend sicuro per un'app Play Framework su Back4App.
Impostato un database, inclusi design dello schema, relazioni e query in tempo reale.
Applicato ACL e CLP per un accesso sicuro ai dati.
Scritto Cloud Code per logica personalizzata, trigger e integrazioni esterne.
Configurato l'autenticazione degli utenti, accesso sociale e reset della password.
Gestito caricamenti di file e aggiunto sicurezza opzionale per i file.
Pianificato attività in background con Cloud Jobs.
Integrato con servizi di terze parti tramite Webhooks.
Esplorato il Back4App Admin Panel per una gestione dei dati semplificata.
Con questi strumenti a disposizione, puoi ottimizzare la modalità di sviluppo, scalare secondo necessità e costruire applicazioni web robuste sul Play Framework. 
Abbraccia ulteriori integrazioni, ottimizzazione delle prestazioni e misure di sicurezza avanzate per portare i tuoi backend server al livello successivo.
Prossimi Passi
Migliora la tua configurazione di produzione con strumenti di caching, logging o monitoraggio.
Esplora la sicurezza avanzata con controlli di accesso basati sui ruoli o configurazioni zero-trust.
Integra i gateway di pagamento o altre API di terze parti per il commercio o l'analisi.
Controlla la documentazione ufficiale di Back4App per approfondimenti sulle prestazioni e la risoluzione dei problemi.
Rivedi altri tutorial su app di chat in tempo reale, soluzioni IoT o servizi basati sulla posizione — molti dei quali si basano sulle tecniche in questa guida.
﻿
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per Elixir?
AVANTI IL PROSSIMO
Come costruire un backend per Spring Boot?