Zapisywanie danych

W tym dokumencie opisano 4 metody zapisywania danych w Firebase Realtime Database: set, update, push i obsługę transakcji.

Sposoby oszczędzania danych

ustawianie zapisywać lub zastępować dane w określonej ścieżce, np. messages/users/<username>;
update aktualizować niektóre klucze dla zdefiniowanej ścieżki bez zastępowania wszystkich danych,
push | wypychanie [in descriptive contexts] Dodaj do listy danych w bazie danych. Za każdym razem, gdy dodajesz nowy węzeł do listy, baza danych generuje unikalny klucz, np. messages/users/<unique-user-id>/<username>
transakcja Używaj transakcji podczas pracy ze złożonymi danymi, które mogą zostać uszkodzone przez jednoczesne aktualizacje.

Zapisywanie danych

Podstawowa operacja zapisu w bazie danych to zestaw, który zapisuje nowe dane w określonym odwołaniu do bazy danych, zastępując wszystkie istniejące dane w tej ścieżce. Aby zrozumieć, jak działa metoda set, utworzymy prostą aplikację do blogowania. Dane aplikacji są przechowywane w tym odwołaniu do bazy danych:

Java
final FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("server/saving-data/fireblog");
Node.js
// Import Admin SDK
const { getDatabase } = require('firebase-admin/database');

// Get a database reference to our blog
const db = getDatabase();
const ref = db.ref('server/saving-data/fireblog');
Python
# Import database module.
from firebase_admin import db

# Get a database reference to our blog.
ref = db.reference('server/saving-data/fireblog')
Go
// Create a database client from App.
client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// Get a database reference to our blog.
ref := client.NewRef("server/saving-data/fireblog")

Zacznijmy od zapisania danych użytkowników. Będziemy przechowywać dane każdego użytkownika pod unikalną nazwą użytkownika, a także jego imię i nazwisko oraz datę urodzenia. Każdy użytkownik będzie miał unikalną nazwę, więc warto użyć metody set zamiast push, ponieważ masz już klucz i nie musisz go tworzyć.

Najpierw utwórz odwołanie do bazy danych z danymi użytkownika. Następnie użyj set() / setValue(), aby zapisać obiekt użytkownika w bazie danych z nazwą użytkownika, imieniem i nazwiskiem oraz datą urodzenia. Możesz przekazać ciąg znaków, liczbę, wartość logiczną, null, tablicę lub dowolny obiekt JSON. Przekazanie wartości null spowoduje usunięcie danych w określonej lokalizacji. W tym przypadku przekażesz obiekt:

Java
public static class User {

  public String date_of_birth;
  public String full_name;
  public String nickname;

  public User(String dateOfBirth, String fullName) {
    // ...
  }

  public User(String dateOfBirth, String fullName, String nickname) {
    // ...
  }

}

