Question

我目前正在测试Firebase以及我打算在整个应用程序的生命周期中使用的Singleton模型。我现在已经陷入了一些似乎非常微不足道的事情，但我无法理解我的生活。我有一个我使用的模型示例：firebase中的书签。

public class BookSingleton {



private static BookSingleton model;

private ArrayList<BookMark> bookmarks = new ArrayList<BookMark>();


public static BookSingleton getModel()
{
    if (model == null)
    {
        throw new IllegalStateException("The model has not been initialised yet.");
    }

    return model;
}


public ArrayList<Bookmark> theBookmarkList()
{
    return this.bookmarks;
}


public void setBookmarks(ArrayList<Bookmark> bookmarks){
    this.bookmarks = bookmarks;
}


public void loadModelWithDataFromFirebase(){
    Firebase db = new Firebase(//url);
    Firebase bookmarksRef = fb.child(//access correct child);


    final ArrayList<Bookmark> loadedBookmarks = new ArrayList<Bookmark>();
    bookmarksRef.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
                    //getting all properties from firebase...
                    Bookmark bookmark = new Bookmark(//properties here);
                    loadedBookmarks.add(bookmark);



                }
            }
            //bookmarks still exist here at this point
            setBookmarks(loadedBookmarks);

        }

        @Override
        public void onCancelled(FirebaseError firebaseError) {

        }
    });
    //by now loadedBookmarks is empty
    //this is probably the issue?
    //even without this line bookmarks is still not set in mainactivity
    setBookmarks(loadedBookmarks);
}

现在，当我使用Singleton集的实例启动mainActivity时，我得到一个null错误，因为我写的从firebase加载模型数据的函数显然没有设置任何内容。

这样的事情： MainActivity

public class MainActivity extends AppCompatActivity {

private BookSingleton theModel;



@Override
protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    // Load the model
    theModel = BookSingleton.getModel(this);
      //manually setting this works 
      //        ArrayList<Book> bookSamples = new ArrayList<Book>;
      //        bookSamples.add(aBookSample);

    theModel.loadModelWithSampleData(bookSamples);
    //should have set the singleton model property Bookmarks to the results from firebase

    theModel.loadModelWithDataFromFirebase();
    //returns 0
    Log.d(TAG, "" + theModel.theBookmarkList().size());


    setContentView(R.layout.activity_main);

