Quickstarters
Come costruire un backend per Kotlin?

38min
Introduzione
In questo tutorial, imparerai come costruire un backend completo per un'applicazione Android (scritta in Kotlin) utilizzando Back4App.
Esploreremo l'integrazione delle funzionalità essenziali di Back4App—compresi la gestione del database, le Funzioni Cloud Code, le API REST e GraphQL, l'autenticazione degli utenti e le query in tempo reale (Live Queries)—per creare un backend sicuro, scalabile e robusto che comunica senza problemi con la tua app Android.
Vedrai anche come la rapida configurazione e l'ambiente intuitivo di Back4App possano ridurre drasticamente il tempo e lo sforzo rispetto alla configurazione manuale di server e database.
Durante il percorso, acquisirai esperienza pratica con funzionalità chiave, comprese le funzionalità di sicurezza avanzate, la pianificazione di attività con Cloud Jobs e la configurazione di webhook per integrazioni esterne.
Alla fine di questo tutorial, sarai ben preparato per migliorare questa configurazione di base in un'applicazione pronta per la produzione, o per incorporare facilmente logica personalizzata e API di terze parti secondo necessità.
Prerequisiti
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.
Ambiente di sviluppo Android/Kotlin di base
 Assicurati di avere Android Studio installato sul tuo computer. Puoi seguire la documentazione ufficiale di configurazione di Android Studio se non l'hai ancora configurato.
Un minimo di Android 4.0 o superiore nella configurazione Gradle della tua app
Tipicamente, imposterai questo nel tuo minSdkVersion nella build.gradle del tuo modulo.
Familiarità con Kotlin e concetti di base di Android
 Documentazione per sviluppatori Android.
Se sei nuovo in Android o Kotlin, rivedi la documentazione ufficiale o un tutorial per principianti prima di iniziare.
Assicurati di avere tutti questi prerequisiti in atto prima di iniziare. Avere il tuo progetto Back4app configurato e il tuo ambiente Android locale pronto ti aiuterà a seguire più facilmente.
Passo 1 – Configurazione del Progetto Back4app
Crea un Nuovo Progetto
Il primo passo per costruire il tuo backend Android su Back4app è creare un nuovo progetto. Se non ne hai già creato uno, segui questi passaggi:
Accedi al tuo account Back4app.
Clicca sul pulsante “Nuova App” nel tuo dashboard di Back4app.
Dai un nome alla tua app (ad esempio, “Android-Kotlin-Backend-Tutorial”).
﻿
Una volta creato il progetto, lo vedrai elencato nel tuo dashboard di Back4app. Questo progetto sarà la base per tutte le configurazioni del backend discusse in questo tutorial.
Collegare il Parse SDK
Back4App si basa sulla Parse Platform per gestire i tuoi dati, fornire funzionalità in tempo reale, gestire l'autenticazione degli utenti e altro ancora. Integrare la tua app Android con Back4App comporta l'aggiunta delle dipendenze del Parse Android SDK ai tuoi file Gradle e la loro inizializzazione con le credenziali dal tuo dashboard di Back4App.
Recupera le tue chiavi Parse:
Nel tuo dashboard di Back4App, vai alla sezione “Impostazioni App” o “Sicurezza e Chiavi” della tua app per trovare il tuo ID Applicazione e Chiave Client. Troverai anche l'URL del Server Parse (spesso nel formato https://parseapi.back4app.com).
﻿
Aggiungi il Parse SDK ai tuoi file build.gradle:
Nel tuo build.gradle principale (a livello di progetto):
Text
allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}
allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}
﻿
Nel tuo build.gradle a livello di modulo (di solito app/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"
}
﻿
Inizializza Parse nella tua applicazione Android:
Crea una Applicazione personalizzata (ad es., App.kt) se non ne hai già una:
Kotlin
package com.example.app

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

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize Parse
        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")  // from Back4App Dashboard
                .clientKey("YOUR_CLIENT_KEY")  // from Back4App Dashboard
                .server("https://parseapi.back4app.com/")
                .build()
        )

        // (Optional) Track statistics around app opens
        ParseInstallation.getCurrentInstallation().saveInBackground()
    }
}
package com.example.app

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

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize Parse
        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")  // from Back4App Dashboard
                .clientKey("YOUR_CLIENT_KEY")  // from Back4App Dashboard
                .server("https://parseapi.back4app.com/")
                .build()
        )

        // (Optional) Track statistics around app opens
        ParseInstallation.getCurrentInstallation().saveInBackground()
    }
}
﻿
Successivamente, apri il tuo AndroidManifest.xml e registra la Applicazione personalizzata:
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.app">

    <application
        android:name=".App"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:usesCleartextTraffic="true"
        ... >
        ...
    </application>