DatabaseReference usersRef = ref.child("users&qu<ot;);

MapSt>ring, User users = n<>ew HashMap();
users.put("alanisawesome", new User("June 23, 1912", "Alan Turing"));
users.put("gracehop", new User("December 9, 1906", "Grace Hopper"));

usersRef.setValueAsync(users);
Node.js
const usersRef = ref.child('users');
usersRef.set({
  alanisawesome: {
    date_of_birth: 'June 23, 1912',
    full_name: 'Alan Turing'
  },
  gracehop: {
    date_of_birth: 'December 9, 1906',
    full_name: 'Grace Hopper'
  }
});
Python
users_ref = ref.child('users')
users_ref.set({
    'alanisawesome': {
        'date_of_birth': 'June 23, 1912',
        'full_name': 'Alan Turing'
    },
    'gracehop': {
        'date_of_birth': 'December 9, 1906',
        'full_name': 'Grace Hopper'
    }
})
Go
// User is a json-serializable type.
type User struct {
	DateOfBirth string `json:"date_of_birth,omitempty"`
	FullName    string `json:"full_name,omitempty"`
	Nickname    string `json:"nickname,omitempty"`
}

usersRef := ref.Child("users")
err := usersRef.Set(ctx, map[string]*User{
	"alanisawesome": {
		DateOfBirth: "June 23, 1912",
		FullName:    "Alan Turing",
	},
	"gracehop": {
		DateOfBirth: "December 9, 1906",
		FullName:    "Grace Hopper",
	},
})
if err != nil {
	log.Fatalln("Error setting value:", err)
}

Gdy obiekt JSON jest zapisywany w bazie danych, jego właściwości są automatycznie mapowane na podrzędne lokalizacje bazy danych w sposób zagnieżdżony. Jeśli teraz przejdziesz na adres URL https://docs-examples.firebaseio.com/server/saving-data/fireblog/users/alanisawesome/full_name, zobaczysz wartość „Alan Turing”. Możesz też zapisywać dane bezpośrednio w lokalizacji podrzędnej:

Java
usersRef.child("alanisawesome").setValueAsync(new User("June 23, 1912", "Alan Turing"));
usersRef.child("gracehop").setValueAsync(new User("December 9, 1906", "Grace Hopper"));
Node.js
const usersRef = ref.child('users');
usersRef.child('alanisawesome').set({
  date_of_birth: 'June 23, 1912',
  full_name: 'Alan Turing'
});
usersRef.child('gracehop').set({
  date_of_birth: 'December 9, 1906',
  full_name: 'Grace Hopper'
});
Python
users_ref.child('alanisawesome').set({
    'date_of_birth': 'June 23, 1912',
    'full_name': 'Alan Turing'
})
users_ref.child('gracehop').set({
    'date_of_birth': 'December 9, 1906',
    'full_name': 'Grace Hopper'
})
Go
if err := usersRef.Child("alanisawesome")&.Set(ctx, User{
	DateOfBirth: "June 23, 1912",
	FullName:    "Alan Turing",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

if err& := usersRef.Child("gracehop").Set(ctx, User{
	DateOfBirth: "December 9, 1906",
	FullName:    "Grace Hopper",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

Oba powyższe przykłady – zapisywanie obu wartości jednocześnie jako obiektu i zapisywanie ich osobno w lokalizacjach podrzędnych – spowodują zapisanie tych samych danych w bazie danych: 

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper"
    }
  }
}

Pierwszy przykład wywoła tylko jedno zdarzenie na klientach, którzy obserwują dane, natomiast drugi przykład wywoła 2 zdarzenia. Pamiętaj, że jeśli dane już istnieją w usersRef, pierwsze podejście spowoduje ich zastąpienie, ale druga metoda zmodyfikuje tylko wartość każdego osobnego węzła podrzędnego, pozostawiając inne elementy podrzędne usersRef bez zmian.

Aktualizowanie zapisanych danych

Jeśli chcesz zapisywać dane w wielu elementach podrzędnych lokalizacji bazy danych jednocześnie bez zastępowania innych węzłów podrzędnych, możesz użyć metody aktualizacji, jak pokazano poniżej:

Java
DatabaseReference hopperRef = usersRef.child("gracehop&q<uot;);
MapStri>ng, Object hopperUpdates = n<>ew HashMap();
hopperUpdates.put("nickname", "Amazing Grace");

hopperRef.updateChildrenAsync(hopperUpdates);
Node.js
const usersRef = ref.child('users');
const hopperRef = usersRef.child('gracehop');
hopperRef.update({
  'nickname': 'Amazing Grace'
});
Python
hopper_ref = users_ref.child('gracehop')
hopper_ref.update({
    'nickname': 'Amazing Grace'
})
Go
hopperRef := usersRef.Child("gracehop")
if err := hopperRef.Update(ctx, map[string]interface{}{
	"nickname": "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating child:", err)
}

Spowoduje to zaktualizowanie danych Grace, aby zawierały jej pseudonim. Jeśli zamiast update użyjesz set, spowoduje to usunięcie zarówno full_name, jak i date_of_birth z hopperRef.

Firebase Realtime Database obsługuje też aktualizacje wielościeżkowe. Oznacza to, że metoda update może teraz aktualizować wartości w wielu lokalizacjach w bazie danych jednocześnie. Jest to zaawansowana funkcja, która pomaga denormalizować dane. Korzystając z aktualizacji wielościeżkowych, możesz jednocześnie dodać pseudonimy do kont Grace i Alana:

Java
Map<String, Object> userUpdates = new HashMap<>();
userUpdates.put("alanisawesome/nickname", "Alan The Machine");
userUpdates.put("gracehop/nickname", "Amazing Grace");

usersRef.updateChildrenAsync(userUpdates);
Node.js
const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome/nickname': 'Alan The Machine',
  'gracehop/nickname': 'Amazing Grace'
});
Python
users_ref.update({
    'alanisawesome/nickname': 'Alan The Machine',
    'gracehop/nickname': 'Amazing Grace'
})
Go
if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome/nickname": "Alan The Machine",
	"gracehop/nickname":      "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

Po tej aktualizacji Alan i Grace mają dodane pseudonimy: 

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing",
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper",
      "nickname": "Amazing Grace"
    }
  }
}

