Odczyt i zapis danych na platformach Apple

(Opcjonalnie) Prototypowanie i testowanie za pomocą Firebase Local Emulator Suite

Zanim omówimy, jak aplikacja odczytuje i zapisze dane w Realtime Database, zapoznamy Cię z zestawem narzędzi, które możesz wykorzystać do tworzenia prototypów i testowania funkcji Realtime Database: Firebase Local Emulator Suite. Jeśli testujesz różne modele danych, optymalizujesz reguły bezpieczeństwa lub szukasz najbardziej opłacalnego sposobu interakcji z back-endem, warto pracować lokalnie bez wdrażania usług na żywo.

Emulator Realtime Database jest częścią Local Emulator Suite, który umożliwia aplikacji interakcję z treścią i konfiguracją emulowanej bazy danych, a także opcjonalnie emulowanymi zasobami projektu (funkcjami, innymi bazami danych i regułami zabezpieczeń).

Korzystanie z emulatora Realtime Database wymaga wykonania kilku czynności:

1. Dodanie linii kodu do konfiguracji testowej aplikacji, aby połączyć się z emulatorem.
2. W katalogu głównym lokalnego katalogu projektu uruchom firebase emulators:start.
3. Wykonywanie wywołań z prototypowego kodu aplikacji za pomocą platformy Realtime Database SDK lub interfejsu API REST Realtime Database.

Dostępny jest szczegółowy samouczek dotyczący funkcji Realtime Database i Cloud Functions. Zapoznaj się też z Local Emulator Suitewprowadzeniem.

Pobieranie obiektu FIRDatabaseReference

Aby móc odczytywać lub zapisywać dane z bazy danych, potrzebujesz instancji FIRDatabaseReference:

var ref: DatabaseReference!

ref = Database.database().reference()

@property (strong, nonatomic) FIRDatabaseReference *ref;

self.ref = [[FIRDatabase database] reference];

Zapisywanie danych

W tym dokumencie znajdziesz podstawowe informacje o odczytywaniu i zapisywaniu danych Firebase.

Dane Firebase są zapisywane w odwołaniu Database i pobierane przez dołączenie do niego odbiornika asynchronicznego. Listener jest uruchamiany raz w przypadku początkowego stanu danych i po raz kolejny, gdy dane ulegną zmianie.

Podstawowe operacje zapisu

W przypadku podstawowych operacji zapisu możesz użyć polecenia setValue, aby zapisać dane w określonym odwołaniu, zastępując wszystkie dotychczasowe dane w tej ścieżce. Dzięki tej metodzie możesz:

• Typy przepustki odpowiadające dostępnym typom danych JSON:
  • NSString
  • NSNumber
  • NSDictionary
  • NSArray

Użytkownika z polem setValue możesz dodać w ten sposób:

self.ref.child("users").child(user.uid).setValue(["username": username])

[[[self.ref child:@"users"] child:authResult.user.uid]
    setValue:@{@"username": username}];

Użycie setValue w ten sposób powoduje zastąpienie danych w wybranej lokalizacji, w tym wszystkich węzłów podrzędnych. Nadal jednak możesz zaktualizować element podrzędny bez przepisywania całego obiektu. Jeśli chcesz zezwolić użytkownikom na aktualizowanie swoich profili, możesz zmienić nazwę użytkownika w ten sposób:

self.ref.child("users/\(user.uid)/username").setValue(username)

[[[[_ref child:@"users"] child:user.uid] child:@"username"] setValue:username];

Odczytywanie danych

Odczytywanie danych przez nasłuchiwanie zdarzeń wartości

Aby odczytywać dane na ścieżce i nasłuchiwać zmian, użyj funkcji observeEventType:withBlock w FIRDatabaseReference, aby obserwować zdarzenia FIRDataEventTypeValue.

