Quickstarters
Come costruire un backend per Flutter?

40min
Introduzione
In questo tutorial, imparerai come costruire un backend per Flutter utilizzando Back4app, un backend open source e affidabile come servizio (BaaS). 
Esploreremo l'integrazione delle funzionalità essenziali di Back4app—come la gestione del database, le Cloud Functions, le API RESTful, le API GraphQL e l'autenticazione degli utenti—nel tuo progetto Flutter. 
Scoprirai anche come gestire aggiornamenti in tempo reale utilizzando le Live Queries. Utilizzando i potenti server backend di Back4app, puoi saltare gran parte della configurazione manuale e concentrarti sulla creazione di un'app Flutter dinamica.
Questa guida mostrerà agli sviluppatori Flutter come impostare una struttura backend sicura, scalabile e robusta che comunica senza sforzo con il lato client. 
Metteremo anche in evidenza i vantaggi di lasciare che Back4app gestisca il lavoro pesante—come l'hosting, l'autenticazione degli utenti e la logica del server—così puoi beneficiare di funzionalità come il ridimensionamento automatico, la sicurezza avanzata e la manutenzione semplificata. 
Se hai un progetto Flutter e vuoi risparmiare innumerevoli ore di configurazione del backend, questo è il posto giusto per iniziare.
Alla fine di questo tutorial, comprenderai il tipo di backend che puoi creare con Back4app e sarai pronto ad estendere i tuoi servizi backend per un'applicazione pronta per la produzione o integrare funzionalità più complesse, come API esterne e autenticazione avanzata degli utenti. 
Iniziamo!
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.
Ambiente di sviluppo Flutter di base
 Assicurati di avere il Flutter SDK installato e configurato. Inoltre, conferma di avere un IDE (come Android Studio o VS Code) configurato per Flutter.
Ambiente di programmazione Dart
Di solito questo viene installato insieme a Flutter. Assicurati di poter importare pacchetti dart senza errori.
Familiarità con i fondamenti di Flutter
 Documentazione ufficiale di Flutter.
Se sei nuovo in Flutter, rivedi la documentazione ufficiale o un tutorial per principianti prima di iniziare.
Assicurati di avere tutti questi requisiti in ordine. Avere il tuo progetto Back4app configurato e il tuo ambiente Flutter locale impostato ti aiuterà a seguire più facilmente.
Passo 1 – Creare un nuovo progetto su Back4App e connettersi
Crea un nuovo progetto
Il primo passo per costruire il tuo backend Flutter 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, “Flutter-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 di cui discuteremo.
Installa e Inizializza il Parse SDK nella tua App Flutter
Back4app si basa sulla Parse Platform per gestire i tuoi dati, aggiornamenti in tempo reale, autenticazione degli utenti e altro ancora. Per collegare il tuo progetto Flutter a Back4app, segui questi passaggi:
Aggiungi il Parse Flutter SDK alla tua app:
YAML
dependencies:
  parse_server_sdk_flutter: ^4.0.0
dependencies:
  parse_server_sdk_flutter: ^4.0.0
