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传送门点击这里