Zdarzenia FIRDataEventTypeValue możesz użyć do odczytania danych na danej ścieżce w stanie, w jakim były w momencie wystąpienia zdarzenia. Ta metoda jest wywoływana raz, gdy listener zostanie dołączony, i ponownie za każdym razem, gdy dane, w tym elementy podrzędne, ulegną zmianie. Do funkcji wywołania zwrotnego zdarzenia przekazywany jest obiekt snapshot zawierający wszystkie dane w tej lokalizacji, w tym dane podrzędne. Jeśli nie ma żadnych danych, podsumowanie zwróci wartość false, gdy wywołasz funkcję exists(), i nil, gdy odczytasz jej właściwość value.

Ten przykład pokazuje aplikację do blogowania społecznościowego, która pobiera szczegóły wpisu z bazy danych:

refHandle = postRef.observe(DataEventType.value, with: { snapshot in
  // ...
})

_refHandle = [_postRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot * _Nonnull snapshot) {
  NSDictionary *postDict = snapshot.value;
  // ...
}];

Listener otrzymuje obiekt FIRDataSnapshot, który zawiera dane z określonej lokalizacji w bazie danych w momencie zdarzenia w usłudze value. Wartości możesz przypisać do odpowiedniego typu natywnego, np. NSDictionary. Jeśli w danej lokalizacji nie ma żadnych danych, wartość value wynosi nil.

odczytywanie danych raz;

Odczyt jednorazowo za pomocą getData()

Pakiet SDK służy do zarządzania interakcjami z serwerami baz danych, niezależnie od tego, czy aplikacja jest online, czy offline.

Ogólnie rzecz biorąc, do odczytywania danych i otrzymywania powiadomień o aktualizacjach danych z backendu należy używać opisanych powyżej technik dotyczących wartości zdarzeń. Te techniki zmniejszają wykorzystanie i obciążenia, a także są zoptymalizowane pod kątem zapewnienia użytkownikom jak najlepszego wrażenia podczas korzystania z usługi online i offline.

Jeśli dane są potrzebne tylko raz, możesz użyć funkcji getData(), aby uzyskać podsumowanie danych z bazy danych. Jeśli z jakiegokolwiek powodu getData() nie może zwrócić wartości serwera, klient sprawdzi pamięć podręczną lokalnego magazynu i zwróci błąd, jeśli wartość nadal nie zostanie znaleziona.

Ten przykład pokazuje jednorazowe pobranie publicznej nazwy użytkownika z bazy danych:

do {
  let snapshot = try await ref.child("users/\(uid)/username").getData()
  let userName = snapshot.value as? String ?? "Unknown"
} catch {
  print(error)
}

NSString *userPath = [NSString stringWithFormat:@"users/%@/username", uid];
[[ref child:userPath] getDataWithCompletionBlock:^(NSError * _Nullable error, FIRDataSnapshot * _Nonnull snapshot) {
  if (error) {
    NSLog(@"Received an error %@", error);
    return;
  }
  NSString *userName = snapshot.value;
}];

Niepotrzebne używanie funkcji getData() może zwiększyć wykorzystanie przepustowości i spowodować spadek wydajności. Można temu zapobiec, używając odbiorcy w czasie rzeczywistym, jak pokazano powyżej.

jednokrotne odczytywanie danych z obserwatorem;

W niektórych przypadkach możesz chcieć, aby wartość z lokalnej pamięci podręcznej była zwracana natychmiast zamiast sprawdzać zaktualizowaną wartość na serwerze. W takich przypadkach możesz użyć polecenia observeSingleEventOfType, aby natychmiast pobrać dane z lokalnego dysku podręcznego.

Jest to przydatne w przypadku danych, które trzeba wczytać tylko raz i nie będą się często zmieniać ani wymagać aktywnego słuchania. Na przykład aplikacja do blogowania w poprzednich przykładach używa tej metody do wczytania profilu użytkownika, gdy ten zaczyna pisać nowy post:

let userID = Auth.auth().currentUser?.uid
ref.child("users").child(userID!).observeSingleEvent(of: .value, with: { snapshot in
  // Get user value
  let value = snapshot.value as? NSDictionary
  let username = value?["username"] as? String ?? ""
  let user = User(username: username)

  // ...
}) { error in
  print(error.localizedDescription)
}

