Quickstarters
Come costruire un backend per Android?

47min
Introduzione
In questo tutorial, imparerai come costruire un backend completo per un Android (Java) applicazione utilizzando Back4App. 
Esploreremo l'integrazione delle funzionalità essenziali di Back4App—come 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 il tuo client 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, inclusi avanzati strumenti di sicurezza, pianificazione di attività con Cloud Jobs e 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 (Java) di base
Puoi configurarlo utilizzando Android Studio o uno strumento simile. Assicurati di avere installato l'ultima versione dell'Android SDK.
Java (versione 8 o superiore)
Avrai bisogno di Java per compilare ed eseguire il tuo progetto Android.
Familiarità con Java e concetti di base di Android
Documentazione per sviluppatori Android.
Se sei nuovo in Android, 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-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. Collegare la tua applicazione Android a Back4App implica installare il Parse Android SDK e inizializzarlo 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 (o Chiave JavaScript se indicato). Troverai anche il URL del Server Parse (spesso nel formato https://parseapi.back4app.com).
﻿
Installa il Parse SDK nel tuo progetto Android aggiungendo queste righe al tuo 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"
}
﻿
Se hai bisogno del repository Jitpack nel tuo root build.gradle:
Text
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
﻿
Inizializza Parse nella tua applicazione Android:
Crea una classe Application personalizzata (ad esempio, App.java) e configura il 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()
        );
    }
}
﻿
Poi, aggiungi questa classe Application personalizzata nel tuo 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>
﻿
Completando questo passaggio, hai stabilito una connessione sicura tra il tuo front-end Android 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 usarle quando necessario).
Passo 2 – Configurazione del Database
Salvare e interrogare i dati
Con il tuo progetto Back4App configurato e il Parse SDK integrato nella tua app Android, puoi ora iniziare a salvare e recuperare dati. Un modo tipico per creare e salvare un record è utilizzare 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
    }
});
﻿
Per interrogare i dati:
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
    }
});
﻿
In alternativa, puoi utilizzare gli endpoint REST API di 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 fornisce anche un interfaccia GraphQL:
GraphQL
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
﻿
GraphQL
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
﻿
Queste opzioni diverse ti permettono di integrare le operazioni sui dati nel modo che meglio si adatta al tuo processo di sviluppo, sia attraverso il Parse Android 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 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, “GameScore”) e aggiungi colonne pertinenti.
Crea Nuova Classe
﻿
Back4App supporta anche vari tipi di dati: Stringa, Numero, Booleano, Oggetto, Data, File, Puntatore, Array, Relazione, GeoPoint, e Poligono. Puoi scegliere il tipo appropriato per ciascun campo.
Crea Colonna
﻿
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 con uno schema di classe completo.”).
Lascia che l'Agente AI crei lo Schema per te.
﻿
Dati Relazionali
Se hai dati relazionali—diciamo, un Categoria oggetto che punta a più PunteggiDiGioco oggetti—puoi usare Puntatori o Relazioni in Parse. Ad esempio:
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
        }
    });
}
﻿
Quando interroghi, puoi includere i dati del puntatore:
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
    }
});
﻿
Query Live
Per aggiornamenti in tempo reale, Back4App fornisce Query Live. Puoi iscriverti ai cambiamenti in una classe specifica dalla tua app Android:
Abilita le Query Live nel tuo dashboard di Back4App sotto le Impostazioni del Server della tua app.
Inizializza la Query Live nel tuo codice.
In Android, di solito ti affidi alla libreria Parse LiveQuery Android per iscriverti. I passaggi sono simili ad altre piattaforme, ma integrerai 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"
}
﻿
Poi:
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;
    }
});
﻿
Iscrivendoti, ricevi notifiche in tempo reale ogni volta che un nuovo record viene creato, aggiornato o eliminato. Questa funzionalità è particolarmente preziosa per app collaborative o dinamiche in cui più utenti devono vedere i dati più recenti senza aggiornare la pagina.
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:
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
        }
    });
}
﻿
Modifica ACL
﻿
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, o se solo determinati ruoli possano accedervi.
Vai al tuo Dashboard di Back4app, seleziona la tua app e apri la Database sezione.
Seleziona una classe (ad esempio, “GameScore”).
Apri il tab dei Permessi a Livello di Classe.
Configura i tuoi predefiniti.
﻿
Questi permessi impostano la base, mentre gli ACL affinano i permessi per singoli oggetti. Un modello di sicurezza robusto combina tipicamente sia i CLP (restrizioni ampie) che gli ACL (restrizioni dettagliate per oggetto). Per ulteriori informazioni vai a Linee Guida sulla Sicurezza dell'App.
Passo 4 – Scrivere e Distribuire Funzioni di Cloud Code
Perché Cloud Code
Cloud Code è una funzionalità dell'ambiente Parse Server che consente di eseguire codice JavaScript personalizzato sul lato server, senza la necessità di gestire i propri server o infrastruttura. Scrivendo Cloud Code, puoi estendere il tuo backend Back4App con logica aziendale aggiuntiva, validazioni, trigger e integrazioni che vengono eseguite in modo sicuro ed efficiente su Parse Server.
Funzione di esempio
Una semplice funzione Cloud Code che calcola la lunghezza di una stringa di testo inviata dal 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 };
});
﻿
Distribuzione
Back4App CLI:
Dashboard:
Nel dashboard della tua app, vai a Cloud Code > Funzioni. Copia/incolla il tuo codice in main.js e clicca su Distribuisci.
﻿
Chiamare la tua funzione
Da Android (Java) utilizzando il Parse SDK:
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
    }
});
﻿
Puoi anche chiamarlo tramite REST o GraphQL. Questa flessibilità ti consente di integrare la tua logica personalizzata nel tuo frontend Android o in qualsiasi altro client che supporti REST o GraphQL.
Passo 5 – Configurazione dell'autenticazione utente
Autenticazione utente in Back4app
Back4App sfrutta la Parse User classe come base per l'autenticazione. Per impostazione predefinita, Parse gestisce l'hashing delle password, i token di sessione e lo storage sicuro. Questo significa che non devi configurare manualmente flussi di sicurezza complessi.
Impostazione dell'autenticazione utente
In un'applicazione Android che utilizza Java, puoi creare un nuovo utente:
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
    }
});
﻿
Accedi a un utente esistente:
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, un accesso potrebbe apparire così:
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
﻿
Gestione delle sessioni
Dopo un accesso riuscito, Parse crea un token di sessione memorizzato nell'oggetto utente. Puoi controllare l'utente attualmente connesso:
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
}
﻿
Puoi disconnetterti:
Java
ParseUser.logOut();
ParseUser.logOut();
﻿
Integrazione del login sociale
Back4app e Parse possono integrarsi con i popolari fornitori OAuth come Google o Facebook. Ad esempio, puoi configurare il login con Facebook configurando il Facebook App ID e utilizzando i dedicated Parse FacebookUtils per Android. Le istruzioni dettagliate variano, quindi fai riferimento a Documentazione del Login Sociale.
Verifica Email e Reimpostazione Password
Per abilitare la verifica email e la reimpostazione della password:
Naviga nelle Impostazioni Email nel tuo dashboard di Back4App.
Abilita la verifica email.
Configura l'indirizzo del mittente e i modelli email.
Questo aiuta a garantire che l'email del tuo utente sia valida e fornisce un metodo sicuro per il recupero della password.
Passo 6 – Gestione dello Storage dei File
Caricamento e Recupero dei File
Parse include la classe ParseFile per gestire i caricamenti di file, che Back4app memorizza in modo sicuro:
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
    }
});
﻿
Allega il file a un oggetto:
Java
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
﻿
Recupera l'URL del file:
Java
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
﻿
Sicurezza dei file
Parse Server fornisce configurazioni flessibili per gestire la sicurezza del caricamento dei file, inclusa la possibilità di controllare se gli utenti anonimi o autenticati possono caricare file. Assicurati di controllare la documentazione per configurazioni più avanzate.
Passo 7 – Verifica dell'email e reimpostazione della password
Panoramica
Verificare le email assicura che i nuovi utenti possiedano l'indirizzo email utilizzato per registrarsi. Le reimpostazioni della password consentono agli utenti di recuperare i propri account in modo sicuro.
Configurazione del Dashboard di Back4App
Abilita la verifica dell'email: Nel Dashboard della tua app, vai a Impostazioni Email.
Abilita la reimpostazione della password: Configura il flusso dell'email di reimpostazione della password.
Codice/Implementazione
Attivare la reimpostazione della password in 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
    }
});
﻿
Passo 8 – Pianificazione dei compiti con i Cloud Jobs
Cloud Jobs
Usa Cloud Jobs in Back4App per pianificare compiti ricorrenti, come la pulizia dei dati obsoleti o l'invio di email quotidiane. Esempio:
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
  // ...
});
﻿
Pianificalo nel Dashboard di Back4App > Impostazioni App > Impostazioni Server > Compiti in Background.
Pianificazione di un lavoro nel cloud
﻿
Passo 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, ad esempio, inviare dati a un servizio di terze parti come Stripe.
Naviga a Webhooks nel tuo dashboard di Back4App > Altro > WebHooks.
Aggiungi Webhook con il tuo endpoint esterno.
Configura i trigger per eventi rilevanti.
Aggiunta di un Webhook
﻿
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
L' App di Amministrazione di Back4app è un'interfaccia di gestione basata sul web progettata per utenti non tecnici. Consente operazioni CRUD rapide e gestione dei dati di routine senza scrivere alcun codice.
Abilitare l'App di Amministrazione
Vai a Dashboard dell'App > Altro > App di Amministrazione e clicca su Abilita App di Amministrazione.
Abilita l'app Admin
﻿
Crea un primo utente Admin e un sottodominio, e avrai un'interfaccia web per l'amministrazione dei dati.
Conclusione
Seguendo questo tutorial completo, hai:
Creato un backend sicuro per un'app Android (Java) 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 frontend Android (Java) 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
Costruisci un'app Android pronta per la produzione estendendo questo backend per gestire modelli di dati più complessi, strategie di caching e ottimizzazioni delle prestazioni.
Integra 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 costruire un backend per Kotlin?
AVANTI IL PROSSIMO
Come costruire un backend per Remix?