Java 有境界的道模式

道如何与境界一起使用？因为当我在活动中尝试设置模型类的成员时，会出现异常：

java.lang.IllegalStateException：只能从事务内部更改域数据

我知道使用

realm.executeTransaction

可以解决这个问题，但我活动中的代码不再是数据库无关的，因为它将统计特定于低级数据库通信的代码。所以，如果以后我想更改数据库，重构将花费大量的时间和工作。。。此外，我必须在所有活动中处理对

Realm.getDefaultInstance（）的引用

这是我活动的代码示例

protected void onCreate(Bundle savedInstanceState)
{
    mBook = mBookDaoImpl.getBookById(bookId);
}

// Later in the code

private void saveBook(String name)
{
    mBook.setName(name);
}

这是我的模型课

public class Book extends RealmObject
{
    @Required
    @PrimaryKey
    private String id;

    private String name;

    public Book() {
    }

    public Book(String id, String name) {
        this.id = id;
        this.name = name;
    }

    // getter setter methods
}

这是我的DAO接口：

public interface BookDao
{
    List<Book> getAllBooks();

    Book getBookByIsbn(int isbn);

    void saveBook(Book book);

    void deleteBook(Book book);
}

公共接口BookDao
{
列出getAllBooks（）；
Book getBookByIsbn（国际书号）；
作废存折（存折）；
作废删除书（书簿）；
}

最后是我的实现：

public class BookDaoImpl implements BookDao
{
    private static BookDaoImpl INSTANCE = null;

    private Realm mRealm;

    private BookDaoImpl()
    {
        mRealm = Realm.getDefaultInstance();
    }

    public static BookDaoImpl getInstance()
    {
        if (INSTANCE == null)
            INSTANCE = new BookDaoImpl();

        return INSTANCE;
    }

    @Override
    public List<Book> getAllBooks()
    {
        return mRealm.where(Book.class).findAll();
    }

    @Override
    public Book getBookById(String id)
    {
        return mRealm.where(Book.class).equalTo("id", id).findFirst();
    }

    @Override
    public void saveBook(final Book book)
    {
        mRealm.executeTransaction(new Realm.Transaction()
        {
            @Override
            public void execute(Realm realm)
            {
                if (book.getId() == null)
                    book.setId(UUID.randomUUID().toString());
                realm.copyToRealmOrUpdate(book);
            }
        });
    }

    @Override
    public void deleteBook(final Book book)
    {
        mRealm.executeTransaction(new Realm.Transaction()
        {
            @Override
            public void execute(Realm realm)
            {
                mRealm.where(Counter.class).equalTo("id", book.getId())
                        .findFirst()
                        .deleteFromRealm();
            }
        });
    }
}

public类BookDaoImpl实现BookDao
{
私有静态BookDaoImpl实例=null；
私人领域；
私人簿记
{
mRealm=Realm.getDefaultInstance（）；
}
公共静态BookDaoImpl getInstance（）
{
if（实例==null）
INSTANCE=newbookdaoimpl（）；
返回实例；
}
@凌驾
公共列表getAllBooks（）
{
返回mRealm.where（Book.class.findAll（）；
}
@凌驾
公共图书getBookById（字符串id）
{
返回mRealm.where（Book.class）.equalTo（“id”，id）.findFirst（）；
}
@凌驾
公共作废存折（最终存折）
{
mRealm.executeTransaction（新领域.Transaction（）
{
@凌驾
公共void执行（领域）
{
if（book.getId（）==null）
book.setId（UUID.randomuid（）.toString（））；
realm.copyToRealmOrUpdate（book）；
}
});
}
@凌驾
公共图书（最终图书）
{
mRealm.executeTransaction（新领域.Transaction（）
{
@凌驾
公共void执行（领域）
{
mRealm.where（Counter.class）.equalTo（“id”，book.getId（））
.findFirst（）
.deleteFromRealm（）；
}
});
}
}
Realm的
getInstance（）
方法返回一个
线程本地引用计数实例，该实例必须与close（）调用配对
，因此DAO实现可能无法满足您的期望

如果您使用我专门创建的库，使“抽象领域”变得更容易，那么您可以像这样实现DAO：

public class BookDaoImpl implements BookDao
{
    private static BookDaoImpl INSTANCE = null;

    private Monarchy monarchy;

    private BookDaoImpl(Monarchy monarchy)
    {
        this.monarchy = monarchy;
    }

    public static BookDaoImpl getInstance(Monarchy monarchy)
    {
        if (INSTANCE == null) {
            synchronized(BookDaoImpl.class) {
                if(INSTANCE == null) {
                    INSTANCE = new BookDaoImpl(monarchy);
                }
            }
        }
        return INSTANCE;
    }

    @Override
    public List<Book> getAllBooks()
    {
        return monarchy.fetchAllCopiedSync((realm) -> realm.where(Book.class));
    }

    @Override
    public Book getBookById(final String id)
    {
        List<Book> books = monarchy.fetchAllCopiedSync((realm) -> realm.where(Book.class).equalTo("id", id));
        if(books.isEmpty()) {
            return null;
        } else {
            return books.get(0);
        }
    }

    @Override
    public void saveBook(final Book book)
    {
        monarchy.runTransactionSync((realm) -> {
            if (book.getId() == null)
                book.setId(UUID.randomUUID().toString());
            realm.insertOrUpdate(book);
        });
    }

    @Override
    public void deleteBook(final Book book)
    {
        monarchy.runTransactionSync((realm) -> {
                realm.where(Counter.class).equalTo("id", book.getId())
                        .findFirst()
                        .deleteFromRealm();
        });
    }
}

public类BookDaoImpl实现BookDao
{
私有静态BookDaoImpl实例=null；
私人君主制；
私人书店（君主政体）
{
君主制=君主制；
}
公共静态BookDaoImpl getInstance（君主政体）
{
if（实例==null）{
已同步（BookDaoImpl.class）{
if（实例==null）{
实例=新的BookDaoImpl（君主政体）；
}
}
}
返回实例；
}
@凌驾
公共列表getAllBooks（）
{
return monary.fetchAllCopiedSync（（realm）->realm.where（Book.class））；
}
@凌驾
公共图书getBookById（最终字符串id）
{
List books=monary.fetchAllCopiedSync（（realm）->realm.where（Book.class.equalTo（“id”，id））；
if（books.isEmpty（））{
返回null；
}否则{
返回图书。获取（0）；
}
}
@凌驾
公共作废存折（最终存折）
{
君主制。runTransactionSync（（领域）->{
if（book.getId（）==null）
book.setId（UUID.randomuid（）.toString（））；
领域。插入更新（书籍）；
});
}
@凌驾
公共图书（最终图书）
{
君主制。runTransactionSync（（领域）->{
realm.where（Counter.class）.equalTo（“id”，book.getId（））
.findFirst（）
.deleteFromRealm（）；
});
}
}

注意：如果你同步返回
列表
，而不是像
LiveData
（或者最初是
RealmResults
）这样的可观察列表，那么你就浪费了很多功能