</manifest>
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.app">

    <application
        android:name=".App"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:usesCleartextTraffic="true"
        ... >
        ...
    </application>

</manifest>
﻿
Completando questo passaggio, hai stabilito una connessione sicura tra il tuo front end Android (Kotlin) e il backend di Back4App. Tutte le richieste e le transazioni di dati vengono instradate in modo sicuro attraverso questo SDK, riducendo la complessità delle chiamate REST o GraphQL manuali (anche se puoi comunque utilizzarle quando necessario).
Passo 2 – Configurazione del Database
Salvataggio e Query dei Dati
Con il tuo progetto Back4App configurato e il Parse SDK integrato nella tua app Android, puoi ora iniziare a salvare e recuperare dati. Di seguito è riportato un esempio che utilizza Kotlin per creare e recuperare dati.
Kotlin
import com.parse.ParseObject
import com.parse.ParseQuery
import com.parse.SaveCallback
import com.parse.ParseException

// Example: Create a Todo item
fun createTodoItem(title: String, isCompleted: Boolean) {
    val todo = ParseObject("Todo")
    todo.put("title", title)
    todo.put("isCompleted", isCompleted)

    todo.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("Todo saved successfully")
        } else {
            println("Error saving Todo: ${e.localizedMessage}")
        }
    }
}