﻿
Importa il pacchetto Parse nel tuo main.dart (o dove inizializzi la tua app):
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:flutter/material.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  const keyApplicationId = 'YOUR_APPLICATION_ID';
  const keyParseServerUrl = 'https://parseapi.back4app.com';
  const keyClientKey = 'YOUR_CLIENT_KEY';

  // Initialize Parse with debug set to true
  await Parse().initialize(
    keyApplicationId,
    keyParseServerUrl,
    clientKey: keyClientKey,
    autoSendSessionId: true,
    debug: true, 
  );

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter + Back4App Example',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: const Scaffold(
        body: Center(
          child: Text('Hello from Flutter + Back4App!'),
        ),
      ),
    );
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:flutter/material.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  const keyApplicationId = 'YOUR_APPLICATION_ID';
  const keyParseServerUrl = 'https://parseapi.back4app.com';
  const keyClientKey = 'YOUR_CLIENT_KEY';

  // Initialize Parse with debug set to true
  await Parse().initialize(
    keyApplicationId,
    keyParseServerUrl,
    clientKey: keyClientKey,
    autoSendSessionId: true,
    debug: true, 
  );

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter + Back4App Example',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: const Scaffold(
        body: Center(
          child: Text('Hello from Flutter + Back4App!'),
        ),
      ),
    );
  }
}
﻿
Nel tuo dashboard di Back4app, vai alla sezione Sicurezza e Chiavi per trovare il tuo ID Applicazione, Chiave Client, e URL del Server Parse. Sostituisci i segnaposto sopra con le tue credenziali. Con questa inizializzazione, ogni richiesta dalla tua app Flutter è instradata in modo sicuro alla tua istanza di Back4app.
Ricorda che la chiave master non dovrebbe mai essere utilizzata sul lato client della tua app Flutter. Se hai bisogno della chiave master, conservala sul server o in un ambiente sicuro.
Passo 2 – Configurazione del Database
Creazione di un Modello di Dati
Una volta che la tua app Flutter è connessa a Back4app, puoi iniziare a progettare il tuo schema di database. Puoi farlo manualmente dal dashboard di Back4app:
Naviga nella sezione “Database” nel tuo dashboard.
Crea una nuova classe (ad esempio, “Todo”), e aggiungi colonne pertinenti (ad esempio, titolo, isCompleted).
Crea Nuova Classe
﻿
Back4app fornisce anche un Agente AI per aiutare con la creazione automatica dello schema:
Apri l'Agente AI dal tuo Dashboard dell'App o dal menu.
Descrivi il tuo modello di dati in linguaggio semplice (ad esempio, “Crea una nuova App ToDo con uno schema di classe completo.”).
Lascia che l'Agente AI crei lo schema per te.
﻿
Questo semplifica la configurazione dell'architettura dei dati. Se desideri che i campi vengano creati automaticamente, puoi semplicemente iniziare a salvare oggetti dalla tua app—Parse supporta la creazione di schemi al volo.
Creare un Modello di Dati Utilizzando l'Agente AI
Se scegli di utilizzare l'Agente AI di Back4app, basta fornire una breve descrizione e costruirà o suggerirà uno schema per te. Questo è un ottimo modo per accelerare la fase iniziale di modellazione dei dati del tuo progetto Flutter.
Leggere e Scrivere Dati Utilizzando Flutter Parse SDK
Di seguito è riportato un semplice esempio che dimostra come creare e recuperare oggetti utilizzando il Parse Flutter SDK.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createTodoItem(String title, bool isCompleted) async {
  final todo = ParseObject('Todo')
    ..set('title', title)
    ..set('isCompleted', isCompleted);

  final response = await todo.save();
  if (response.success && response.result != null) {
    print('Todo saved successfully: ${response.result}');
  } else {
    print('Error saving Todo: ${response.error?.message}');
  }
}