NSString *userID = [FIRAuth auth].currentUser.uid;
[[[_ref child:@"users"] child:userID] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot * _Nonnull snapshot) {
  // Get user value
  User *user = [[User alloc] initWithUsername:snapshot.value[@"username"]];

  // ...
} withCancelBlock:^(NSError * _Nonnull error) {
  NSLog(@"%@", error.localizedDescription);
}];

Aktualizowanie i usuwanie danych

Aktualizowanie konkretnych pól

Aby jednocześnie zapisywać dane w określonych węzłach podrzędnych bez nadpisywania innych węzłów podrzędnych, użyj metody updateChildValues.

Gdy wywołujesz updateChildValues, możesz zaktualizować wartości podrzędne niższego poziomu, podając ścieżkę klucza. Jeśli dane są przechowywane w kilku lokalizacjach, aby zapewnić lepszą skalowalność, możesz zaktualizować wszystkie wystąpienia tych danych za pomocą rozgałęzienia danych. Na przykład aplikacja do obsługi blogów społecznościowych może chcieć utworzyć posta i jednocześnie zaktualizować go do kanału ostatniej aktywności i kanału aktywności użytkownika publikującego. W tym celu aplikacja do prowadzenia bloga używa kodu takiego jak ten:

guard let key = ref.child("posts").childByAutoId().key else { return }
let post = ["uid": userID,
            "author": username,
            "title": title,
            "body": body]
let childUpdates = ["/posts/\(key)": post,
                    "/user-posts/\(userID)/\(key)/": post]
ref.updateChildValues(childUpdates)

NSString *key = [[_ref child:@"posts"] childByAutoId].key;
NSDictionary *post = @{@"uid": userID,
                       @"author": username,
                       @"title": title,
                       @"body": body};
NSDictionary *childUpdates = @{[@"/posts/" stringByAppendingString:key]: post,
                               [NSString stringWithFormat:@"/user-posts/%@/%@/", userID, key]: post};
[_ref updateChildValues:childUpdates];

W tym przykładzie użyto metody childByAutoId do utworzenia w węźle posta z postami dla wszystkich użytkowników w domenie /posts/$postid oraz jednoczesnego pobrania klucza za pomocą funkcji getKey(). Klucz można następnie wykorzystać do utworzenia drugiego wpisu w postach użytkownika na stronie /user-posts/$userid/$postid.

Dzięki tym ścieżkom możesz przeprowadzać jednoczesne aktualizacje wielu lokalizacji w drzewie JSON za pomocą jednego wywołania funkcji updateChildValues, jak w tym przykładzie, w którym tworzy nowy post w obu lokalizacjach. Aktualizacje wprowadzane w ten sposób są niepodzielne: albo wszystkie aktualizacje zakończą się sukcesem, albo wszystkie się kończą.

Dodaj blok ukończenia

Jeśli chcesz wiedzieć, kiedy dane zostały zapisane, możesz dodać blok zakończenia. Zarówno setValue, jak i updateChildValues przyjmują opcjonalny blok zakończenia, który jest wywoływany po zaakceptowaniu zapisu w bazie danych. Ten odbiorca może być przydatny do śledzenia, które dane zostały zapisane, a które są nadal synchronizowane. Jeśli wywołanie zakończy się niepowodzeniem, do odbiorcy zostanie przekazany obiekt błędu wskazujący, dlaczego wystąpił błąd.

do {
  try await ref.child("users").child(user.uid).setValue(["username": username])
  print("Data saved successfully!")
} catch {
  print("Data could not be saved: \(error).")
}

[[[_ref child:@"users"] child:user.uid] setValue:@{@"username": username} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
  if (error) {
    NSLog(@"Data could not be saved: %@", error);
  } else {
    NSLog(@"Data saved successfully.");
  }
}];

Usuń dane

Najprostszym sposobem usuwania danych jest wywołanie funkcji removeValue z odniesieniem do lokalizacji tych danych.

Możesz też usunąć wartość, podając nil jako wartość dla innej operacji zapisu, takiej jak setValue lub updateChildValues. Możesz używać tej metody razem z funkcją updateChildValues, aby usunąć wiele elementów podrzędnych w jednym wywołaniu interfejsu API.