// Example: Query all Todo items
fun fetchTodos() {
    val query = ParseQuery<ParseObject>("Todo")
    query.findInBackground { results, e ->
        if (e == null) {
            println("Fetched Todo items: ${results.size}")
        } else {
            println("Error fetching Todos: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseObject
import com.parse.ParseQuery
import com.parse.SaveCallback
import com.parse.ParseException

// Example: Create a Todo item
fun createTodoItem(title: String, isCompleted: Boolean) {
    val todo = ParseObject("Todo")
    todo.put("title", title)
    todo.put("isCompleted", isCompleted)

    todo.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("Todo saved successfully")
        } else {
            println("Error saving Todo: ${e.localizedMessage}")
        }
    }
}

// Example: Query all Todo items
fun fetchTodos() {
    val query = ParseQuery<ParseObject>("Todo")
    query.findInBackground { results, e ->
        if (e == null) {
            println("Fetched Todo items: ${results.size}")
        } else {
            println("Error fetching Todos: ${e.localizedMessage}")
        }
    }
}
﻿
In alternativa, puoi utilizzare gli endpoint API REST di Back4App:
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
﻿
Back4app fornisce anche un'interfaccia 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
    }
  }
}
﻿
Queste diverse opzioni ti consentono di integrare le operazioni sui dati nel modo che meglio si adatta al tuo processo di sviluppo, sia attraverso il Parse SDK, REST o GraphQL.
Progettazione dello schema e tipi di dati
Per impostazione predefinita, Parse consente la creazione di schemi al volo, ma puoi anche definire le tue classi e i tuoi tipi di dati nel dashboard di Back4app per avere maggiore controllo.
Naviga nella sezione “Database” nel tuo dashboard di Back4app.
Crea una nuova classe (ad esempio, “Todo”) e aggiungi colonne pertinenti, come titolo (String) e isCompleted (Boolean).
Crea Nuova Classe
﻿
Back4app offre un Agente AI che può aiutarti a progettare il tuo modello di dati:
Apri l'Agente AI dal tuo Dashboard App o dal menu.
Descrivi il tuo modello di dati in linguaggio semplice (ad esempio, “Per favore crea una nuova App ToDo su back4app con uno schema di classe completo.”).
Lascia che l'Agente AI crei lo Schema per te.
﻿
Utilizzare l'Agente AI può farti risparmiare tempo nella configurazione della tua architettura dati e garantire coerenza nella tua applicazione.
Dati Relazionali
Se hai dati relazionali—diciamo, un Category oggetto che punta a più Todo elementi—puoi usare Pointers o Relations in Parse. Ad esempio, aggiungere un puntatore a un Category:
Kotlin
// Linking a Todo to a Category with a pointer
fun createTaskForCategory(categoryObjectId: String, title: String) {
    val todo = ParseObject("Todo")
    val categoryPointer = ParseObject("Category")
    categoryPointer.objectId = categoryObjectId

    todo.put("title", title)
    todo.put("category", categoryPointer)

    todo.saveInBackground { e ->
        if (e == null) {
            println("Created Task with category relationship")
        } else {
            println("Error creating Task: ${e.localizedMessage}")
        }
    }
}
// Linking a Todo to a Category with a pointer
fun createTaskForCategory(categoryObjectId: String, title: String) {
    val todo = ParseObject("Todo")
    val categoryPointer = ParseObject("Category")
    categoryPointer.objectId = categoryObjectId

    todo.put("title", title)
    todo.put("category", categoryPointer)

    todo.saveInBackground { e ->
        if (e == null) {
            println("Created Task with category relationship")
        } else {
            println("Error creating Task: ${e.localizedMessage}")
        }
    }
}
﻿
Quando interroghi, puoi anche includere i dati del puntatore:
Kotlin
val query = ParseQuery.getQuery<ParseObject>("Todo")
query.include("category")
query.findInBackground { todos, e ->
    if (e == null) {
        println("Fetched ${todos.size} todos with category data")
    }
}
val query = ParseQuery.getQuery<ParseObject>("Todo")
query.include("category")
query.findInBackground { todos, e ->
    if (e == null) {
        println("Fetched ${todos.size} todos with category data")
    }
}
﻿
Questa include("category") chiamata recupera i dettagli della categoria insieme a ciascun Todo, rendendo i tuoi dati relazionali facilmente accessibili.
Query in tempo reale
Per aggiornamenti in tempo reale, Back4app fornisce Live Queries. Puoi iscriverti ai cambiamenti in una classe specifica dalla tua app Android:
Abilita le Live Queries nel tuo dashboard di Back4App sotto le Impostazioni del server della tua app.
Inizializza un abbonamento a una Live Query nel tuo codice:
Kotlin
import com.parse.ParseLiveQueryClient
import com.parse.ParseQuery
import com.parse.SubscriptionHandling
...

val parseLiveQueryClient = ParseLiveQueryClient.Factory.getClient()
val parseQuery = ParseQuery<ParseObject>("Todo")

val subscriptionHandling: SubscriptionHandling<ParseObject> =
    parseLiveQueryClient.subscribe(parseQuery)