Pamiętaj, że próba aktualizacji obiektów przez zapisanie obiektów z uwzględnionymi ścieżkami spowoduje inne działanie. Zobaczmy, co się stanie, jeśli spróbujesz zaktualizować dane Grace i Alana w ten sposób:

Java
Map<String, Object> userNicknameUpdates = new HashMap<>();
userNicknameUpdates.put("alanisawesome", new User(null, null, "Alan The Machine"));
userNicknameUpdates.put("gracehop", new User(null, null, "Amazing Grace"));

usersRef.updateChildrenAsync(userNicknameUpdates);
Node.js
const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome': {
    'nickname': 'Alan The Machine'
  },
  'gracehop': {
    'nickname': 'Amazing Grace'
  }
});
Python
users_ref.update({
    'alanisawesome': {
        'nickname': 'Alan The Machine'
    },
    'gracehop': {
        'nickname': 'Amazing Grace'
    }
})
Go
if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisaweso&me": User{Nickname: "Alan The Machine"}&,
	"gracehop":      User{Nickname: "Amazing Grace"},
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

Spowoduje to inne działanie, czyli zastąpienie całego węzła /users: 

{
  "users": {
    "alanisawesome": {
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "nickname": "Amazing Grace"
    }
  }
}

Dodawanie wywołania zwrotnego po zakończeniu

W pakietach Node.js i Java Admin SDK możesz dodać wywołanie zwrotne, aby dowiedzieć się, kiedy dane zostały zatwierdzone. Zarówno metody set, jak i update w tych pakietach SDK przyjmują opcjonalne wywołanie zwrotne, które jest wywoływane po zatwierdzeniu zapisu w bazie danych. Jeśli z jakiegoś powodu wywołanie się nie powiedzie, do wywołania zwrotnego zostanie przekazany obiekt błędu z informacją o przyczynie niepowodzenia. W pakietach Admin SDK dla Pythona i Go wszystkie metody zapisu są blokujące. Oznacza to, że metody zapisu nie zwracają danych, dopóki zapisy nie zostaną zatwierdzone w bazie danych.

Java
DatabaseReference dataRef = ref.child("data");
dataRef.setValue("I'm writing data", new DatabaseReference.CompletionListener() {
  @Override
  public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {
    if (databaseError != null) {
      System.out.println("Data could not be saved " + databaseError.getMessage());
    } else {
      System.out.println("Data saved successfully.");
    }
  }
});
Node.js
dataRef.set('I\'m writing data'>;, (error) = {
  if (error) {
    console.log('Data could not be saved.' + error);
  } else {
    console.log('Data saved successfully.');
  }
});

Zapisywanie list danych

Podczas tworzenia list danych należy pamiętać o tym, że większość aplikacji jest przeznaczona dla wielu użytkowników, i odpowiednio dostosować strukturę listy. Rozwijając powyższy przykład, dodajmy do aplikacji posty na blogu. Pierwszym odruchem może być użycie metody set do przechowywania elementów podrzędnych z automatycznie zwiększanymi indeksami liczb całkowitych, jak w tym przykładzie: 

