保存數據

本文檔介紹了將資料寫入 Firebase 即時資料庫的四種方法：設定、更新、推播和事務支援。

保存資料的方法

放	將資料寫入或替換到定義的路徑，例如messages/users/<username>
更新	更新已定義路徑的一些鍵而不替換所有數據
推	新增到資料庫中的資料列表。每次將新節點推送到清單時，資料庫都會產生一個唯一鍵，例如messages/users/<unique-user-id>/<username>
交易	處理可能因並發更新而損壞的複雜資料時使用事務

儲存數據

基本資料庫寫入操作是將新資料儲存到指定資料庫引用的一組操作，替換該路徑上的任何現有資料。為了理解集合，我們將建立一個簡單的部落格應用程式。您的應用程式的資料儲存在此資料庫引用中：

爪哇

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')

去

// 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")

讓我們從保存一些用戶資料開始。我們將透過唯一的用戶名儲存每個用戶，我們還將儲存他們的全名和出生日期。由於每個用戶都有一個唯一的用戶名，因此在這裡使用 set 方法而不是 Push 方法是有意義的，因為您已經擁有密鑰並且不需要建立密鑰。

首先，建立對使用者資料的資料庫引用。然後使用set() / setValue()將使用者物件以及使用者的使用者名稱、全名和生日儲存到資料庫中。您可以傳遞設定字串、數字、布林值、 null 、陣列或任何 JSON 物件。傳遞null將刪除指定位置的資料。在這種情況下，您將向其傳遞一個物件：

爪哇

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");

Map<String, User> users = new 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'
    }
})

去

// 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)
}

將 JSON 物件儲存到資料庫時，物件屬性會自動以巢狀方式對應到資料庫子位置。現在，如果您導航到 URL https://docs-examples.firebaseio.com/server/ saving-data/fireblog/users/alanisawesome/full_name ，我們將看到值「Alan Turing」。您也可以將資料直接儲存到子位置：

爪哇

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'
})

去

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)
}

上面的兩個範例 - 將兩個值同時作為物件寫入並將它們分別寫入子位置 - 將導致相同的資料儲存到資料庫中：

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

第一個範例將僅在正在監視資料的用戶端上觸發一個事件，而第二個範例將觸發兩個事件。需要注意的是，如果usersRef中已經存在數據，第一種方法將覆蓋它，但第二種方法只會修改每個單獨子節點的值，而保持usersRef的其他子節點不變。

設定該值將覆蓋指定位置的數據，包括任何子節點。

更新已儲存的數據

如果要同時寫入一個資料庫位置的多個子節點而不覆蓋其他子節點，可以使用如下所示的 update 方法：

爪哇

DatabaseReference hopperRef = usersRef.child("gracehop");
Map<String, Object> hopperUpdates = new 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'
})

去

hopperRef := usersRef.Child("gracehop")
if err := hopperRef.Update(ctx, map[string]interface{}{
	"nickname": "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating child:", err)
}

這將更新 Grace 的資料以包含她的暱稱。如果您在此處使用 set 而不是 update ，它會從您的hopperRef中刪除full_name和date_of_birth 。

Firebase 即時資料庫也支援多路徑更新。這意味著 update 現在可以同時更新資料庫中多個位置的值，這是一個強大的功能，可以幫助您對資料進行非規範化。使用多路徑更新，您可以同時為 Grace 和 Alan 添加暱稱：

爪哇

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'
})

去

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)
}

這次更新後，艾倫和格蕾絲都添加了暱稱：

{
  "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"
    }
  }
}

請注意，嘗試透過寫入包含路徑的物件來更新物件將導致不同的行為。讓我們看看如果您嘗試以這種方式更新 Grace 和 Alan 會發生什麼：

爪哇

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'
    }
})

去

if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome": &User{Nickname: "Alan The Machine"},
	"gracehop":      &User{Nickname: "Amazing Grace"},
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

這會導致不同的行為，即覆蓋整個/users節點：

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

更新嵌套數據

給定像alanisawesome這樣的單一鍵路徑，僅更新第一個子層級的數據，並且超出第一個子層級傳入的任何數據都將被視為集合操作。多路徑行為允許使用更長的路徑（如alanisawesome/nickname ）而不覆蓋資料。這就是第一個範例與第二個範例不同的原因。

新增完成回調

在 Node.js 和 Java Admin SDK 中，如果您想知道資料何時提交，可以新增完成回呼。這些 SDK 中的 set 和 update 方法都採用可選的完成回調，該回調會在寫入提交到資料庫時呼叫。如果因為某些原因呼叫不成功，則會向回呼傳遞一個錯誤對象，指示發生失敗的原因。在Python和Go Admin SDK中，所有寫入方法都是阻塞的。也就是說，寫入方法只有在寫入提交到資料庫後才會回傳。