Odłącz detektory

Obserwatorzy nie przerywają automatycznie synchronizowania danych, gdy opuszczasz ViewController. Jeśli obserwator nie zostanie prawidłowo usunięty, nadal będzie synchronizować dane z pamięci lokalnej. Gdy obserwator nie jest już potrzebny, usuń go, przekazując powiązany element FIRDatabaseHandle do metody removeObserverWithHandle.

Gdy dodasz do odwołania blok wywołania zwrotnego, zwrócony zostanie element FIRDatabaseHandle. Za pomocą tych uchwytów można usunąć blok wywołania zwrotnego.

Jeśli do odniesienia do bazy danych dodano wielu detektorów, każdy z nich jest wywoływany po wywołaniu zdarzenia. Aby zatrzymać synchronizację danych w tej lokalizacji, musisz usunąć wszystkich obserwatorów w tej lokalizacji, wywołując metodę removeAllObservers.

Wywołanie metody removeObserverWithHandle lub removeAllObservers na słuchaczu nie powoduje automatycznego usunięcia słuchaczy zarejestrowanych w podrzędnych węzłach. Musisz też śledzić te odwołania lub uchwyty, aby je usunąć.

Zapisywanie danych jako transakcji

Podczas pracy z danymi, które mogą zostać uszkodzone przez równoległe modyfikacje, np. z licznikami przyrostowymi, możesz użyć operacji transakcji. Ta operacja wymaga podania 2 argumentów: funkcji aktualizacji i opcjonalnego wywołania zwrotnego po zakończeniu. Funkcja update przyjmuje jako argument bieżący stan danych i zwraca nowy pożądany stan, który chcesz zapisać.

Na przykład w przypadku aplikacji do prowadzenia bloga społecznościowego możesz zezwolić użytkownikom na oznaczanie postów gwiazdką i usuwanie tej oceny oraz śledzenie, ile gwiazdek otrzymał dany post. W tym celu:

ref.runTransactionBlock({ (currentData: MutableData) -> TransactionResult in
  if var post = currentData.value as? [String: AnyObject],
    let uid = Auth.auth().currentUser?.uid {
    var stars: [String: Bool]
    stars = post["stars"] as? [String: Bool] ?? [:]
    var starCount = post["starCount"] as? Int ?? 0
    if let _ = stars[uid] {
      // Unstar the post and remove self from stars
      starCount -= 1
      stars.removeValue(forKey: uid)
    } else {
      // Star the post and add self to stars
      starCount += 1
      stars[uid] = true
    }
    post["starCount"] = starCount as AnyObject?
    post["stars"] = stars as AnyObject?

    // Set value and report transaction success
    currentData.value = post

    return TransactionResult.success(withValue: currentData)
  }
  return TransactionResult.success(withValue: currentData)
}) { error, committed, snapshot in
  if let error = error {
    print(error.localizedDescription)
  }
}

[ref runTransactionBlock:^FIRTransactionResult * _Nonnull(FIRMutableData * _Nonnull currentData) {
  NSMutableDictionary *post = currentData.value;
  if (!post || [post isEqual:[NSNull null]]) {
    return [FIRTransactionResult successWithValue:currentData];
  }

  NSMutableDictionary *stars = post[@"stars"];
  if (!stars) {
    stars = [[NSMutableDictionary alloc] initWithCapacity:1];
  }
  NSString *uid = [FIRAuth auth].currentUser.uid;
  int starCount = [post[@"starCount"] intValue];
  if (stars[uid]) {
    // Unstar the post and remove self from stars
    starCount--;
    [stars removeObjectForKey:uid];
  } else {
    // Star the post and add self to stars
    starCount++;
    stars[uid] = @YES;
  }
  post[@"stars"] = stars;
  post[@"starCount"] = @(starCount);

  // Set value and report transaction success
  currentData.value = post;
  return [FIRTransactionResult successWithValue:currentData];
} andCompletionBlock:^(NSError * _Nullable error,
                       BOOL committed,
                       FIRDataSnapshot * _Nullable snapshot) {
  // Transaction completed
  if (error) {
    NSLog(@"%@", error.localizedDescription);
  }
}];

