Android Architecture Components（AAC）2 Room進一步封裝

上篇文章 Android Architecture Components（AAC）1 資料庫架構Room 我們介紹了room的基本使用以及它的優缺點，接下來我們繼續對room這個資料庫架構分析。

先從dao類入手這裡我們添加了一個baseDao這個dao作為所有dao的父類分裝了共通化的資料庫處理。

@Dao
public interface BaseDao<T> {
    @Insert
    public void insertItem(T item);//插入單條資料

    @Insert
    public void insertItems(List<T> items);//插入list資料

    @Delete
    public void deleteItem(T item);//删除item

    @Update
    public void updateItem(T item);//更新item
}
           

再看我們的userDao變成了什麼樣子

@Dao
public interface UserDao extends BaseDao<User> {
    @Query("SELECT * FROM user")
    public List<User> getUsers();//擷取user集合

    @Query("SELECT * FROM user WHERE id=:id")
    public User getUserById(int id);//通過id擷取user
}
           

是不是變的清晰了許多

再看後面的對db的更新以及新dao的添加類處理

UserDB

@Database(entities = {User.class}, version = , exportSchema = false)
public abstract class UserDB extends RoomDatabase {
    private static final String DBName = "userDB.db";
    private static UserDB instance;
    public static UserDB getInstance() {
        if (instance == null) {
            synchronized (UserDB.class) {
                if (instance == null) {
                    instance = createDB();
                }
            }
        }
        return instance;
    }

    @NonNull
    private static UserDB createDB() {
        return Room.databaseBuilder(RoomApplication.getContext(), UserDB.class, DBName)
                .addCallback(new Callback() {
                    @Override
                    public void onCreate(@NonNull SupportSQLiteDatabase db) {
                        super.onCreate(db);
                    }

                    @Override
                    public void onOpen(@NonNull SupportSQLiteDatabase db) {
                        super.onOpen(db);
                    }
                }).addMigrations(
                        new MyMigration(, ),
                        new MyMigration(, ))
                .allowMainThreadQueries()
                .build();
    }
    //擷取單個dao執行個體
    public abstract UserDao getUserDao();

    private static class MyMigration extends Migration {

        MyMigration(int startVersion, int endVersion) {
            super(startVersion, endVersion);
        }

        @Override
        public void migrate(@NonNull SupportSQLiteDatabase database) {
            switch (startVersion) {
                case :
                    int as1w = ;
                    Toast.makeText(RoomApplication.getContext(),"111111111111111",Toast.LENGTH_LONG).show();
                    Log.e("sssssssssssssss","111111111111111");
//                    database.execSQL();
                    break;
                case :

                    Toast.makeText(RoomApplication.getContext(),"2222222222222222",Toast.LENGTH_LONG).show();
                    Log.e("sssssssssssssss","2222222222222222");
                    int asw = ;
//                    database.execSQL();
                    break;
            }
        }
    }
}
           

這裡我們看到了db這個類的職責是維護資料庫的結構負責資料庫名稱版本更新處理以及擷取dao的操作，可以說資料庫的結構有變動隻需要修改本類相關的處理即可。

是以從這裡看的話Room給我們提供的RoomDatabase 類還是很不錯了我們可以輕松的把資料庫的資料操作跟結構操作分離開來。

接下來要介紹的就是對資料庫的資料操作類DBManager這裡封裝了對資料庫的資料業務操作，使用DBManager的好處是将資料庫資料操作統一化，讓業務類操作資料庫隻需要一個方法搞定，這樣業務邏輯更清晰，同時資料庫也更好維護，代碼如下。

public class DBManager {
    public static void insertUsers(List<User> items) {
        UserDB.getInstance().getUserDao().insertItems(items);
    }

    public static void deleteUser(User user) {
        UserDB.getInstance().getUserDao().deleteItem(user);
    }

    public static void updateUser(User user) {
        UserDB.getInstance().getUserDao().updateItem(user);
    }

    public static List<User> getUsers() {
        return UserDB.getInstance().getUserDao().getUsers();
    }
}
           

最後就是調用層的處理了。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        List<User> users = new ArrayList<>();
        for (int i = ; i < ; i++) {
            User user = new User();
            user.setAge(i * );
            user.setHeight(i * );
            user.setUserName("lanfang" + i);
            user.setPassWord("123" + i);
            user.setVip(false);
            users.add(user);
        }
        DBManager.insertUsers(users);

        User user = new User();
        user.setId();
        DBManager.deleteUser(user);

        user.setId();
        user.setAge();
        user.setHeight();
        user.setUserName("lanfang");
        user.setPassWord("123");
        user.setVip(false);
        DBManager.updateUser(user);

        List<User> ss = DBManager.getUsers();
        int a = ss.size();
    }
}
           

是不是邏輯很清晰

經過對Root的封裝處理我們繼續對這個資料庫架構分析 ，從dao入手這個dao的設計是每個dao對應一個entity，這樣的話對于項目來說耦合度大大降低了，每個類的修改不會影響其他類的功能，但同時也存在弊端，從我們的資料庫manager中可以看到每個類的插入删除添加其實可以走統一處理的但由于我們要操作資料庫的表對象就必須依賴執行個體化的dao層對象如 UserDB.getInstance().getUserDao()，我們每個entity對應一個dao的話需要寫很多類似的處理，但同時上面也說了他們的耦合度很低很低，是以修改每個處理雖然都需要添加一個方法但是每個方法改變不會影響其他的邏輯處理，希望這篇部落格能幫助到到家更好的了解到room這個架構。

github傳送門點選這裡