ORM数据库框架 LitePal

其他 2018-05-28 19:36:46 阅读次数: 1

简介

An Android library that makes developers use SQLite database extremely easy.

特点
  • 采用对象关系映射(ORM)的模式
  • 很“轻”，jar包只有100k不到
  • 使用起来比较简单

使用过程
  • 首先引入lib，可以通过gradle引入也可以将下载的litepal.jar包直接放入libs目录下。
  • 然后在assets目录下新建一个 litepal.xml 文件，文件名称不能更改。
  • 然后在 AndroidManifest 中配置一下 LitePalApplication，如果已使用自定义的Application，只需在你的Application的onCreate方法中调用 LitePal.initialize(this) 即可。
  • 接下来创建继承自DataSupport的Mode类，之后这些实体类就拥有了进行CRUD操作的能力，LitePal框架会自动创建好相应的数据表，以及表数据类型和非空约束等。
LitePal不管是创建数据库、表还是执行增删改查，都是根据Model的类名和属性名，每次都需要进行反射拼装，然后调用Android原生的数据库操作，或者直接执行sql语句，实现相应的功能。

LitePal for Android 文档

litepal-1.6.1.jar  (library contains *.class files)
litepal-1.6.1-src.jar  (library contains *.class files and *.java files)

LitePal is an open source Android library that allows developers to use SQLite database extremely easy. You can finish most of the database operations without writing even a SQL statement, including create or upgrade tables, crud operations, aggregate functions聚合函数, etc. The setup of LitePal is quite simple as well, you can integrate it into your project in less than 5 minutes.

Experience the magic right now and have fun!

Features

Using object-relational mapping (ORM) pattern.
Almost zero-configuration(only one configuration file with few properties).
Maintains保持 all tables automatically(e.g. create, alter or drop tables).
Multi databases supported.
Encapsulated总结、囊括 APIs for avoiding writing SQL statements.
Awesome极好的 fluent query API.
Alternative替代的、可选的 choice to use SQL still, but easier and better APIs than the originals.
More for you to explore.

Quick Setup

1. Include library
Using Eclipse
Download the latest jar in the above section. Or browse all versions here to choose one to download.
Put the jar into libs folder of your Android project.

Using Android Studio
Edit your build.gradle file and add below dependency: 
compile 'org.litepal.android:core:1.6.1'
1
1
 
1 
compile 'org.litepal.android:core:1.6.1'

2. Configure litepal.xml
Create a file in the assets folder of your project and name it as litepal.xml. Then copy the following codes into it. 
<?xml version="1.0" encoding="utf-8"?>
<litepal>
    <!--  Define the database name of your application.  By default each database name should be end with .db. 
        If you didn't name your database end with .db,   LitePal would plus the suffix automatically for you.   -->
    <dbname value="demo" />

    <!-- Define the version of your database. Each time you want to upgrade your database, the version tag would helps.
        Modify the models you defined in the mapping tag, and just make the version value plus one,
        the upgrade of database will be processed automatically without concern.  -->
    <version value="1" />

    <!-- Define your models in the list with mapping tag, LitePal will create tables for each mapping class.
        The supported fields defined in models will be mapped into columns.  -->
    <list>
        <mapping class="com.test.model.Reader" />
    </list>
    
    <!-- Define where the .db file should be. "internal" means the .db file will be stored in the database folder of internal storage which no one can access. 
        "external" means the .db file will be stored in the path to the directory on the primary external storage device where
        the application can place persistent files it owns which everyone can access. "internal" will act as default.-->
    <storage value="external" />
</litepal>
22
22
 
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<litepal>
3 
    <!--  Define the database name of your application.  By default each database name should be end with .db.
4 
        If you didn't name your database end with .db,   LitePal would plus the suffix automatically for you.   -->
5 
    <dbname value="demo" />
6
7 
    <!-- Define the version of your database. Each time you want to upgrade your database, the version tag would helps.
8 
        Modify the models you defined in the mapping tag, and just make the version value plus one,
9 
        the upgrade of database will be processed automatically without concern.  -->
10 
    <version value="1" />
11
12 
    <!-- Define your models in the list with mapping tag, LitePal will create tables for each mapping class.
13 
        The supported fields defined in models will be mapped into columns.  -->
14 
    <list>
15 
        <mapping class="com.test.model.Reader" />
16 
    </list>
17 
    
18 
    <!-- Define where the .db file should be. "internal" means the .db file will be stored in the database folder of internal storage which no one can access.
19 
        "external" means the .db file will be stored in the path to the directory on the primary external storage device where
20 
        the application can place persistent files it owns which everyone can access. "internal" will act as default.-->
21 
    <storage value="external" />
22 
</litepal>
This is the only configuration file, and the properties are simple.
  • dbname configure the database name of project.
  • version configure the version of database. Each time you want to upgrade database, plus the value here.
  • list configure the mapping classes.
  • storage configure where the database file should be stored. internal and external are the only valid options.

