Kurzanleitung: Mobil-/Webclientbibliothek verwenden

In dieser Kurzanleitung wird gezeigt, Sie Firestore einrichten und mit der Android-, iOS- und Web-Clientbibliothek Daten hinzufügen sowie lesen.

Firestore-Datenbank erstellen

  1. Falls noch nicht geschehen, erstellen Sie ein Firebase-Projekt: Klicken Sie in der Firebase Console auf Projekt hinzufügen und folgen Sie der Anleitung auf dem Bildschirm, um ein Firebase-Projekt zu erstellen oder Firebase-Dienste für ein vorhandenes GCP-Projekt hinzuzufügen.

  2. Wählen Sie im Navigationsbereich der Firebase Console Datenbank aus und klicken Sie dann für Firestore auf Datenbank erstellen.

  3. Wählen Sie für Ihre Firestore-Sicherheitsregeln Testmodus aus:

    Testmodus
    Gut für die ersten Schritte mit den Mobil- und Web-Clientbibliotheken, allerdings können Ihre Daten von beliebigen Personen gelesen werden. Prüfen Sie nach dem Test den Abschnitt Daten schützen.
  4. Wählen Sie einen Speicherort für Ihre Datenbank aus.

    • Diese Speicherorteinstellung ist der standardmäßige Ressourcenspeicherort der Google Cloud Platform (GCP) für Ihr Projekt. Beachten Sie, dass dieser Speicherort für GCP-Dienste in Ihrem Projekt verwendet wird, die eine Speicherorteinstellung benötigen, insbesondere Ihr standardmäßiger Cloud Storage-Bucket und Ihre App Engine-Anwendung (die erforderlich ist, wenn Sie Cloud Scheduler verwenden).

    • Wenn Sie keinen Speicherort auswählen können, verfügt Ihr Projekt bereits über einen standardmäßigen Speicherort für GCP-Ressourcen. Er wurde entweder während der Erstellung des Projekts oder beim Einrichten eines anderen Dienstes festgelegt, für den eine Speicherorteinstellung erforderlich ist.

  5. Klicken Sie auf Fertig.

Wenn Sie Firestore aktivieren, wird auch die API im Cloud API Manager aktiviert.

Entwicklungsumgebung einrichten

Fügen Sie Ihrer Anwendung die erforderlichen Abhängigkeiten und Clientbibliotheken hinzu.

Web
  1. Folgen Sie der Anleitung unter Firebase zu meiner Webanwendung hinzufügen.
  2. Fügen Sie der Anwendung die Firebase- und Firestore-Bibliotheken hinzu:
    <script src="https://www.gstatic.com/firebasejs/7.20.-/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/7.20.-/firebase-firestore.js"></script>
    Das Firestore SDK ist auch als NPM-Paket verfügbar.
    npm install firebase@7.20.- --save
    
    Sie müssen Firebase wie Firestore manuell anfordern.
    const firebase = require("firebase");
    // Required for side-effects
    require("firebase/firestore");
    
iOS
  1. Folgen Sie der Anleitung unter Firebase zu meiner iOS-Anwendung hinzufügen.
  2. Fügen Sie Ihrem Podfile den Firestore-Pod hinzu.
    pod 'Firebase/Firestore'
    
    # Optionally, include the Swift extensions if you're using Swift.
    pod 'FirebaseFirestoreSwift'
    
  3. Speichern Sie die Datei und führen Sie den Befehl pod install aus.
Java
Android
  1. Folgen Sie der Anleitung unter Firebase zu meiner Android-Anwendung hinzufügen.
  2. In die Datei build.gradle auf Projektebene muss das Maven-Repository von Google in die Abschnitte buildscript und allprojects aufgenommen werden.
  3. Fügen Sie die Firestore Android-Bibliothek zur Gradle-Datei des Moduls (auf Anwendungsebene, in der Regel app/build.gradle) hinzu:
    implementation 'com.google.firebase:firebase-firestore:21.6.0'
Kotlin+KTX
Android
  1. Folgen Sie der Anleitung unter Firebase zu meiner Android-Anwendung hinzufügen.
  2. In die Datei build.gradle auf Projektebene muss das Maven-Repository von Google in die Abschnitte buildscript und allprojects aufgenommen werden.
  3. Fügen Sie die Firestore Android-Bibliothek zur Gradle-Datei des Moduls (auf Anwendungsebene, in der Regel app/build.gradle) hinzu:
    implementation 'com.google.firebase:firebase-firestore-ktx:21.6.0'

Firestore initialisieren

Initialisieren Sie eine Instanz von Firestore:

Web
// Initialize Firestore through Firebase
firebase.initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###'
});