subscriptionHandling.handleEvent(SubscriptionHandling.Event.CREATE) { queryTodo, todo ->
    println("New Todo created: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.UPDATE) { queryTodo, todo ->
    println("Todo updated: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.DELETE) { queryTodo, todo ->
    println("Todo deleted: ${todo.getString("title")}")
}
import com.parse.ParseLiveQueryClient
import com.parse.ParseQuery
import com.parse.SubscriptionHandling
...

val parseLiveQueryClient = ParseLiveQueryClient.Factory.getClient()
val parseQuery = ParseQuery<ParseObject>("Todo")

val subscriptionHandling: SubscriptionHandling<ParseObject> =
    parseLiveQueryClient.subscribe(parseQuery)

subscriptionHandling.handleEvent(SubscriptionHandling.Event.CREATE) { queryTodo, todo ->
    println("New Todo created: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.UPDATE) { queryTodo, todo ->
    println("Todo updated: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.DELETE) { queryTodo, todo ->
    println("Todo deleted: ${todo.getString("title")}")
}
﻿
Ogni volta che un nuovo Todo viene creato, aggiornato o eliminato, il client riceve un callback in tempo reale—perfetto per app collaborative o dinamiche.
Passo 3 – Applicare la Sicurezza con ACL e CLP
Meccanismo di Sicurezza di Back4app
Back4app prende sul serio la sicurezza fornendo Liste di Controllo degli Accessi (ACL) e Permessi a Livello di Classe (CLP). Queste funzionalità ti consentono di limitare chi può leggere o scrivere dati su base per oggetto o per classe, garantendo che solo gli utenti autorizzati possano modificare i tuoi dati.
﻿
Liste di Controllo degli Accessi (ACL)
Un ACL è applicato a singoli oggetti per determinare quali utenti, ruoli o il pubblico possono eseguire operazioni di lettura/scrittura. Ad esempio:
Kotlin
fun createPrivateTodo(title: String, ownerUser: ParseObject) {
    val todo = ParseObject("Todo")
    todo.put("title", title)

    // Create an ACL granting read/write access only to the owner
    val acl = com.parse.ParseACL(ownerUser)
    acl.publicReadAccess = false
    acl.publicWriteAccess = false

    todo.acl = acl

    todo.saveInBackground { e ->
        if (e == null) {
            println("Saved private todo")
        } else {
            println("Error: ${e.localizedMessage}")
        }
    }
}
fun createPrivateTodo(title: String, ownerUser: ParseObject) {
    val todo = ParseObject("Todo")
    todo.put("title", title)

    // Create an ACL granting read/write access only to the owner
    val acl = com.parse.ParseACL(ownerUser)
    acl.publicReadAccess = false
    acl.publicWriteAccess = false

    todo.acl = acl

    todo.saveInBackground { e ->
        if (e == null) {
            println("Saved private todo")
        } else {
            println("Error: ${e.localizedMessage}")
        }
    }
}
﻿
Permessi a Livello di Classe (CLP)
I CLP governano i permessi predefiniti di un'intera classe, come se la classe sia leggibile o scrivibile pubblicamente.
Vai al tuo Dashboard di Back4app, seleziona la tua app e apri la sezione Database.
Seleziona una classe (ad esempio, “Todo”).
Apri la scheda dei Permessi a Livello di Classe.
Configura i tuoi predefiniti, come “Richiede Autenticazione” per lettura o scrittura, o “Nessun Accesso” per il pubblico.
﻿
Passo 4 – Scrivere Funzioni di Cloud Code
Il Cloud Code ti consente di eseguire codice JavaScript personalizzato simile a Kotlin su Parse Server (caricato come .js file), senza dover gestire l'infrastruttura del server. Questo è ideale per la logica aziendale, le convalide, i trigger e le chiamate API esterne.
Come Funziona
Di solito posizioni le funzioni JavaScript, i trigger e eventuali moduli npm richiesti in un main.js file. Questo file viene distribuito al tuo progetto Back4App e viene eseguito nell'ambiente del Parse Server.
Casi d'uso tipici
Logica Aziendale
Validazioni dei Dati
Trigger (come beforeSave, afterSave)
Applicazione della Sicurezza
Integrazioni con API di terze parti
Distribuisci la tua Funzione
Di seguito è riportata una semplice funzione Cloud Code:
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 };
});
﻿
Distribuendo tramite il Back4App CLI:
Bash
# For Linux/Mac
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# For Windows, download the .exe from the releases page
# For Linux/Mac
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# For Windows, download the .exe from the releases page
﻿
Quindi configura e distribuisci:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
Chiamare la tua funzione
Dal tuo codice Android (Kotlin) tramite il Parse SDK:
Kotlin
import com.parse.ParseCloud
import com.parse.FunctionCallback
import com.parse.ParseException

fun callTextLengthFunction(someText: String) {
    val params = hashMapOf("text" to someText)
    ParseCloud.callFunctionInBackground<Map<String, Any>>("calculateTextLength", params) { result, e ->
        if (e == null) {
            val length = result["length"] as Int
            println("Text length: $length")
        } else {
            println("Error calling Cloud Code: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseCloud
import com.parse.FunctionCallback
import com.parse.ParseException

fun callTextLengthFunction(someText: String) {
    val params = hashMapOf("text" to someText)
    ParseCloud.callFunctionInBackground<Map<String, Any>>("calculateTextLength", params) { result, e ->
        if (e == null) {
            val length = result["length"] as Int
            println("Text length: $length")
        } else {
            println("Error calling Cloud Code: ${e.localizedMessage}")
        }
    }
}
﻿
Puoi anche chiamarlo tramite REST o GraphQL in modo simile.
Passo 5 – Configurazione dell'autenticazione
Autenticazione dell'utente in Back4App
Back4App sfrutta la Parse User classe per l'autenticazione. Parse gestisce l'hashing sicuro delle password, i token di sessione e altro ancora out of the box.
Impostazione dell'autenticazione dell'utente
In Kotlin, puoi creare un nuovo utente:
Kotlin
import com.parse.ParseUser
...
fun signUpUser(username: String, password: String, email: String) {
    val user = ParseUser()
    user.username = username
    user.setPassword(password)
    user.email = email

    user.signUpInBackground { e ->
        if (e == null) {
            println("User signed up successfully!")
        } else {
            println("Error signing up user: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseUser
...
fun signUpUser(username: String, password: String, email: String) {
    val user = ParseUser()
    user.username = username
    user.setPassword(password)
    user.email = email

    user.signUpInBackground { e ->
        if (e == null) {
            println("User signed up successfully!")
        } else {
            println("Error signing up user: ${e.localizedMessage}")
        }
    }
}
﻿
Accedi a un utente esistente:
Kotlin
fun logInUser(username: String, password: String) {
    ParseUser.logInInBackground(username, password) { user, e ->
        if (user != null && e == null) {
            println("User logged in: ${user.username}")
        } else {
            println("Error logging in: ${e?.localizedMessage}")
        }
    }
}
fun logInUser(username: String, password: String) {
    ParseUser.logInInBackground(username, password) { user, e ->
        if (user != null && e == null) {
            println("User logged in: ${user.username}")
        } else {
            println("Error logging in: ${e?.localizedMessage}")
        }
    }
}
﻿
I login social come Google, Facebook e Apple possono essere integrati. Controlla Documentazione sul login sociale per dettagli.
Gestione delle sessioni
Parse gestisce automaticamente i token di sessione. Puoi accedere all'utente corrente:
Kotlin
val currentUser = ParseUser.getCurrentUser()
if (currentUser != null) {
    println("Currently logged-in user: ${currentUser.username}")
} else {
    println("No user is logged in")
}
val currentUser = ParseUser.getCurrentUser()
if (currentUser != null) {
    println("Currently logged-in user: ${currentUser.username}")
} else {
    println("No user is logged in")
}
﻿
E disconnettersi:
Kotlin
ParseUser.logOut()
ParseUser.logOut()
﻿
Passo 6 – Gestione dello Storage dei File
Caricamento e Recupero di File
Parse include la ParseFile classe per gestire i caricamenti di file:
Kotlin
import com.parse.ParseFile
import com.parse.ParseException

fun uploadImage(file: java.io.File) {
    val bytes = file.readBytes()
    val parseFile = ParseFile(file.name, bytes)

    parseFile.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("File saved: ${parseFile.url}")
        } else {
            println("Error uploading file: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseFile
import com.parse.ParseException

fun uploadImage(file: java.io.File) {
    val bytes = file.readBytes()
    val parseFile = ParseFile(file.name, bytes)

    parseFile.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("File saved: ${parseFile.url}")
        } else {
            println("Error uploading file: ${e.localizedMessage}")
        }
    }
}
﻿
Parse include la ParseFile classe per gestire i caricamenti di file:
Sicurezza dei file
Puoi controllare chi può caricare o scaricare file regolando le ACL e le CLP o utilizzando impostazioni specifiche per i file nella configurazione del parse-server.
Passo 7 – Verifica dell'email e reimpostazione della password
Abilita la verifica dell'email nelle impostazioni del tuo dashboard Back4App.
Configura il tuo indirizzo di invio, i modelli di email o un dominio personalizzato se desiderato.
Usa ParseUser.requestPasswordResetInBackground(email, callback) per attivare un flusso di reimpostazione della password nella tua app.
Passo 8 – Pianificazione dei compiti con Cloud Jobs
I Cloud Jobs ti permettono di automatizzare compiti di routine come la pulizia dei dati o l'invio di notifiche periodiche.
JS
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo')
  const query = new Parse.Query(Todo)
  // e.g., remove todos older than 30 days
  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
  query.lessThan('createdAt', cutoff)

  const oldTodos = await query.find({ useMasterKey: true })
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true })
  return `Deleted ${oldTodos.length} old Todos.`
})
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo')
  const query = new Parse.Query(Todo)
  // e.g., remove todos older than 30 days
  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
  query.lessThan('createdAt', cutoff)

  const oldTodos = await query.find({ useMasterKey: true })
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true })
  return `Deleted ${oldTodos.length} old Todos.`
})
﻿
Pianifica il lavoro nel tuo dashboard Back4App sotto Impostazioni del server > Lavori in background.
Passaggio 9 – Integrazione dei Webhook
Webhook consentono alla tua app Back4App di inviare richieste HTTP a un servizio esterno ogni volta che si verificano determinati eventi.
Aggiungi un Webhook nel tuo Dashboard di Back4App sotto Altro > Webhook.
Configura i trigger (ad esempio, dopo aver salvato un nuovo oggetto).
Aggiungi un endpoint URL (come un webhook di Slack o Stripe).
Aggiunta di un Webhook
﻿
Passaggio 10 – Esplorare il Pannello di Amministrazione di Back4App
L' App di Amministrazione di Back4App è un'interfaccia web amichevole per utenti non tecnici per gestire i dati.
Abilitalo sotto Dashboard App > Altro > App di Amministrazione.
Crea il tuo primo utente amministratore.
Scegli un sottodominio per accedere al pannello di amministrazione.
Accedi per visualizzare, modificare o rimuovere facilmente i record dal tuo database.
Abilita l'App di Amministrazione
﻿
Conclusione
Seguendo questo tutorial completo, hai:
Creato un backend sicuro per un'app Android su Back4App.
Configurato un database con schemi di classe, tipi di dati e relazioni.
Integrato query in tempo reale (Live Queries) per aggiornamenti immediati dei dati.
Applicato misure di sicurezza utilizzando ACL e CLP per proteggere e gestire l'accesso ai dati.
Implementato Cloud Code funzioni per eseguire logica aziendale personalizzata sul lato server.
Impostato l'autenticazione degli utenti con supporto per la verifica dell'email e il ripristino della password.
Gestito caricamenti di file e recupero, con controlli di sicurezza dei file opzionali.
Pianificato Cloud Jobs per attività di background automatizzate.
Utilizzato Webhooks per integrarsi con servizi esterni.
Esplorato il Pannello di Amministrazione di Back4App per la gestione dei dati.
Con un solido front end Android (Kotlin) e un robusto backend Back4App, sei ora ben attrezzato per sviluppare applicazioni ricche di funzionalità, scalabili e sicure. Continua a esplorare funzionalità più avanzate, integra la tua logica aziendale e sfrutta la potenza di Back4App per risparmiare innumerevoli ore nella gestione di server e database. Buon coding!
Prossimi Passi
Costruire un'app Android pronta per la produzione estendendo questo backend per gestire modelli di dati più complessi, strategie di caching e ottimizzazioni delle prestazioni.
Integrare funzionalità avanzate come flussi di autenticazione specializzati, controllo degli accessi basato sui ruoli o API esterne (come i gateway di pagamento).
Controlla la documentazione ufficiale di Back4app per approfondimenti su sicurezza avanzata, ottimizzazione delle prestazioni e analisi dei log.
Esplora altri tutorial su applicazioni di chat in tempo reale, dashboard IoT o servizi basati sulla posizione. Puoi combinare le tecniche apprese qui con API di terze parti per creare applicazioni complesse e reali.
﻿
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come creare un backend per Swift?
AVANTI IL PROSSIMO
Come costruire un backend per Android?