爪哇

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.');
  }
});

儲存資料列表

在建立資料清單時，重要的是要記住大多數應用程式的多用戶性質並相應地調整清單結構。擴展上面的範例，讓我們將部落格文章添加到您的應用程式中。您的第一直覺可能是使用 set 來儲存具有自動遞增整數索引的子項，如下所示：

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

推播與交易

當使用資料列表時push()可確保唯一且依時間順序排列的鍵。您可能會想要使用事務來產生自己的金鑰，但推送是更好的選擇。交易速度更慢且更複雜。它們需要與伺服器進行一次或多次往返。客戶端上的「push()」產生的金鑰可以在離線狀態下工作，並針對效能進行了最佳化。

如果用戶新增新帖子，它將儲存為/posts/2 。如果只有一個作者添加帖子，那麼這將起作用，但在協作部落格應用程式中，許多用戶可能會同時添加帖子。如果兩位作者同時寫入/posts/2 ，那麼其中一篇文章將會被另一篇文章刪除。

為了解決這個問題， Firebase 用戶端提供了一個push()函數，為每個新的 child 產生一個唯一的金鑰。透過使用唯一的子金鑰，多個客戶端可以同時將子金鑰新增至相同位置，而不必擔心寫入衝突。

爪哇

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'
})

去

// 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)
}

唯一鍵是基於時間戳，因此清單項目將自動按時間順序排序。由於 Firebase 為每個部落格文章產生唯一的金鑰，因此如果多個用戶同時添加帖子，則不會發生寫入衝突。您的資料庫資料現在如下所示：

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

在 JavaScript、Python 和 Go 中，呼叫push()然後立即呼叫set()的模式非常常見，Firebase SDK 允許您透過將要設定的資料直接傳遞給push()來組合它們，如下所示：

爪哇

// 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'
})

去

if _, err := postsRef.Push(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

取得push()產生的唯一金鑰

呼叫push()將傳回對新資料路徑的引用，您可以使用它來取得金鑰或為其設定資料。以下程式碼將產生與上面範例相同的數據，但現在我們可以存取生成的唯一密鑰：

爪哇

// 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

去

// 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

如您所見，您可以從push()參考中取得唯一鍵的值。

在關於檢索資料的下一節中，我們將學習如何從 Firebase 資料庫讀取此資料。

保存交易數據

當處理可能因並發修改而損壞的複雜資料（例如增量計數器）時，SDK 提供了事務操作。

在 Java 和 Node.js 中，您為事務操作提供兩個回呼：一個更新函數和一個可選的完成回呼。在Python和Go中，事務操作是阻塞的，因此它只接受更新函數。

更新函數將資料的當前狀態作為參數，並應傳回您想要寫入的新的所需狀態。例如，如果您想增加特定部落格文章的按讚數，您可以撰寫以下交易：

爪哇

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')

去

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)
}

上面的範例檢查計數器是否為null或尚未增加，因為如果沒有寫入預設值，則可以使用null來呼叫交易。

如果上面的程式碼在沒有事務函數的情況下運行，並且兩個客戶端嘗試同時遞增它，則它們都會寫入1作為新值，從而導致遞增一個而不是兩個。

事務函數被多次調用

您的事務處理程序被多次調用，並且必須能夠處理null資料。即使資料庫中存在現有數據，在運行事務函數時也可能不會在本地緩存。

網路連線和離線寫入

在 Node.js 和 Java 中，如果客戶端失去網路連接，您的應用程式將繼續正常運作。 Python 和 Go Admin SDK 需要網路連接，因為它們使用Firebase REST API與資料庫伺服器進行通訊。在沒有網路連線的情況下在 Python 或 Go Admin SDK 上呼叫資料庫操作會導致異常。

Firebase Node.js 和 Java 用戶端維護任何活動資料的自己的內部版本。寫入資料時，請先寫入此本機版本。然後，客戶端會「盡最大努力」將該資料與資料庫和其他客戶端同步。

因此，在任何資料寫入資料庫之前，對資料庫的所有寫入都將立即觸發本機事件。這意味著當您使用 Firebase 編寫應用程式時，無論網路延遲或網路連線如何，您的應用程式都將保持回應。

重新建立連線後，我們將收到適當的事件集，以便客戶端「趕上」當前伺服器狀態，而無需編寫任何自訂程式碼。

保護您的數據

Firebase 即時資料庫具有安全語言，可讓您定義哪些使用者對資料的不同節點具有讀寫存取權。您可以在保護您的資料中閱讀更多相關資訊。