Room数据库框架使用记录

最新推荐文章于 2024-06-14 12:07:38 发布
最新推荐文章于 2024-06-14 12:07:38 发布
阅读量624 收藏
点赞数
分类专栏： Android基础 文章标签： Room数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sfhong2008/article/details/90371139
版权

Room 是goole 在jetpack 中的一个数据库框架,在项目中使用特此记录,以备后查

在项目中使用到了room 数据库框架, 特此记录:
1.添加依赖(用到了annotationProcess, 需要配置在app 使用model 下,不能配置在lib 的model下)

  // Room
 implementation   'android.arch.persistence.room:runtime:1.1.1'
implementation   'android.arch.persistence.room:rxjava2:1.0.0'
annotationProcessor   'android.arch.persistence.room:compiler:1.1.1'

2.创建一个抽象类,继承自RoomDatabase,提供一个全局的数据库抽象:

@Database(entities = {NewPhotoBean.class,PhotoDescBean.class,PhotoTranslateScaleBean.class},version = 1,exportSchema = false)
public abstract class AppDB extends  RoomDatabase{

 private static final String DB_NAME="frame.db";
 private static volatile AppDB instance;

public static synchronized AppDB getInstance(Context context){
    if (instance==null){
        instance=create(context);
    }

    return instance;
}


private  static AppDB create(Context context){
    return Room.databaseBuilder(
            context,
            AppDB.class,
            DB_NAME)
            .allowMainThreadQueries() //配置是否可以在main线程调用数据的操作
            //.addMigrations(MIGRATION_1_2)
            .build();


}


//数据库升级的配置, 默认的version=1
static final Migration MIGRATION_1_2 = new Migration(1, 2) {
    @Override
    public void migrate(SupportSQLiteDatabase database) {
       /* database.execSQL("ALTER TABLE department "
                + " ADD COLUMN phone_num TEXT");*/
    }
};


//提供给注解实现的抽象方法.
public abstract NewPhotoDao getNewPhotoDao();

}

3…实现@Dao

 @Dao
public interface NewPhotoDao {

@Insert
long insert(NewPhotoBean newPhotoBean);  //插入单条记录


@Insert
void insert(List<NewPhotoBean> newPhotoBeans); //插入多条记录



@Update
void update(NewPhotoBean newPhotoBean); //根据id 更新记录



@Query("delete from newphoto  where path = :path") 
int deleteNewPhotoByPath(String path); //使用sql 语句执行删除, 注意 "= :path", 冒号和变量要连着



@Query("delete from newPhoto where path in (:pathList)")
int deleteNewPhotoRecords(List<String> pathList );



@Delete
void delete(NewPhotoBean newPhotoBean);


@Query("delete from newphoto ")
int deleteAllNewPhotoRecords();


@Query("SELECT * FROM newphoto")
List<NewPhotoBean> getAllNewPhoto();

@Query("SELECT * FROM newphoto  order by id desc")
List<NewPhotoBean> getAllNewPhotoRxJava();


@Query("SELECT * FROM newphoto  order by id desc")
List<NewPhotoBean> getAllNewPhoto();


@Query("SELECT path FROM newphoto  order by id desc")
List<String> getAllNewPhotoStr();


@Query("SELECT * FROM newPhoto where path = :path")
NewPhotoBean findNewPhotoRecord(String path);



  //@Query("select * from newphoto where userId=(select userId from newphoto order by id desc limit 1) group by  path order by id desc")
 /* @Query("select * from newphoto where userId=(select userId from newphoto order by id desc limit 1) ")
 Single<List<NewPhotoBean>> getLastPersonPhotos();*/




@Insert
long insert(PhotoDescBean photoDescBean );


@Query("SELECT * FROM photoDesc  order by id desc")
Single<List<PhotoDescBean>> getAllPhotoDesc();


@Query("SELECT * from photoDesc where photoPath = :filePath")
Single<List<PhotoDescBean>>  findPhotoDescByPath(String filePath);



@Query("select * from phototranslatescale where path = :path")
PhotoTranslateScaleBean findPhotoTranslateScale(String path);

@Insert
long insertPhotoTranslateScale(PhotoTranslateScaleBean scaleBean);

@Update
int updatePhotoTranslateScale(PhotoTranslateScaleBean scaleBean);


@Query("delete from phototranslatescale  where path = :path")
int deletePhotoTranslateScaleByPath(String path);


@Query("select * from phototranslatescale ")
List<PhotoTranslateScaleBean> getAllPhotoTranslateScale();

}