3. Configure LitePalApplication
You don't want to pass the Context param all the time. To makes the APIs simple, just configure the LitePalApplication in AndroidManifest.xml as below: 
android:name="org.litepal.LitePalApplication"
1
1
 
1 
android:name="org.litepal.LitePalApplication"
Of course you may have your own Application and has already configured here,  That's OK. LitePal can still live with that. Just call LitePal.initialize(context) in your own Application: 
LitePal.initialize(this);
1
1
 
1 
LitePal.initialize(this);
Make sure to call this method as early as you can. In the onCreate() method of Application will be fine. And always remember to use the application context as parameter. Do not use any instance of activity or service as parameter, or memory leaks might happen.

Get Started

After setup, you can experience the powerful function now.

1. Create tables

Define the models first. For example you have two models, Album and Song. The models can be defined as below: 
public class Album extends DataSupport {
    @Column(unique = true, defaultValue = "unknown")
    private String name;
    private float price;
    private byte[] cover;
    private List<Song> songs = new ArrayList<Song>();
    // generated getters and setters.
    ...
}
9
9
 
1 
public class Album extends DataSupport {
2 
    @Column(unique = true, defaultValue = "unknown")
3 
    private String name;
4 
    private float price;
5 
    private byte[] cover;
6 
    private List<Song> songs = new ArrayList<Song>();
7 
    // generated getters and setters.
8 
    ...
9 
}
public class Song extends DataSupport {
    @Column(nullable = false)
    private String name;
    private int duration;
    @Column(ignore = true)
    private String uselessField;
    private Album album;
    // generated getters and setters.
    ...
}
10
10
 
1 
public class Song extends DataSupport {
2 
    @Column(nullable = false)
3 
    private String name;
4 
    private int duration;
5 
    @Column(ignore = true)
6 
    private String uselessField;
7 
    private Album album;
8 
    // generated getters and setters.
9 
    ...
10 
}
Then add these models into the mapping list in litepal.xml: 
<list>
    <mapping class="org.litepal.litepalsample.model.Album" />
    <mapping class="org.litepal.litepalsample.model.Song" />
</list>
4
4
 
1 
<list>
2 
    <mapping class="org.litepal.litepalsample.model.Album" />
3 
    <mapping class="org.litepal.litepalsample.model.Song" />
4 
</list>
OK! The tables will be generated next time you operate database. For example, gets the SQLiteDatabase with following codes: 
SQLiteDatabase db = LitePal.getDatabase();
1
1
 
1 
SQLiteDatabase db = LitePal.getDatabase();
Now the tables will be generated automatically with SQLs like this: 
CREATE TABLE album (
    id integer primary key autoincrement,
    name text unique default 'unknown',
    price real,
    cover blob
);
6
6
 
1 
CREATE TABLE album (
2 
    id integer primary key autoincrement,
3 
    name text unique default 'unknown',
4 
    price real,
5 
    cover blob
6 
);
CREATE TABLE song (
    id integer primary key autoincrement,
    name text not null,
    duration integer,
    album_id integer
);
6
6
 
1 
CREATE TABLE song (
2 
    id integer primary key autoincrement,
3 
    name text not null,
4 
    duration integer,
5 
    album_id integer
6 
);

2. Upgrade tables

Upgrade tables in LitePal is extremely easy. Just modify your models anyway you want: 
public class Album extends DataSupport {
    ...
    @Column(ignore = true)
    private float price;//忽略掉此字段
    private Date releaseDate;//添加此字段
}
1 
public class Album extends DataSupport {
2 
    ...
3 
    @Column(ignore = true)
4 
    private float price;//忽略掉此字段
5 
    private Date releaseDate;//添加此字段
6 
}
A releaseDate field was added and price field was annotated to ignore. Then increase the version number in litepal.xml: 
<version value="2" ></version>
1
1
 
1 
<version value="2" ></version>
The tables will be upgraded next time you operate database. A releaseDate column will be added into album table and the original price column will be removed. All the data in album相册 table except those removed columns will be retained保存.

But there are some upgrading conditions that LitePal can't handle and all data in the upgrading table will be cleaned:
  • Add a field which annotated as unique = true.
  • Change a field's annotation into unique = true.
  • Change a field's annotation into nullable = false.
Be careful of the above conditions which will cause losing data.

3. Save data

The saving API is quite object oriented面向对象的. Each model which inherits from DataSupport would have the save() method for free: 
Album album = new Album();
album.setName("album");
album.setPrice(10.99f);
album.setCover(getCoverImageBytes());
album.save();
5
5
1 
Album album = new Album();
2 
album.setName("album");
3 
album.setPrice(10.99f);
4 
album.setCover(getCoverImageBytes());
5 
album.save();
This will insert album into database with associations.

4. Update data