Future<List<ParseObject>?> fetchTodos() async {
  final QueryBuilder<ParseObject> queryTodo =
      QueryBuilder<ParseObject>(ParseObject('Todo'));

  final response = await queryTodo.query();
  if (response.success && response.results != null) {
    print('Fetched Todo items: ${response.results}');
    return response.results as List<ParseObject>;
  } else {
    print('Error fetching Todos: ${response.error?.message}');
    return null;
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createTodoItem(String title, bool isCompleted) async {
  final todo = ParseObject('Todo')
    ..set('title', title)
    ..set('isCompleted', isCompleted);

  final response = await todo.save();
  if (response.success && response.result != null) {
    print('Todo saved successfully: ${response.result}');
  } else {
    print('Error saving Todo: ${response.error?.message}');
  }
}

Future<List<ParseObject>?> fetchTodos() async {
  final QueryBuilder<ParseObject> queryTodo =
      QueryBuilder<ParseObject>(ParseObject('Todo'));

  final response = await queryTodo.query();
  if (response.success && response.results != null) {
    print('Fetched Todo items: ${response.results}');
    return response.results as List<ParseObject>;
  } else {
    print('Error fetching Todos: ${response.error?.message}');
    return null;
  }
}
﻿
Con questo, puoi interagire direttamente con il tuo database Back4app dalla tua app Flutter. Basta chiamare createTodoItem('Feed the cat', false) o fetchTodos() per scrivere e leggere dati.
Lettura e Scrittura dei Dati Utilizzando l'API REST
Se hai bisogno di integrarti con altri servizi o preferisci un approccio più tradizionale, puoi comunque utilizzare l'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
﻿
Lettura e Scrittura dei Dati Utilizzando l'API GraphQL
Back4app offre anche un endpoint 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 ti offre flessibilità per costruire l'approccio che funziona meglio per la tua app Flutter.
Lavorare con le Query Live
Back4app fornisce Query Live in modo da poter ricevere aggiornamenti in tempo reale sui tuoi dati. Abilita le Query Live nel dashboard di Back4app (Impostazioni del server) e poi utilizza il client Flutter Parse LiveQuery.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:parse_server_sdk_flutter/live_query.dart';

Future<void> subscribeToTodos() async {
  final liveQuery = LiveQuery();
  final query = QueryBuilder<ParseObject>(ParseObject('Todo'));

  Subscription subscription = await liveQuery.client.subscribe(query);

  subscription.on(LiveQueryEvent.create, (value) {
    print('New Todo created: $value');
  });

  subscription.on(LiveQueryEvent.update, (value) {
    print('Todo updated: $value');
  });

  subscription.on(LiveQueryEvent.delete, (value) {
    print('Todo deleted: $value');
  });
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:parse_server_sdk_flutter/live_query.dart';

Future<void> subscribeToTodos() async {
  final liveQuery = LiveQuery();
  final query = QueryBuilder<ParseObject>(ParseObject('Todo'));

  Subscription subscription = await liveQuery.client.subscribe(query);

  subscription.on(LiveQueryEvent.create, (value) {
    print('New Todo created: $value');
  });

  subscription.on(LiveQueryEvent.update, (value) {
    print('Todo updated: $value');
  });

  subscription.on(LiveQueryEvent.delete, (value) {
    print('Todo deleted: $value');
  });
}
﻿
Con questa sottoscrizione, puoi ascoltare le modifiche ai dati mentre accadono. Questo è fantastico per costruire app collaborative in cui più utenti vedono aggiornamenti di dati in tempo reale. Una volta attivato il hot reload, la tua sottoscrizione rimarrà attiva a meno che l'app non venga riavviata.
Passo 3 – Applicare la Sicurezza con ACL e CLP
Cosa sono ACL e CLP?
Back4app utilizza ACL (Liste di Controllo degli Accessi) e CLP (Permessi a Livello di Classe) per limitare chi può leggere o scrivere dati sia a livello di oggetto che di classe. Questo strato garantisce che i tuoi dati siano protetti da accessi non autorizzati.
Impostare i Permessi a Livello di Classe
Nel tuo Dashboard di Back4app, vai a Database e seleziona una classe (ad esempio, “Todo”).
Naviga a Class-Level Permissions.
Imposta i valori predefiniti (ad esempio, solo gli utenti autenticati possono creare nuovi oggetti).
﻿
Configurare le ACL nel codice
Puoi anche applicare le ACL a livello di oggetto dal codice Flutter:
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createPrivateTodo(ParseUser ownerUser, String title) async {
  final todo = ParseObject('Todo')..set('title', title);

  final acl = ParseACL(owner: ownerUser);
  acl.setPublicReadAccess(allowed: false);
  acl.setPublicWriteAccess(allowed: false);

  todo.setACL(acl);

  final response = await todo.save();
  if (response.success) {
    print('Private Todo saved.');
  } else {
    print('Error: ${response.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createPrivateTodo(ParseUser ownerUser, String title) async {
  final todo = ParseObject('Todo')..set('title', title);

  final acl = ParseACL(owner: ownerUser);
  acl.setPublicReadAccess(allowed: false);
  acl.setPublicWriteAccess(allowed: false);

  todo.setACL(acl);

  final response = await todo.save();
  if (response.success) {
    print('Private Todo saved.');
  } else {
    print('Error: ${response.error?.message}');
  }
}
﻿
Combinando CLP e ACL, puoi garantire che solo le persone o i ruoli giusti possano accedere o modificare dati specifici.
Passo 4 – Scrivere funzioni di Cloud Code
Perché Cloud Code?
Il Cloud Code ti consente di eseguire logica lato server senza dover configurare manualmente alcun server backend. Questo è perfetto per convalidare i dati, integrarsi con servizi esterni o applicare determinate regole nel tuo backend come servizio (BaaS).
Funzione di Esempio
Ecco un esempio di Cloud Function che calcola la lunghezza di un testo:
JS
// main.js in your Cloud Code
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js in your Cloud Code
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Puoi distribuire questo codice tramite il Back4app CLI o nel dashboard della tua app sotto Cloud Code.
Distribuzione
Utilizzando il Back4app CLI:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
Utilizzando il Dashboard:
Nel dashboard della tua app, vai su Cloud Code > Funzioni.
Incolla il codice JavaScript.
Clicca Distribuisci.
﻿
Chiamare il Cloud Code da Flutter
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> getTextLength(String text) async {
  final function = ParseCloudFunction('calculateTextLength');
  final params = <String, dynamic>{'text': text};

  final ParseResponse result = await function.execute(parameters: params);
  if (result.success && result.result != null) {
    print('Text length: ${result.result['length']}');
  } else {
    print('Error calling Cloud Code: ${result.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> getTextLength(String text) async {
  final function = ParseCloudFunction('calculateTextLength');
  final params = <String, dynamic>{'text': text};

  final ParseResponse result = await function.execute(parameters: params);
  if (result.success && result.result != null) {
    print('Text length: ${result.result['length']}');
  } else {
    print('Error calling Cloud Code: ${result.error?.message}');
  }
}
﻿
Questo approccio sicuro garantisce che la logica sensibile rimanga sul server, mentre la tua app Flutter effettua semplicemente richieste.
Passo 5 – Configurazione dell'Autenticazione
Abilita l'Autenticazione Utente
Back4app utilizza la Parse.User classe per gestire la registrazione e il login degli utenti. Per impostazione predefinita, Parse si occupa dell'hashing delle password, dei token di sessione e dello storage sicuro.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> signUpUser(String username, String password, String email) async {
  final user = ParseUser(username, password, email);
  final response = await user.signUp();
  if (response.success) {
    print('User signed up successfully!');
  } else {
    print('Sign up error: ${response.error?.message}');
  }
}

Future<void> logInUser(String username, String password) async {
  final user = ParseUser(username, password, null);
  final response = await user.login();
  if (response.success) {
    print('User logged in: ${response.result}');
  } else {
    print('Login error: ${response.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> signUpUser(String username, String password, String email) async {
  final user = ParseUser(username, password, email);
  final response = await user.signUp();
  if (response.success) {
    print('User signed up successfully!');
  } else {
    print('Sign up error: ${response.error?.message}');
  }
}

Future<void> logInUser(String username, String password) async {
  final user = ParseUser(username, password, null);
  final response = await user.login();
  if (response.success) {
    print('User logged in: ${response.result}');
  } else {
    print('Login error: ${response.error?.message}');
  }
}
﻿
Accesso Sociale
Back4app supporta integrazioni con Google, Apple, Facebook e altro. Ogni fornitore ha un approccio specifico e potrebbe richiedere librerie aggiuntive (ad esempio, per l'accesso con Facebook o Google). Puoi quindi chiamare:
Dart
await ParseUser.loginWith('facebook', <String, dynamic>{
  'id': 'USER_FACEBOOK_ID',
  'access_token': 'FACEBOOK_ACCESS_TOKEN',
  'expiration_date': 'DATE'
});
await ParseUser.loginWith('facebook', <String, dynamic>{
  'id': 'USER_FACEBOOK_ID',
  'access_token': 'FACEBOOK_ACCESS_TOKEN',
  'expiration_date': 'DATE'
});
﻿
Regola i parametri secondo la documentazione del fornitore.
Passo 6 – Gestione dello Storage dei File
Impostazione dello Storage dei File
Puoi memorizzare immagini, documenti o altri file multimediali utilizzando ParseFile. Back4app protegge questi file e fornisce un URL per il recupero.
Dart
import 'dart:io';
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:image_picker/image_picker.dart';

Future<void> uploadImage() async {
  final picker = ImagePicker();
  final XFile? pickedFile = await picker.pickImage(source: ImageSource.gallery);
  if (pickedFile == null) {
    print('No file selected.');
    return;
  }

  final parseFile = ParseFile(File(pickedFile.path));
  final response = await parseFile.save();
  if (response.success) {
    print('File saved: ${parseFile.url}');
  } else {
    print('Error uploading file: ${response.error?.message}');
  }
}
import 'dart:io';
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:image_picker/image_picker.dart';

Future<void> uploadImage() async {
  final picker = ImagePicker();
  final XFile? pickedFile = await picker.pickImage(source: ImageSource.gallery);
  if (pickedFile == null) {
    print('No file selected.');
    return;
  }

  final parseFile = ParseFile(File(pickedFile.path));
  final response = await parseFile.save();
  if (response.success) {
    print('File saved: ${parseFile.url}');
  } else {
    print('Error uploading file: ${response.error?.message}');
  }
}
﻿
Considerazioni sulla Sicurezza
Puoi definire chi ha accesso ai file (pubblico, utenti autenticati o riservato) combinando la sicurezza a livello di file con le ACL. Questo garantisce che i tuoi dati sui file rimangano al sicuro.
Passo 7 – Verifica Email e Ripristino Password
Perché Sono Importanti
La verifica dell'email conferma che un utente possiede l'indirizzo email fornito, mentre i flussi di ripristino della password migliorano l'esperienza dell'utente e la sicurezza.
Configurazione del Dashboard
Vai alle Impostazioni Email della tua app nel dashboard di Back4app.
Abilita Verifica Email e Ripristino Password.
Configura i modelli email o il tuo dominio personalizzato se necessario.
Queste impostazioni consentono alla tua app Flutter di gestire automaticamente i controlli di proprietà degli utenti e il recupero della password.
Implementazione in Flutter
Dart
final user = ParseUser('testuser', 'password123', '[email protected]');
final signUpResponse = await user.signUp();
if (signUpResponse.success) {
  // The user will receive a verification email
}

// For password reset
final resetResponse = await ParseUser.requestPasswordReset('[email protected]');
if (resetResponse.success) {
  print('Reset email sent successfully!');
}
final user = ParseUser('testuser', 'password123', 'test@example.com');
final signUpResponse = await user.signUp();
if (signUpResponse.success) {
  // The user will receive a verification email
}

// For password reset
final resetResponse = await ParseUser.requestPasswordReset('test@example.com');
if (resetResponse.success) {
  print('Reset email sent successfully!');
}
﻿
Passo 8 – Pianificazione dei Compiti con Cloud Jobs
Cloud Jobs
Potresti voler pianificare compiti ricorrenti (come la pulizia dei dati obsoleti o l'invio di email periodiche). I Cloud Jobs ti permettono di fare proprio questo:
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);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
// 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);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Distribuisci questo codice, poi vai a Impostazioni App > Impostazioni Server > Lavori in Background nel tuo dashboard di Back4app per programmarlo.
Programmazione di un Lavoro Cloud
﻿
Passo 9 – Integrazione dei Webhook
Cosa Sono i Webhook?
I webhook consentono alla tua app Back4app di inviare richieste HTTP a un servizio esterno quando si verificano determinati eventi (come il salvataggio di un nuovo oggetto). Questo è ideale per l'integrazione con strumenti di terze parti.
Vai a Altro > WebHooks nel tuo dashboard di Back4app e Aggiungi Webhook.
Imposta il tuo endpoint e i trigger (ad es., “Nuovo record in Todo”).
Aggiunta di un Webhook
﻿
Puoi anche configurare manualmente i webhook nel Cloud Code effettuando richieste HTTP nei trigger beforeSave o afterSave.
BeforeSave WebHook
﻿
Passo 10 – Esplorare il Pannello di Amministrazione di Back4App
Dove Trovarlo
L' App di Amministrazione di Back4app è un'interfaccia user-friendly che consente ai membri del team non tecnici di gestire i dati (operazioni CRUD, attività sui dati, ecc.) senza dover aprire il Dashboard di Parse.
Vai a App Dashboard > Altro > App di Amministrazione.
Clicca su Abilita App di Amministrazione.
Abilita App di Amministrazione
﻿
Creerai un utente amministratore, sceglierai un sottodominio e accederai con le credenziali appena create. L'App di Amministrazione aiuta con revisioni e modifiche rapide dei dati.
Conclusione
In questo tutorial, hai imparato come costruire un backend per Flutter utilizzando Back4app e il Parse Flutter SDK. 
Hai creato classi, memorizzato dati, configurato query in tempo reale, applicato sicurezza con ACL e CLP, scritto Cloud Functions, programmato attività, integrato webhook ed esplorato il Pannello di Amministrazione di Back4app. 
Questo approccio accelera lo sviluppo permettendoti di concentrarti sul lato client di Flutter piuttosto che su una complessa configurazione del server.
La stringa finale che hai ora è un backend funzionante e sicuro che sfrutta API RESTful, autenticazione degli utenti e facile manipolazione dei dati. 
Puoi integrare funzionalità più avanzate in qualsiasi momento—come ulteriori Cloud Functions, chiamate API esterne o ruoli personalizzati. 
Prossimi Passi
Vai in produzione: Implementa caching avanzato, analisi o controlli di accesso basati su ruoli.
Estendi la tua app: Integra servizi di terze parti o costruisci più Cloud Functions per logica aziendale specializzata.
Consulta la documentazione di Back4app: Esplora sicurezza avanzata, ottimizzazione delle prestazioni, analisi dei log e altro.
Scopri di più: Dai un'occhiata ai tutorial per app di chat dal vivo, servizi basati sulla posizione o strutture dati più complesse. Combinali con il tuo progetto Flutter per casi d'uso reali.
Continuando a perfezionare questa configurazione, trasformerai la tua app Flutter in una soluzione potente e scalabile costruita su un robusto servizio backend. Buon coding!
Aggiornato 23 Jan 2025
Questa pagina ti è stata di aiuto?
Come costruire un backend per Objective-C?
AVANTI IL PROSSIMO
Come costruire un backend per Gatsby?