4.创建bean对象:

@Entity(tableName = "photoDesc")
public class PhotoDescBean {

  @PrimaryKey(autoGenerate = true)
   private   int id; //设置主键


public PhotoDescBean() {
}



private String photoPath;



private String desc;



private  long  createTime;



private String  userId;


private String  userName;


public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

public String getPhotoPath() {
    return photoPath;
}

public void setPhotoPath(String photoPath) {
    this.photoPath = photoPath;
}

public String getDesc() {
    return desc;
}

public void setDesc(String desc) {
    this.desc = desc;
}

public long getCreateTime() {
    return createTime;
}

public void setCreateTime(long createTime) {
    this.createTime = createTime;
}

public String getUserId() {
    return userId;
}

public void setUserId(String userId) {
    this.userId = userId;
}

public String getUserName() {
    return userName;
}

public void setUserName(String userName) {
    this.userName = userName;
}


@Override
public String toString() {
    return "PhotoDescBean{" +
            "id=" + id +
            ", photoPath='" + photoPath + '\'' +
            ", desc='" + desc + '\'' +
            ", createTime=" + createTime +
            ", userId='" + userId + '\'' +
            ", userName='" + userName + '\'' +
            '}';
}

}

5, 提供一个数据库管理类:

public  class DBUtils {


private static final DBUtils ourInstance = new DBUtils();
private static final String TAG = "DBUtils";


private static  AppDB appDB;


public static DBUtils get(Context ctx) {
    if (appDB ==null){
        appDB=AppDB.getInstance(ctx);
    }

    return ourInstance;
}

private DBUtils() {

}




public  void addPhotoDesc(PhotoDescBean photoDescBean, CallBack callback){
    Observable.just("")
            .map(s->{

                return appDB.getNewPhotoDao().insert(photoDescBean);

            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(id -> {

                if (callback!=null){

                    callback.onCallback(id);
                }

            });



}



public void getAllPhotoDesc(CallBack callBack) {
    appDB.getNewPhotoDao().getAllPhotoDesc()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    newPhotoBeans -> {
                        if (callBack!=null){

                            callBack.onCallback(newPhotoBeans);
                        }
                    }
            );



}



public void getPhotoDescByPath(String filePath,CallBack callBack){

    appDB.getNewPhotoDao().findPhotoDescByPath(filePath)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(photoDescBean -> {

                if (callBack!=null){

                    if (photoDescBean.size()>0){
                        callBack.onCallback(photoDescBean.get(0));
                    }else{

                        callBack.onCallback(null);
                    }
                }

            });



}




//==============================NewPhotoBean=============================


public void getAllNewPhotoRecord(CallBack callBack) {

    Observable.just("")
            .map(s -> {
                return  appDB.getNewPhotoDao().getAllNewPhoto();
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    newPhotoBeans -> {
                        if (callBack!=null){

                            callBack.onCallback(newPhotoBeans);
                        }
                    }
            );

}

public  void getAllNewPhotoRecordStr(CallBack callBack) {

    Observable.just("")
            .map(s -> {
                return  appDB.getNewPhotoDao().getAllNewPhotoStr();
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    newPhotoBeans -> {
                        if (callBack!=null){

                            callBack.onCallback(newPhotoBeans);
                        }
                    }
            );

}



public void deleteNewPhotoRecords(List<String> newPhotoBeans, CallBack callBack){

    Observable.just("")
            .map(s -> {

                return  appDB.getNewPhotoDao().deleteNewPhotoRecords(newPhotoBeans);
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    id -> {
                        if (callBack!=null){

                            callBack.onCallback(id);
                        }
                    }
            );


}


public void deleteAllNewPhotoRecord(CallBack callBack) {
    Observable.just("")
            .map(s -> {

                return  appDB.getNewPhotoDao().deleteAllNewPhotoRecords();
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    id -> {
                        if (callBack!=null){
                            callBack.onCallback(id);
                        }
                    }
            );

}



public void deleteNewPhotoByPath(String photo) {
    appDB.getNewPhotoDao().deleteNewPhotoByPath(photo);


}


public void deleteNewPhotoByPathAsync(String photo, CallBack callBack) {

    Observable.just("")
            .map(s -> {

                //删除位置记录
                //appDB.getNewPhotoDao().deletePhotoTranslateScaleByPath(photo);
                return  appDB.getNewPhotoDao().deleteNewPhotoByPath(photo);
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    id -> {
                        if (callBack!=null){
                            callBack.onCallback(id);
                        }
                    }
            );


}

public void addOrUpdateNewPhotoRecord(NewPhotoBean bean, CallBack callBack) {

    Observable.just("")
            .map(s -> {
               NewPhotoBean newPhotoBean= appDB.getNewPhotoDao().findNewPhotoRecord(bean.getPath());
               if (newPhotoBean!=null){

                   return newPhotoBean.getId();

               }else{

                   return  appDB.getNewPhotoDao().insert(bean);
               }

            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    id -> {
                        if (callBack!=null){
                            callBack.onCallback(id);
                        }
                    }
            );

}

//=========================================PhotoTranslateScaleBean==============================================


public void addOrUpdatePhotoTranslateScale(PhotoTranslateScaleBean scaleBean, CallBack callBack) {
    Observable.just("")
            .map( s -> {

                  PhotoTranslateScaleBean bean= getPhotoTranslateScaleByPath(scaleBean.getPath());
                  if (bean!=null){

                      //先删除旧记录
                      appDB.getNewPhotoDao().deletePhotoTranslateScaleByPath(scaleBean.getPath());
                  }

                    return  appDB.getNewPhotoDao().insertPhotoTranslateScale(scaleBean);



            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(

                    id->{


                        if (callBack!=null){
                            callBack.onCallback(id);
                        }
                    }

            );


}



public void deletePhotoTranslateScaleByPath(String path) {

        appDB.getNewPhotoDao().deletePhotoTranslateScaleByPath(path);

}

public void deletePhotoTranslateScaleByPathAsync(String path, CallBack callBack) {

    Observable.just("")
            .map(s -> {

                return  appDB.getNewPhotoDao().deletePhotoTranslateScaleByPath(path);
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    id -> {
                        if (callBack!=null){
                            callBack.onCallback(id);
                        }
                    }
            );


}



public PhotoTranslateScaleBean getPhotoTranslateScaleByPath(String path){
    return appDB.getNewPhotoDao().findPhotoTranslateScale(path);

}


public void getAllPhotoTranslateScale(CallBack callBack){
    Observable.just("")
            .map(s -> {
                return  appDB.getNewPhotoDao().getAllPhotoTranslateScale();
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    newPhotoBeans -> {
                        if (callBack!=null){

                            callBack.onCallback(newPhotoBeans);
                        }
                    }
            );


}




//=========================================数据库操作的回调==================================
public interface CallBack {

    void onCallback(Object result);

}

6.在代码中调用:

 //删除NewPhoto记录
  DBUtils.get(mContext).deleteNewPhotoByPath(realPath);
   //删除原图的位置记录
 DBUtils.get(mContext).deletePhotoTranslateScaleByPath(realPath);
  //删除缩略图的位置记录
 DBUtils.get(mContext).deletePhotoTranslateScaleByPath(ScanUtil.generateThumbPathByPhotoPath(realPath));
_红日_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android-room数据库框架使用
08-13
room数据库框架使用
Andriod开发 Room 数据库处理框架
jmqxnxg的博客
06-03 1382
Room是Android Jetpack组件库中的一部分，它是一个SQLite数据库的抽象层，提供了更简单的API和更好的性能，适合于中大型应用程序。举个例子，我们要将书本信息存储到数据库中，那么可以先创建一个书本信息的新类，用于封装书本信息。在该实体类中，用注解表明实体：@Entity， 和对应表中的主键：@PrimaryKey。这个接口不需要实现具体的增删改查操作，只需要用注解标记好对应的操作。也是类似的，用注解写清楚该数据库涉及的实体类。这样数据库的实例就是全局变量。3）创建数据库的抽象类。
Android Room数据库使用介绍
最新发布
WriteBug001的博客
06-14 1391
Room是Google提供的Android架构组件之一，旨在简化数据库操作。它是SQLite的一个抽象层，提供了更易用和安全的API。// tableName 指定了数据库中对应的表名为 "users"。如果不指定，默认使用类名作为表名// 使用默认值 0，autoGenerate = true 表示自动生成主键// 如果不使用 @ColumnInfo 注解，默认情况下 Room 将使用属性名作为数据库中的列名。
room 数据库
Nivze的博客
01-20 189
第一步：添加Room库依赖 dependencies { //room implementation 'android.arch.persistence.room:runtime:1.1.1' annotationProcessor 'android.arch.persistence.room:compiler:1.1.1' } 第二步： 创建Dao @Dao pu...
Room，数据库框架学习一(Room框架搭建)
Mrlove的博客
01-19 2808
概念 Room设计到的概念有以下几个： 1、Entity : 对应数据库中的表，可以使用Entity注解将一个类变成数据库中的一张表结构。 2、DAO : 全称Database Access Object,定义了对数据库中数据的读写等操作，DAO中可以使用SQL语句来操作数据库。 3、RoomDatabase : 数据库持有类，用于创建数据库或者连接到数据库。内部包含DAO和Entity。 Ent...
Android JetPack 框架库之Room数据库
qq_15596445的博客
05-21 229
Dao@Insert。
Room数据库的使用与升级（详细介绍了增删改查，关于查询，各种查询方式都有介绍）
UrasakiNakajima的博客
05-27 4015
Room是Google推出的数据库框架，是一个 ORM (Object Relational Mapping)对象关系映射数据库、其底层还是对SQLite的封装。使用ORM可以让开发者更加关注业务逻辑，而不是SQL 语句。在JavaWeb领域也有类似的ORM 数据库框架Hibernate、MyBatis等等。Android平台数据库框架在 Android 中常见的数据库框架：GreendaoRealmDBFlowLitePal。
Jetpack 之 Room数据库
树叶的博客
09-08 351
文章目录@[toc]1.依赖添加2.创建Entity, 创建一张学生表3.针对Entity定一个对应的Dao接口文件，以便对Entity进行访问4.创建数据库5.操作数据库 1.依赖添加 dependencies { implementation "andoirdx.room:room-runtime:2.2.2" annotationProcessor "androidx.room:room-compiler:2.2.2" } 2.创建Entity, 创建一张学生表 新建一个名为Student的Ja
Room数据库使用
u013356780的博客
06-09 1442
简介 Room持久库提供了一个SQLite抽象层，让你访问数据库更加稳如狗，提示数据库性能。 Room库帮助应用数据缓存，这个缓存是应用唯一的真实来源，并且允许用户查看应用中的关键信息的一致副本。 ...
Jetpack Room数据库
summerrse的博客
07-16 2888
Jetpack Room数据库 简介 Room 在 SQLite 上提供了一个抽象层，以便在充分利用 SQLite 的强大功能的同时，能够流畅地访问数据库。 处理大量结构化数据的应用可极大地受益于在本地保留这些数据。最常见的用例是缓存相关数据。这样，当设备无法访问网络时，用户仍可在离线状态下浏览相应内容。设备重新连接到网络后，用户发起的所有内容更改都会同步到服务器。 由于 Room 负责为您处理这些问题，因此我们强烈建议您使用 Room（而不是SQLite）。 依赖（AndroidX环境下） 在kotli
Android Studio 查看打开Room数据库数据
fumeidonga的博客
05-11 1152
CSDN内容合伙人、技术专家， 从零开始做，带领团队单日营收超千万。专注于分享各领域原创系列文章 ，擅长java后端、移动开发、商业化变现、人工智能等，希望大家多多支持。
Room数据库的使用
chenrenxiang的专栏
11-14 7600
废话也不多说了，Room数据库就是对SQLite数据库的封装，使之用起来更方便。Google也说了强烈推荐使用Room来替代SQLite。 1.在项目中添加Room dependencies { ... def room_version = "2.1.0-alpha02" implementation "androidx.room:room-runtime:$room_vers...
初识Room数据库
yuzy717的博客
04-16 1396
Room 在易用性、安全性、灵活性和可维护性等方面都有优 势，而 SQLite 的优势则在于它是一个轻量级的数据库管理 系统，对于简单应用程序而言，SQLite 可能更加适合
Room数据库框架
cherry459的博客
07-09 822
android开发也知道，用原生的数据库开发代码量多，特别麻烦。不过，目前google已经有自己的数据库框架Room了，现在写下自己使用Room框架的一些心得体会。 官方介绍： The Room persistence library provides an abstraction layer over SQLite to allow fluent database access while ...
【Jetpack系列二】——Room操作数据库
大帅在唱歌
06-17 862
文章目录Jetpack组件之 Room操作数据库简介主要类依赖定义实体类访问数据创建数据库插入数据删除数据更新数据Tips Jetpack组件之 Room操作数据库 看了google出品的jetpack库，感觉还是很不错的，这里开始我们的Jetpack学习之旅 本文所有源码收录在 --> https://github.com/ddssingsong/AnyTool 简介 官方： Room持久...
room数据库的使用
qq_40204114的博客
09-01 792
SearchView一个类似百度搜索框关键字搜索效果的实现 https://blog.csdn.net/qq_42177292/article/details/81158423 Room数据库详实使用指北（附Demo） https://blog.csdn.net/langlitaojin/article/details/88400659 https://blog.csdn.net/chenrenxiang/article/details/84067783 https://zhuanlan.zhihu.com
Android Jetpack架构组件-Room数据库查询艺术
One X的博客
04-01 3650
目录一、Room 中的数据库关系查询1.1、 一对一关系1.2、 一对多关系1.3、多对多关系二、配合Rxjava的使用三、配合LiveData的使用四、配合Paging框架的使用五、结语 在阅读本文前，需要先了解Room框架的使用，入门可点击笔者Android Jetpack架构组件-Room基本使用文章 一、Room 中的数据库关系查询 设计一个关系型数据库很重要的一部分是将数据拆分成具有...
一文带你了解Room数据库
热门推荐
养生阿华田
12-21 1万+
1.引言 Sqlite的代码写起来繁琐且容易出错，数据和对象之间的映射过程写起来实在无趣，还是不如使用ORM框架来的得心应手。 2.Room是什么 Room是Goole推出的数据库框架，属于ORM库。 Room提供了SQLite的抽象层，以便在充分利用SQLite的同时允许流畅的数据库访问。 Room与其他ORM框架对比有以下优点： 编译期检查，Room会在编译的时候验证每个@Query和@Entity等，它不仅检查语法问题，还会检查是否有该表,这就意味着几乎没有任何运行时错误的风险 较少的模板代码 与
常用第三方数据库——room
qq_42281792的博客
07-09 844
组件 Room由三个重要的组件组成：Database、Entity、DAO。 Database：包含数据库持有者，并作为与应用持久关联数据的底层连接的主要访问点。而且Database对应的类必须满足下面几个条件： 1. 必须是abstract类而且的extends RoomDatabase。 2. 必须在类头的注释中包含与数据库关联的实体列表(Entity对应的类)。 3. 包含一个具有0个参...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值