The simplest way, use save() method to update a record found by find(): 
Album albumToUpdate = DataSupport.find(Album.class, 1);
albumToUpdate.setPrice(20.99f); // raise the price
albumToUpdate.save();
1 
Album albumToUpdate = DataSupport.find(Album.class, 1);
2 
albumToUpdate.setPrice(20.99f); // raise the price
3 
albumToUpdate.save();
Each model which inherits from DataSupport would also have update() and updateAll() method. You can update a single record with a specified id: 
Album albumToUpdate = new Album();
albumToUpdate.setPrice(20.99f); // raise the price
albumToUpdate.update(id);
3
3
1 
Album albumToUpdate = new Album();
2 
albumToUpdate.setPrice(20.99f); // raise the price
3 
albumToUpdate.update(id);
Or you can update multiple records with a where condition: 
Album albumToUpdate = new Album();
albumToUpdate.setPrice(20.99f); // raise the price
albumToUpdate.updateAll("name = ?", "album");
 
1 
Album albumToUpdate = new Album();
2 
albumToUpdate.setPrice(20.99f); // raise the price
3 
albumToUpdate.updateAll("name = ?", "album");

5. Delete data

You can delete a single record using the static delete() method in DataSupport: 
DataSupport.delete(Song.class, id);
1
1
 
1 
DataSupport.delete(Song.class, id);
Or delete multiple records using the static deleteAll() method in DataSupport: 
DataSupport.deleteAll(Song.class, "duration > ?" , "350");
1 
DataSupport.deleteAll(Song.class, "duration > ?" , "350");

6. Query data

Find a single record from song table with specified id: 
Song song = DataSupport.find(Song.class, id);
 
1 
Song song = DataSupport.find(Song.class, id);
Find all records from song table: 
List<Song> allSongs = DataSupport.findAll(Song.class);
1
1
1 
List<Song> allSongs = DataSupport.findAll(Song.class);
Constructing complex query with fluent query: 
List<Song> songs = DataSupport.where("name like ? and duration < ?", "song%", "200")
    .order("duration")
    .find(Song.class);
 
1 
List<Song> songs = DataSupport.where("name like ? and duration < ?", "song%", "200")
2 
    .order("duration")
3 
    .find(Song.class);

7. Async operations

Every database operation is on main thread by default. If your operation might spent a long time, for example saving or querying tons of records. You may want to use async operations.
LitePal support async operations on all crud methods. If you want to find all records from song table on a background thread, use codes like this: 
DataSupport.findAllAsync(Song.class).listen(new FindMultiCallback() {
    @Override
    public <T> void onFinish(List<T> t) {
        List<Song> allSongs = (List<Song>) t;
    }
});
1 
DataSupport.findAllAsync(Song.class).listen(new FindMultiCallback() {
2 
    @Override
3 
    public <T> void onFinish(List<T> t) {
4 
        List<Song> allSongs = (List<Song>) t;
5 
    }
6 
});
Just use findAllAsync() instead of findAll(), and append a listen() method, the finding result will be callback to onFinish() method once it finished.

Abd saving asynchronously is quite the same: 
album.saveAsync().listen(new SaveCallback() {
    @Override
    public void onFinish(boolean success) {
    }
});
1 
album.saveAsync().listen(new SaveCallback() {
2 
    @Override
3 
    public void onFinish(boolean success) {
4 
    }
5 
});
Just use saveAsync() instead of save(). It will save Album into database on a background, and the saving result will be callback to onFinish() method.

8. Multiple databases

If your app needs multiple databases, LitePal support it completely. You can create as many databases as you want at runtime. For example: 
LitePalDB litePalDB = new LitePalDB("demo2", 1);
litePalDB.addClassName(Singer.class.getName());
litePalDB.addClassName(Album.class.getName());
litePalDB.addClassName(Song.class.getName());
LitePal.use(litePalDB);
5
5
1 
LitePalDB litePalDB = new LitePalDB("demo2", 1);
2 
litePalDB.addClassName(Singer.class.getName());
3 
litePalDB.addClassName(Album.class.getName());
4 
litePalDB.addClassName(Song.class.getName());
5 
LitePal.use(litePalDB);
This will create a demo2 database with singer, album and song tables.

If you just want to create a new database but with same configuration as litepal.xml, you can do it with: 
LitePalDB litePalDB = LitePalDB.fromDefault("newdb");
LitePal.use(litePalDB);
 
1 
LitePalDB litePalDB = LitePalDB.fromDefault("newdb");
2 
LitePal.use(litePalDB);

You can always switch back to default database with: 
LitePal.useDefault();
1
1
 
1 
LitePal.useDefault();
And you can delete any database by specified database name: 
LitePal.deleteDatabase("newdb");
1
1
1 
LitePal.deleteDatabase("newdb");

ProGuard

If you are using ProGuard you might need to add the following option: 
-keep class org.litepal.** {
    *;
}
-keep class * extends org.litepal.crud.DataSupport {
    *;
}
1 
-keep class org.litepal.** {
2 
    *;
3 
}
4 
-keep class * extends org.litepal.crud.DataSupport {
5 
    *;
6 
}
2018-5-28

猜你喜欢

转载自www.cnblogs.com/baiqiantao/p/21e0f397e45ffe0485dc0f9aac66f0eb.html
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022