Transakcja zapobiega błędnemu zliczaniu gwiazdek, jeśli więcej użytkowników oznaczy gwiazdką ten sam post w tym samym czasie lub jeśli klient ma nieaktualne dane. Wartość zawarta w klasie FIRMutableData to początkowo ostatnia znana wartość ścieżki klienta lub nil, jeśli takiej wartości nie ma. Serwer porównuje wartość początkową z jej bieżącą wartością i akceptuje transakcję, jeśli wartości są zgodne, lub odrzuca ją. Jeśli transakcja zostanie odrzucona, serwer zwróci bieżącą wartość klientowi, który ponownie wykona transakcję z aktualną wartością. Proces ten powtarza się, dopóki transakcja nie zostanie zaakceptowana lub nie zostanie podjęta zbyt duża liczba prób.

Atomic przyrosty po stronie serwera

W tym przypadku do bazy danych zapisujemy 2 wartości: identyfikator użytkownika, który oznaczył post gwiazdką lub odznaczył go gwiazdką, oraz zwiększoną liczbę gwiazdek. Jeśli wiemy, że użytkownik oznaczył post jako ulubiony, możemy użyć operacji atomowej zwiększania zamiast transakcji.

let updates = [
  "posts/\(postID)/stars/\(userID)": true,
  "posts/\(postID)/starCount": ServerValue.increment(1),
  "user-posts/\(postID)/stars/\(userID)": true,
  "user-posts/\(postID)/starCount": ServerValue.increment(1)
] as [String : Any]
Database.database().reference().updateChildValues(updates)

NSDictionary *updates = @{[NSString stringWithFormat: @"posts/%@/stars/%@", postID, userID]: @TRUE,
                        [NSString stringWithFormat: @"posts/%@/starCount", postID]: [FIRServerValue increment:@1],
                        [NSString stringWithFormat: @"user-posts/%@/stars/%@", postID, userID]: @TRUE,
                        [NSString stringWithFormat: @"user-posts/%@/starCount", postID]: [FIRServerValue increment:@1]};
[[[FIRDatabase database] reference] updateChildValues:updates];

Ten kod nie korzysta z operacji transakcji, więc nie jest automatycznie ponownie uruchamiany, jeśli wystąpiła aktualizacja powodująca konflikt. Operacja zwiększania wartości występuje jednak bezpośrednio na serwerze bazy danych, więc nie ma możliwości wystąpienia konfliktu.

Jeśli chcesz wykrywać i odrzucać konflikty dotyczące aplikacji (np. gdy użytkownik oznacza posta gwiazdką już wcześniej), musisz utworzyć niestandardowe reguły zabezpieczeń odpowiednie do tego zastosowania.

Praca z danymi w trybie offline

Jeśli klient utraci połączenie z siecią, Twoja aplikacja będzie nadal działać prawidłowo.

Każdy klient połączony z bazą danych Firebase zachowuje własną, wewnętrzną wersję wszystkich aktywnych danych. Dane są najpierw zapisywane w tej wersji lokalnej. Klient Firebase synchronizuje te dane ze zdalnymi serwerami baz danych i innymi klientami w ramach najlepszych starań.

W rezultacie wszystkie zapisy w bazie danych powodują natychmiastowe wywołanie zdarzeń lokalnych, zanim jakiekolwiek dane zostaną zapisane na serwerze. Oznacza to, że aplikacja pozostaje responsywna niezależnie od opóźnień w sieci lub połączenia.

Po ponownym nawiązaniu połączenia aplikacja otrzymuje odpowiedni zestaw zdarzeń, dzięki czemu klient synchronizuje się z bieżącym stanem serwera, bez konieczności pisania kodu niestandardowego.

Więcej informacji o działaniu offline znajdziesz w artykule Więcej informacji o możliwościach online i offline.

Następne kroki

• Praca z listami danych
• Dowiedz się, jak uporządkować dane
• Więcej informacji o możliwościach online i offline