本頁面由 Cloud Translation API 翻譯而成。
Switch to English

保存數據

本文檔涵蓋將數據寫入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
var admin = require("firebase-admin");

// Get a database reference to our blog
var db = admin.database();
var ref = db.ref("server/saving-data/fireblog");
蟒蛇
# 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
var 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"
  }
});
蟒蛇
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
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"
});
蟒蛇
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
var hopperRef = usersRef.child("gracehop");
hopperRef.update({
  "nickname": "Amazing Grace"
});
蟒蛇
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的數據以包括她的暱稱。如果您曾使用此設定的,而不是更新,它會刪除兩個full_namedate_of_birthhopperRef

Firebase實時數據庫還支持多路徑更新。這意味著更新現在可以同時更新數據庫中多個位置的值,這項強大的功能可以幫助您對數據進行非規範化 。使用多路徑更新,您可以同時為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
usersRef.update({
  "alanisawesome/nickname": "Alan The Machine",
  "gracehop/nickname": "Amazing Grace"
});
蟒蛇
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)
}

更新之後,Alan和Grace都添加了暱稱:

{
  "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
usersRef.update({
  "alanisawesome": {
    "nickname": "Alan The Machine"
  },
  "gracehop": {
    "nickname": "Amazing Grace"
  }
});
蟒蛇
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"
    }
  }
}

添加完成回調

在Node.js和Java Admin SDK中,如果您想知道何時提交數據,則可以添加完成回調。這些SDK中的set和update方法均採用可選的完成回調,當將提交提交給數據庫時將調用該回調。如果由於某種原因調用失敗,則會向回調函數傳遞一個錯誤對象,指示失敗原因。在Python和Go Admin SDK中,所有寫入方法均處於阻塞狀態。也就是說,在將寫入提交到數據庫之前,write方法不會返回。

爪哇
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", function(error) {
  if (error) {
    alert("Data could not be saved." + error);
  } else {
    alert("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"
    }
  }
}

如果用戶添加新帖子,它將被存儲為/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
var postsRef = ref.child("posts");

var 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"
});
蟒蛇
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"
});
蟒蛇
# 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()
var newPostRef = postsRef.push();

// Get the unique key generated by push()
var postId = newPostRef.key;
蟒蛇
# 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
var upvotesRef = db.ref("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes");
upvotesRef.transaction(function (current_value) {
  return (current_value || 0) + 1;
});
蟒蛇
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作為新值,從而導致一個增量而不是兩個增量。

網絡連接和脫機寫入

Firebase Node.js和Java客戶端維護任何活動數據的內部版本。寫入數據後,首先將其寫入此本地版本。然後,客戶端在“盡力而為”的基礎上將數據與數據庫以及與其他客戶端同步。

結果,所有寫入數據庫的操作都會立即觸發本地事件,甚至不會將任何數據寫入數據庫。這意味著,當您使用Firebase編寫應用程序時, 無論網絡延遲或Internet連接如何您的應用程序都將保持響應狀態。

重新建立連接後,我們將收到適當的事件集,以便客戶端“捕獲”當前服務器狀態,而無需編寫任何自定義代碼。

保護您的數據

Firebase實時數據庫具有一種安全語言,可讓您定義哪些用戶對數據的不同節點具有讀寫訪問權限。您可以在保護您的數據中閱讀更多有關它的信息