    //......rest of code

我该如何做到这一点？

Answer 1

Firebase加载并同步数据异步。因此，loadModelWithDataFromFirebase()不会等待加载完成，只需启动从数据库加载数据。当您的loadModelWithDataFromFirebase()函数返回时，加载尚未完成。

您可以使用一些适当的日志语句轻松地自行测试：

public void loadModelWithDataFromFirebase(){
    Firebase db = new Firebase(//url);
    Firebase bookmarksRef = fb.child(//access correct child);

    Log.v("Async101", "Start loading bookmarks");
    final ArrayList<Bookmark> loadedBookmarks = new ArrayList<Bookmark>();
    bookmarksRef.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            Log.v("Async101", "Done loading bookmarks");
            //getting all properties from firebase...
            Bookmark bookmark = new Bookmark(//properties here);
            loadedBookmarks.add(bookmark);
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) { }
    });
    Log.v("Async101", "Returning loaded bookmarks");
    setBookmarks(loadedBookmarks);
}

与您可能期望的相反，日志语句的顺序为：

Start loading bookmarks
Returning loaded bookmarks
Done loading bookmarks

您有两种选择来处理此加载的异步性质：

压制异步错误（通常伴随着嘀咕像：＆＃34;这是一个错误，这些人不知道他们在做什么＆＃34;）
拥抱异步野兽（通常伴随着相当长的几个小时的诅咒，但过了一段时间的平静和更好的行为应用）

拿蓝色药丸 - 使异步调用同步行为

如果您想选择第一个选项，那么放置良好的同步原语就可以解决问题：

public void loadModelWithDataFromFirebase() throws InterruptedException {
    Firebase db = new Firebase(//url);
    Firebase bookmarksRef = fb.child(//access correct child);

    Semaphore semaphore = new Semaphore(0);

    final ArrayList<Bookmark> loadedBookmarks = new ArrayList<Bookmark>();
    bookmarksRef.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            Bookmark bookmark = new Bookmark(//properties here);
            loadedBookmarks.add(bookmark);
            semaphore.release();
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) { throw firebaseError.toException(); }
    });
    semaphore.acquire();
    setBookmarks(loadedBookmarks);
}

更新（20160303）：当我刚在Android上测试时，它阻止了我的应用。它适用于普通的JVM，但在线程方面Android更加挑剔。随意尝试使它工作......或

拿红色药丸 - 处理Firebase中数据同步的异步性质

如果您选择接受异步编程，则应重新考虑应用程序的逻辑。

您目前有＆＃34;首先加载书签。然后加载示例数据。然后加载更多。＆＃34;

使用异步加载模型时，您应该考虑＆＃34;每当加载书签时，我想加载示例数据。每当加载样本数据时，我都想加载更多。＆＃34;

以这种方式思考的好处是，当数据可能不断变化并因此多次同步时，它也可以工作：＆＃34;每当书签发生变化时，我也想加载样本数据。每当样本数据发生变化时，我都想加载更多。＆＃34;

在代码中，这会导致嵌套调用或事件链：

public void synchronizeBookmarks(){
    Firebase db = new Firebase(//url);
    Firebase bookmarksRef = fb.child(//access correct child);

    final ArrayList<Bookmark> loadedBookmarks = new ArrayList<Bookmark>();
    bookmarksRef.addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            Bookmark bookmark = new Bookmark(//properties here);
            loadedBookmarks.add(bookmark);
            setBookmarks(loadedBookmarks);
            loadSampleData();
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) { throw firebaseError.toException(); }
    });
}

在上面的代码中，我们不等待单个值事件，而是处理所有这些事件。这意味着每当书签发生变化时，onDataChange都会被执行，我们（重新）加载样本数据（或任何其他符合您应用需求的行为）。

为了使代码更具可重用性，您可能希望定义自己的回调接口，而不是调用onDataChange中的精确代码。看看this answer就是一个很好的例子。

Answer 2

TL; DR：拥抱Firebase Asynchronicity

正如我在另一个post中提到的，您可以使用promises处理Firebase的异步性质。它会是这样的：

public Task<List<Data>> synchronizeBookmarks(List<Bookmark> bookmarks) {
     return Tasks.<Void>forResult(null)
        .then(new GetBook())
        .then(new AppendBookmark(bookmarks))
        .then(new LoadData())
}

public void synchronizeBookmarkWithListener() {
     synchronizeBookmarks()
         .addOnSuccessListener(this)
         .addOnFailureListener(this);
}

com.google.android.gms.tasks

Google API for Android提供了task framework（就像Parse与Bolts一样），与JavaScript promises概念类似。

首先，您要创建一个Task，用于从Firebase下载书签：

class GetBook implements Continuation<Void, Task<Bookmark>> {

    @Override
    public Task<Bookmark> then(Task<Void> task) {
        TaskCompletionSource<Bookmark> tcs = new TaskCompletionSource();

        Firebase db = new Firebase("url");
        Firebase bookmarksRef = db.child("//access correct child");

        bookmarksRef.addValueEventListener(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                tcs.setResult(dataSnapshot.getValue(Bookmark.class));
            }
        });

        tcs.getTask();
    }

}

既然你明白了，那么setBookmarks和loadSampleData也是异步的。您还可以将它们创建为Continuation任务（就像前一个）将按顺序运行：

class AppendBookmark(List<Bookmark> bookmarks) implements
    Continuation<List<Bookmark>, Task<Bookmark> {

    final List<Bookmark> bookmarks;

    LoadBookmarks(List<Bookmark> bookmarks) {
        this.bookmark = bookmark;
    }

    @Override
    Task<List<Bookmark>> then(Task<Bookmark> task) {
        TaskCompletionSource<List<Bookmark>> tcs = new TaskCompletionSource();
        bookmarks.add(task.getResult());         
        tcs.setResult(this.bookmarks);
        return tcs.getTask();
    }
}

class LoadSampleData implements Continuation<List<Bookmark>, List<Data>> {
    @Override
    public Task<List<Data>> then(Task<List<Bookmark>> task) {
        // ...
    }
}

Answer 3

加载类时必须初始化Singleton。把它放在你的代码上：

private static BookSingleton  model = new BookSingleton();

private BookSingleton() {
}

public static BookSingleton getModel() {     return model == null ? new BookSingleton() : model;
}

在Firebase侦听器中设置Singleton属性值

3 个答案:

拿蓝色药丸 - 使异步调用同步行为

拿红色药丸 - 处理Firebase中数据同步的异步性质

TL; DR：拥抱Firebase Asynchronicity

com.google.android.gms.tasks