var db = firebase.firestore();
Informationen zum dauerhaften Sichern von Daten für den Fall, dass die Verbindung des Geräts unterbrochen wird, finden Sie in der Dokumentation Offlinedaten aktivieren.
Swift
import Firebase

FirebaseApp.configure()

let db = Firestore.firestore()
Objective-C
@import Firebase;

// Use Firebase library to configure APIs
[FIRApp configure];

FIRFirestore *defaultFirestore = [FIRFirestore firestore];
  
Java
Android
// Access a Firestore instance from your Activity
  FirebaseFirestore db = FirebaseFirestore.getInstance();
Kotlin+KTX
Android
  // Access a Firestore instance from your Activity
  val db = Firebase.firestore

Daten hinzufügen

In Firestore werden Daten in Dokumenten gespeichert, die wiederum in Sammlungen gespeichert sind. Firestore erstellt Sammlungen und Dokumente implizit, wenn Sie dem Dokument zum ersten Mal Daten hinzufügen. Sie müssen Sammlungen oder Dokumente also nicht explizit anlegen.

Mit dem folgenden Beispielcode können Sie eine neue Sammlung und ein Dokument erstellen.

Web
db.collection("users").add({
    first: "Ada",
    last: "Lovelace",
    born: 1815
})
.then(function(docRef) {
    console.log("Document written with ID: ", docRef.id);
})
.catch(function(error) {
    console.error("Error adding document: ", error);
});
Swift
// Add a new document with a generated ID
var ref: DocumentReference? = nil
ref = db.collection("users").addDocument(data: [
    "first": "Ada",
    "last": "Lovelace",
    "born": 1815
]) { err in
    if let err = err {
        print("Error adding document: \(err)")
    } else {
        print("Document added with ID: \(ref!.documentID)")
    }
}
Objective-C
// Add a new document with a generated ID
__block FIRDocumentReference *ref =
    [[self.db collectionWithPath:@"users"] addDocumentWithData:@{
      @"first": @"Ada",
      @"last": @"Lovelace",
      @"born": @1815
    } completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error adding document: %@", error);
      } else {
        NSLog(@"Document added with ID: %@", ref.documentID);
      }
    }];
  
Java
Android
// Create a new user with a first and last name
Map<String, Object> user = new HashMap<>();
user.put("first", "Ada");
user.put("last", "Lovelace");
user.put("born", 1815);

// Add a new document with a generated ID
db.collection("users")
        .add(user)
        .addOnSuccessListener(new OnSuccessListener<DocumentReference>() {
            @Override
            public void onSuccess(DocumentReference documentReference) {
                Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId());
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.w(TAG, "Error adding document", e);
            }
        });
Kotlin+KTX
Android
// Create a new user with a first and last name
val user = hashMapOf(
        "first" to "Ada",
        "last" to "Lovelace",
        "born" to 1815
)

// Add a new document with a generated ID
db.collection("users")
    .add(user)
    .addOnSuccessListener { documentReference ->
        Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}")
    }
    .addOnFailureListener { e ->
        Log.w(TAG, "Error adding document", e)
    }

Fügen Sie jetzt der Sammlung users ein weiteres Dokument hinzu. Beachten Sie, dass dieses Dokument ein Schlüssel/Wert-Paar (zweiter Vorname) enthält, das im ersten Dokument nicht auftaucht. Dokumente in einer Sammlung können unterschiedliche Informationen enthalten.

Web
// Add a second document with a generated ID.
db.collection("users").add({
    first: "Alan",
    middle: "Mathison",
    last: "Turing",
    born: 1912
})
.then(function(docRef) {
    console.log("Document written with ID: ", docRef.id);
})
.catch(function(error) {
    console.error("Error adding document: ", error);
});
Swift
// Add a second document with a generated ID.
ref = db.collection("users").addDocument(data: [
    "first": "Alan",
    "middle": "Mathison",
    "last": "Turing",
    "born": 1912
]) { err in
    if let err = err {
        print("Error adding document: \(err)")
    } else {
        print("Document added with ID: \(ref!.documentID)")
    }
}
Objective-C
// Add a second document with a generated ID.
__block FIRDocumentReference *ref =
    [[self.db collectionWithPath:@"users"] addDocumentWithData:@{
      @"first": @"Alan",
      @"middle": @"Mathison",
      @"last": @"Turing",
      @"born": @1912
    } completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error adding document: %@", error);
      } else {
        NSLog(@"Document added with ID: %@", ref.documentID);
      }
    }];
  