// NOT RECOMMENDED - use push() instead!
{
  "posts": {
    "0": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "1": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

Jeśli użytkownik doda nowy post, zostanie on zapisany jako /posts/2. To rozwiązanie sprawdziłoby się, gdyby posty dodawał tylko jeden autor, ale w aplikacji do wspólnego blogowania wielu użytkowników może dodawać posty jednocześnie. Jeśli 2 autorów pisze jednocześnie do /posts/2, jeden z postów zostanie usunięty przez drugi.

Aby rozwiązać ten problem, klienci Firebase udostępniają funkcję push(), która generuje unikalny klucz dla każdego nowego elementu podrzędnego. Dzięki unikalnym kluczom podrzędnym kilku klientów może jednocześnie dodawać elementy podrzędne do tej samej lokalizacji bez obaw o konflikty zapisu.

Java
public static class Post {

  public String author;
  public String title;

  public Post(String author, String title) {
    // ...
  }

}

DatabaseReference postsRef = ref.child("posts");

DatabaseReference newPostRef = postsRef.push();
newPostRef.setValueAsync(new Post("gracehop", "Announcing COBOL, a New Programming Language"));

// We can also chain the two calls together
postsRef.push().setValueAsync(new Post("alanisawesome", "The Turing Machine"));
Node.js
const newPostRef = postsRef.push();
newPostRef.set({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});

// we can also chain the two calls together
postsRef.push().set({
  author: 'alanisawesome',
  title: 'The Turing Machine'
});
Python
posts_ref = ref.child('posts')

new_post_ref = posts_ref.push()
new_post_ref.set({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})

# We can also chain the two calls together
posts_ref.push().set({
    'author': 'alanisawesome',
    'title': 'The Turing Machine'
})
Go
// Post is a json-serializable type.
type Post struct {
	Author string `json:"author,omitempty"`
	Title  string `json:"title,omitempty"`
}

postsRef := ref.Child("posts")

newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:"&, err)
}

if err := newPostRef.Set(ctx, Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

// We &can also chain the two calls together
if _, err := postsRef.Push(ctx, Post{
	Author: "alanisawesome",
	Title:  "The Turing Machine",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

Unikalny klucz jest oparty na sygnaturze czasowej, więc elementy listy będą automatycznie uporządkowane chronologicznie. Firebase generuje unikalny klucz dla każdego posta na blogu, więc nie wystąpią żadne konflikty zapisu, jeśli wielu użytkowników doda post w tym samym czasie. Dane w bazie danych wyglądają teraz tak: 

{
  "posts": {
    "-JRHTHaIs-jNPLXOQivY": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "-JRHTHaKuITFIhnj02kE": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

W językach JavaScript, Python i Go wzorzec wywoływania push(), a następnie natychmiastowego wywoływania set() jest tak powszechny, że pakiet SDK Firebase umożliwia ich połączenie przez przekazanie danych do ustawienia bezpośrednio do push() w następujący sposób:

Java
// No Java equivalent
Node.js
// This is equivalent to the calls to push().set(...) above
postsRef.push({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});;
Python
# This is equivalent to the calls to push().set(...) above
posts_ref.push({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})
Go
if _, err := postsRef.Push(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

Pobieranie unikalnego klucza wygenerowanego przez push()

Wywołanie push() zwróci odwołanie do nowej ścieżki danych, której możesz użyć do uzyskania klucza lub ustawienia danych. Ten kod spowoduje wyświetlenie tych samych danych co w przykładzie powyżej, ale teraz będziemy mieć dostęp do wygenerowanego unikalnego klucza:

Java
// Generate a reference to a new location and add some data using push()
DatabaseReference pushedPostRef = postsRef.push();

// Get the unique ID generated by a push()
String postId = pushedPostRef.getKey();
Node.js
// Generate a reference to a new location and add some data using push()
const newPostRef = postsRef.push();

// Get the unique key generated by push()
const postId = newPostRef.key;
Python
# Generate a reference to a new location and add some data using push()
new_post_ref = posts_ref.push()

# Get the unique key generated by push()
post_id = new_post_ref.key
Go
// Generate a reference to a new location and add some data using Push()
newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:", err)
}

// Get the unique key generated by Push()
postID := newPostRef.Key

Jak widać, wartość unikalnego klucza możesz uzyskać z odwołania push().

W następnej sekcji, Pobieranie danych, dowiesz się, jak odczytywać te dane z bazy danych Firebase.

Zapisywanie danych transakcyjnych

Podczas pracy ze złożonymi danymi, które mogą zostać uszkodzone przez równoczesne modyfikacje, np. licznikami przyrostowymi, pakiet SDK udostępnia operację transakcji.

W językach Java i Node.js operacja transakcji otrzymuje 2 wywołania zwrotne: funkcję aktualizacji i opcjonalne wywołanie zwrotne zakończenia. W językach Python i Go operacja transakcji jest blokująca, dlatego akceptuje tylko funkcję aktualizacji.

Funkcja aktualizacji przyjmuje bieżący stan danych jako argument i powinna zwracać nowy stan, który chcesz zapisać. Jeśli na przykład chcesz zwiększyć liczbę głosów za konkretnym postem na blogu, możesz napisać transakcję podobną do tej:

Java
DatabaseReference upvotesRef = ref.child("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes");
upvotesRef.runTransaction(new Transaction.Handler() {
  @Override
  public Transaction.Result doTransaction(MutableData mutableData) {
    Integer currentValue = mutableData.getValue(Integer.class);
    if (currentValue == null) {
      mutableData.setValue(1);
    } else {
      mutableData.setValue(currentValue + 1);
    }

    return Transaction.success(mutableData);
  }

  @Override
  public void onComplete(
      DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) {
    System.out.println("Transaction completed");
  }
});
Node.js
const upvotesRef = db.ref('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes');
upvotesRef.transaction((current_>value) = {
  return (current_value || 0) + 1;
});
Python
def increment_votes(current_value):
    return current_value + 1 if current_value else 1

upvotes_ref = db.reference('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes')
try:
    new_vote_count = upvotes_ref.transaction(increment_votes)
    print('Transaction completed')
except db.TransactionAbortedError:
    print('Transaction failed to commit')
Go
fn := func(t db.TransactionNode) (interface{}, error) {
	var currentValue int
	if err := t.Unmarshal(&currentValue); err != nil {
		return nil, err
	}
	return currentValue + 1, nil
}

ref := client.NewRef("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes")
if err := ref.Transaction(ctx, fn); err != nil {
	log.Fatalln("Transaction failed to commit:", err)
}

W przykładzie powyżej sprawdzamy, czy licznik ma wartość null lub czy nie został jeszcze zwiększony, ponieważ transakcje mogą być wywoływane z wartością null, jeśli nie została zapisana wartość domyślna.

Jeśli powyższy kod zostałby uruchomiony bez funkcji transakcji i 2 klientów próbowałoby jednocześnie zwiększyć wartość, obaj zapisaliby 1 jako nową wartość, co spowodowałoby jednokrotne zwiększenie wartości zamiast dwukrotnego.

Połączenia sieciowe i zapisy offline

Klienci Firebase Node.js i Java utrzymują własną wewnętrzną wersję wszystkich aktywnych danych. Gdy dane są zapisywane, najpierw są zapisywane w tej wersji lokalnej. Następnie klient synchronizuje te dane z bazą danych i innymi klientami, starając się to zrobić jak najlepiej.

W rezultacie wszystkie operacje zapisu w bazie danych będą natychmiast wywoływać zdarzenia lokalne, zanim jeszcze jakiekolwiek dane zostaną zapisane w bazie danych. Oznacza to, że gdy piszesz aplikację za pomocą Firebase, będzie ona działać niezależnie od opóźnień sieci czy połączenia z internetem.

Po ponownym nawiązaniu połączenia otrzymamy odpowiedni zestaw zdarzeń, dzięki czemu klient „dogoni” bieżący stan serwera bez konieczności pisania niestandardowego kodu.

Zabezpieczanie danych

Firebase Realtime Database ma język zabezpieczeń, który pozwala określić, którzy użytkownicy mają dostęp do odczytu i zapisu w różnych węzłach danych. Więcej informacji na ten temat znajdziesz w artykule Zabezpieczanie danych.