Java
Android
// Create a new user with a first, middle, and last name
Map<String, Object> user = new HashMap<>();
user.put("first", "Alan");
user.put("middle", "Mathison");
user.put("last", "Turing");
user.put("born", 1912);

// Add a new document with a generated ID
db.collection("users")
        .add(user)
        .addOnSuccessListener(new OnSuccessListener<DocumentReference>() {
            @Override
            public void onSuccess(DocumentReference documentReference) {
                Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId());
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.w(TAG, "Error adding document", e);
            }
        });
Kotlin+KTX
Android
// Create a new user with a first, middle, and last name
val user = hashMapOf(
        "first" to "Alan",
        "middle" to "Mathison",
        "last" to "Turing",
        "born" to 1912
)

// Add a new document with a generated ID
db.collection("users")
    .add(user)
    .addOnSuccessListener { documentReference ->
        Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}")
    }
    .addOnFailureListener { e ->
        Log.w(TAG, "Error adding document", e)
    }

Daten lesen

Um schnell zu prüfen, ob die Daten zu Firestore hinzugefügt wurden, verwenden Sie die Datenansicht in der Firebase Console.

Sie können auch mit der Methode get die gesamte Sammlung abrufen.

Web
db.collection("users").get().then((querySnapshot) => {
    querySnapshot.forEach((doc) => {
        console.log(`${doc.id} => ${doc.data()}`);
    });
});
Swift
db.collection("users").getDocuments() { (querySnapshot, err) in
    if let err = err {
        print("Error getting documents: \(err)")
    } else {
        for document in querySnapshot!.documents {
            print("\(document.documentID) => \(document.data())")
        }
    }
}
Objective-C
[[self.db collectionWithPath:@"users"]
    getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot,
                                 NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error getting documents: %@", error);
      } else {
        for (FIRDocumentSnapshot *document in snapshot.documents) {
          NSLog(@"%@ => %@", document.documentID, document.data);
        }
      }
    }];
  
Java
Android
db.collection("users")
        .get()
        .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
            @Override
            public void onComplete(@NonNull Task<QuerySnapshot> task) {
                if (task.isSuccessful()) {
                    for (QueryDocumentSnapshot document : task.getResult()) {
                        Log.d(TAG, document.getId() + " => " + document.getData());
                    }
                } else {
                    Log.w(TAG, "Error getting documents.", task.getException());
                }
            }
        });
Kotlin+KTX
Android
db.collection("users")
        .get()
        .addOnSuccessListener { result ->
            for (document in result) {
                Log.d(TAG, "${document.id} => ${document.data}")
            }
        }
        .addOnFailureListener { exception ->
            Log.w(TAG, "Error getting documents.", exception)
        }

Daten schützen

Verwenden Sie Firebase Authentication und Firestore-Sicherheitsregeln, um Ihre Daten in Firestore zu schützen.

Hier sind einige grundlegende Regelsätze, die Sie für den Einstieg verwenden können. Sie können Ihre Sicherheitsregeln auf dem Tab "Regeln" der Firebase Console ändern.

Auth erforderlich

// Allow read/write access on all documents to any user signed in to the application
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if request.auth != null;
    }
  }
}

Sperrmodus

// Deny read/write access to all users under any conditions
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if false;
    }
  }
}

Testmodus

// Allow read/write access to all users under any conditions
// Warning: **NEVER** use this rule set in production; it allows
// anyone to overwrite your entire database.
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if true;
    }
  }
}

Videoanleitung ansehen

Eine ausführliche Anleitung zu den ersten Schritten mit den Mobil- und Web-Clientbibliotheken von Firestore erhalten Sie in den folgenden Videoanleitungen:

Web
iOS
Android

Weitere Videos finden Sie im Firebase-YouTube-Kanal.

Weitere Informationen

Vertiefen Sie Ihr Wissen mit folgenden Themen:

  • Codelabs — Erfahren Sie, wie Sie Firestore in einer realen Anwendung nutzen. Verwenden Sie dafür das Codelab für Android, iOS oder Web.
  • Datenmodell – Erfahren Sie mehr über die Strukturierung von Daten in Firestore, einschließlich hierarchischer Daten und untergeordneter Sammlungen.
  • Daten hinzufügen – Erfahren Sie mehr über das Erstellen und Aktualisieren von Daten in Firestore.
  • Daten abrufen – Erfahren Sie mehr über das Abrufen von Daten.
  • Einfache und kumulierende Abfragen ausführen – Erfahren Sie mehr darüber, wie Sie einfache und kumulierende Abfragen ausführen.
  • Abfragen sortieren und begrenzen – Erfahren Sie mehr darüber, wie Sie die von Ihren Abfragen zurückgegebenen Daten sortieren und begrenzen.