数据库开源框架之litepal

主页: [https://github.com/LitePalFramework/LitePal](https://github.com/LitePalFramework/LitePal)

 

---

配置:

1. 引入Jar包或源码

2. 配置litepal.xml

在项目的assets目录下面新建一个litepal.xml文件，并将以下代码拷贝进去：

<?xml version="1.0" encoding="utf-8"?>
<litepal>
    <dbname value="demo" ></dbname>
    <version value="1" ></version>
    <list>
    </list>
</litepal>

 配置文件相当简单，<dbname>用于设定数据库的名字，<version>用于设定数据库的版本号，<list>用于设定所有的映射模型，我们稍后就会用到

3. 配置LitePalApplication

由于操作数据库时需要用到Context，而我们显然不希望在每个接口中都去传一遍这个参数，那样操作数据库就显得太繁琐了。因此，LitePal使用了一个方法来简化掉Context这个参数，只需要在AndroidManifest.xml中配置一下LitePalApplication，所有的数据库操作就都不用再传Context了，如下所示：

<manifest>   
    <application   
        android:name="org.litepal.LitePalApplication"   
      ...   
    >   
    ...   
    </application>   
</manifest> 

 当然，有些程序可能会有自己的Application，并在这里配置过了。比如说有一个MyApplication，如下所示：

<manifest>   
   <application   
        android:name="com.example.MyApplication"   
        ...   
    >   
    ...   
    </application>   
</manifest> 

 这时只需要修改一下MyApplication的继承结构，让它不要直接继承Application类，而是继承LitePalApplication类，就可以使用一切都能正常工作了，代码如下所示：

public class MyApplication extends LitePalApplication {   
    ...   
}  

但是，有些程序可能会遇到一些更加极端的情况，比如说MyApplication需要继承另外一个AnotherApplication，并且这个AnotherApplication还是在jar包当中的，不能修改它的代码。这种情况应该算是比较少见了，但是如果你遇到了的话也不用急，仍然是有解释方案的。你可以把LitePal的源码下载下来，然后把src目录下的所有代码直接拷贝到你项目的src目录下面，接着打开LitePalApplication类，将它的继承结构改成继承自AnotherApplication，再让MyApplication继承自LitePalApplication，这样所有的Application就都可以在一起正常工作了。
所有的配置工作全部完成.

---

建表

LitePal中是如何建表的吧。根据对象关系映射模式的理念，每一张表都应该对应一个模型(Model)，也就是说，如果我们想要建一张news表，就应该有一个对应的News模型类。新建一个News类，然后，表中的每一列其实就是对应了模型类中的一个字段，比如news表中有id、title、content、publishdate、commentcount这几个列，那么在News类中就也应该有这几个字段，代码如下所示：如下所示：

 

package com.loaderman.litepaldemo;
import java.util.Date;
public class News {
    private int id;
    private String title;
    private String content;
    private Date publishDate;
    private int commentCount;
}

 

 

其中id这个字段可写可不写，因为即使不写这个字段，LitePal也会在表中自动生成一个id列，毕竟每张表都一定要有主键的嘛。

这里我要特别说明一下，LitePal的映射规则是非常轻量级的，不像一些其它的数据库框架，需要为每个模型类单独配置一个映射关系的XML，LitePal的所有映射都是自动完成的。根据LitePal的数据类型支持，可以进行对象关系映射的数据类型一共有8种，int、short、long、float、double、boolean、String和Date。只要是声明成这8种数据类型的字段都会被自动映射到数据库表中，并不需要进行任何额外的配置。

现在模型类已经建好了，我们还差最后一步，就是将它配置到映射列表当中。编辑assets目录下的litepal.xml文件，在<list>标签中加入News模型类的声明：

 

<?xml version="1.0" encoding="utf-8"?>
<litepal>
    <dbname value="demo" ></dbname>
    <version value="1" ></version>
    <list>
        <mapping class="com.loaderman.litepaldemo.News"></mapping>
    </list>
</litepal>

只要你对数据库有任何的操作，news表就会被自动创建出来。比如说LitePal提供了一个便捷的方法来获取到SQLiteDatabase的实例，如下所示：

SQLiteDatabase db = Connector.getDatabase();

调用一下上述代码，news表就应该已经创建成功

---

 升级表

添加表或者修改字段

需要创建一张comment表。得先创建一个Comment类了，如下所示：

package com.loaderman.litepaldemo;
public class Comment {
    private int id;
    private String content;
}

Comment类中有id和content这两个字段，也就意味着comment表中会有id和content这两列。

接着修改litepal.xml中的配置，在映射列表中新增Cooment类，并将版本号加1，如下所示：

 

<?xml version="1.0" encoding="utf-8"?>
<litepal>
    <dbname value="demo" ></dbname>
    <version value="2" ></version>
    <list>
        <mapping class="com.loaderman.litepaldemo.News"></mapping>
        <mapping class="com.loaderman.litepaldemo.Comment"></mapping>
    </list>
</litepal>

 

 

升级的操作就已经完成了，现在我们只需要操作一下数据库，comment表就会自动生成了.

如果需要在comment表中添加一个publishdate列,只需要,Comment类中添加这样一个字段,然后需要在litepal.xml中对版本号加1就行了

这样当我们下一次操作数据库的时候，publishdate列就应该会自动添加到comment表中。调用Connector.getDatabase()方法，然后重新查询comment表结构

不是说SQLite不支持删除列的命令吗？那LitePal又是怎样做到的呢？其实LitePal并没有删除任何一列，它只是先将comment表重命名成一个临时表，然后根据最新的Comment类的结构生成一个新的comment表，再把临时表中除了publishdate之外的数据复制到新的表中，最后把临时表删掉。因此，看上去的效果好像是做到了删除列的功能。

这也是使用框架的好处，如果没有框架的帮助，我们显然不会为了删除一个列而大废周章地去写这么多的代码，而使用框架的话，具体的实现逻辑我们已经不用再关心，只需要控制好模型类的数据结构就可以了。

另外，如果你想删除某一张表的话，操作也很简单，在litepal.xml中的映射列表中将相应的类删除，表自然也就不存在了。其它的一些升级操作也都是类似的，相信你已经能举一反三，这里就不再赘述了。

---

表关联

表与表之间的关联关系一共有三种类型，一对一、多对一、和多对多，

一对一

表示两个表中的数据必须是一一对应的关系。这种场景其实并不是很常见，我们还是通过例子来直观地体会一下，

现在已经创建好了news这张表，里面主要记录了新闻的标题和内容，那么除了标题和内容之外，有些新闻还可能带有一些导语和摘要，我们把这两个字段放在一张introduction表中，作为新闻的简介。那么很显然，news表和introduction表就是一对一的关系了，因为一条新闻只能对应一个简介，一个简介也只能属于一条新闻。它们之间的对应关系大概如下图描述的一样：

可以看到，News1对应了Introduction2，News2对应了Introduction3，News3对应了Introduction1，但不管怎么样，它们都是一对一的关系。

由于数据库并不像面向对象的语言一样支持相互引用，如果想让两张表之间建立一对一的关系，一般就只能通过外键的方式来实现了。因此，一对一关系的表结构就可以这样设计：

请注意，introduction表中有一个news_id列，这是一个外键列，里面应该存放一个具体的新闻id，这样一条introduction就能对应一条news，也就实现一对一的关系了，如下图所示：

由此我们就能够看出，id为1的introduction对应着id为2的news，id为2的introduction对应着id为3的news，id为3的introduction对应着id为1的news。需要注意的是，一对一的关系并没有强制要求外键必须加在哪一张表上，你可以在introduction表中加一个news_id作为外键，也可以在news表中加一个introduction_id作为外键，不管使用哪一种，都可以表示出它们是一对一的关联关系。

多对一

表示一张表中的数据可以对应另一张表中的多条数据。这种场景比起一对一关系就要常见太多了，在我们平时的开发工作中多对一关系真的是比比皆是。比如说现在我们的数据库中有一个news表，还有一个comment表，它们两个之间就是典型的多对一关系，一条新闻可以有很多条评论，但是一条评论只能是属于一条新闻的。它们的关系如下图所示：

而这种多对一的关系在编程语言中是非常容易体现出来的，比如Java中就有专门集合类，如List、Set等，使用它们的话就能轻松简单地在对象之间建立多对一的关系，我们稍后就会看到。那么，这里的难点仍然是在数据库表中如何建立这样的多对一关系。现在说难点其实已经不难了，因为前面我们已经学会了一对一关系的建立方法，而多对一也是类似的。没错，数据库表中多对一的关系仍然是通过外键来建立的，只不过一对一的时候外键加在哪一张表上都可以，但多对一的时候关键必须要加在多方的表中。因此，多对一关系的表结构就可以这样设计：

在comment表中有一个news_id列，这是一个外键列，里面应该存放一个具体的新闻id，并且允许多条comment都存放同一个新闻id，这样一条评论就只能对应一条新闻，但一条新闻却可以有多条评论，也就实现多对一的关系了，如下图所示：

由此我们就可以看出，id为1、2、3的三条评论是属于第一条新闻的，而id为4、5的两条评论是属于第二条新闻的。

多对多

表示两张关联表中的数据都可以对应另一张表中的多条数据。这种场景也不算是很常见，但比一对一关系要稍微更加常用一些。举个例子，我们都知道新闻网站是会将新闻进行种类划分的，这样用户就可以选择自己喜欢的那一类新闻进行浏览，比如说网易新闻中就会有头条、科技、娱乐、手机等等种类。每个种类下面当然都会有许多条新闻，而一条新闻也可能是属于多个种类的，比如iPhone6发布的新闻既可以属于手机种类，也可以属于科技种类，甚至还可以上头条。因此，新闻和种类之间就是一种多对多的关系，如下图所示：

可以看到，News1是属于Category1的，而News2和News3都是既属于Category1也属于Category2，如此复杂的关联关系该如何表示呢？在面向对象的编程语言中一切都是那么的简单，只需要在News类中使用集合类声明拥有多个Category，然后在Category类中也使用集合类声明拥有多个News就可以了，我们稍后就会看到。而难点仍然是留在了数据库上，两张表之间如何建立多对多的关联关系呢，还是用外键吗？肯定不行了，多对多的情况只能是借助中间表来完成了。也就是说，我们需要多建立一张表，这张表没什么其它作用，就是为了存放news表和category表之间的关联关系的，如下图所示：

注意这里我们建立一张名为category_news的中间表，中间表的命名并没有什么强制性的约束，但一个良好的命名规范可以让你一眼就明白这张表是用来做什么的。中间表里面只有两列，而且也只需要有两列，分别是news表的外键和category表的外键，在这里存放新闻和种类相应的id，就可以让它们之间建立关联关系了，如下图所示：

由此我们就可以看出，第一条新闻是属于第一个种类的，而第二和第三条新闻，则既属于第一个种类，也属于第二个种类。反过来也可以这样看，第一个种类下面有第一、第二、第三这三条新闻，而第二个种类下面只有第二、第三这两条新闻。不管怎么看，多对多的关系都是成立的。

总结:即一对一关联的实现方式是用外键，多对一关联的实现方式也是用外键，多对多关联的实现方式是用中间表。

---

使用LitePal建立表关联

还需要有Introduction和Category这两个类，新建Introduction类，代码如下所示：

package com.loaderman.litepaldemo;
public class Category {
    private int id;
    private String name;
}

---

package com.loaderman.litepaldemo;
public class Introduction {
    private int id;
    private String guide;
    private String digest;
}

现在四个类都已经建好了，但目前它们都还是各自独立的，互相之间没有任何联系，那么我们现在就开始用极为简单易懂的方式来给它们建立关联吧。首先，News和Introduction是一对一的关系，那就可以在News类中添加如下引用：

private Introduction introduction;

就是这么简单，在News类中可以得到一个对应的Introduction的实例，那么它们之间就是一对一关系了。

接着Comment和News是多对一的关系，因此News中应该包含多个Comment，而Comment中应该只有一个News，所以就可以这样写：

private List<Comment> commentList = new ArrayList<Comment>(); 

 先使用一个泛型为Comment的List集合来表示News中包含多个Comment，然后修改Comment类的代码，如下所示：

private News news; 

在Comment类中声明了一个News的实例，这样就清楚地表示出了News中可以包含多个Comment，而Comment中只能有一个News，也就是多对一的关系了。

最后News和Category是多对多的关系，相信聪明的你一定已经知道该怎么写了。News中可以包含多个Category，所以仍然应该使用List集合来表示

 

private List<Category> categoryList = new ArrayList<Category>();  

 而Category中也可以包含多个News，因此Category类也应该使用相同的写法，如下所示：

private List<News> newsList = new ArrayList<News>();

关联关系都声明好了之后，我们只需要将所有的实体类都添加到映射列表当中，并将数据库版本号加1就可以了。修改litepal.xml的代码，如下所示

<?xml version="1.0" encoding="utf-8"?>
<litepal>
    <dbname value="demo" ></dbname>
    <version value="4" ></version>
    <list>
        <mapping class="com.loaderman.litepaldemo.News"></mapping>
        <mapping class="com.loaderman.litepaldemo.Comment"></mapping>
        <mapping class="com.loaderman.litepaldemo.Category"></mapping>
        <mapping class="com.loaderman.litepaldemo.Introduction"></mapping>
    </list>
</litepal>

基本上到这里就可以轻松地说结束了，现在只需要任意操作一下数据库，表之间的关联关系就将会自动建立，比如说调用一下Connector.getDatabase()方法。

查看表结构发现:

introduction表的结构,多了一个news_id列，说明introduction表和news表之间的一对一关系

comment表的结构comment表中也有一个news_id的列，那么comment表和news表之间的多对一关系也已经建立好了

category_news这张中间表一共只有两列，一列是news_id，一列是category_id，分别对应着两张表的外键，这样news表和category表的多对多关系也建立好了

 

---

使用LitePal存储数据

在项目里已经建好了News、Comment、Introduction、Category这几个实体类，通过这些实体类，LitePal就可以把相应的表自动创建出来。现在来观察这几个实体类，我们发现这几个类都是没有继承结构的。没错，因为LitePal进行表管理操作时不需要这些实体类有任何的继承结构，当时为了简单起见就没有写。但是进行CRUD操作时就不行了，LitePal要求所有的实体类都要继承自DataSupport这个类，因此这里我们就要把继承结构给加上才行。修改News类的代码，如下所示：

• public class News extends DataSupport{ }

  可以看到，这里只是让News类继承自了DataSupport，其它什么都没有改变。另外几个Comment、Introduction、Category类也使用同样的改法

  继承了DataSupport类之后，这些实体类就拥有了进行CRUD操作的能力，那么比如想要存储一条数据到news表当中，就可以这样写

News news = new News();
news.title="这是一条新闻标题";
news.content="这是一条新闻内容";
news.publishDate=new Date();
news.save();

 除此之外，save()方法还是有返回值的，我们可以根据返回值来判断存储是否成功

save()方法返回的是一个布尔值，用于表示存储成功还是失败，但同时也说明这个方法是不会抛出异常的。有些朋友希望如果存储失败的话就抛出异常，而不是返回一个false，那就可以使用saveThrows()方法来代替

使用saveThrows()方法来存储数据，一旦存储失败就会抛出一个DataSupportException异常，我们可以通过对这个异常进行捕获来处理存储失败的情况。

LitePal在存储数据的时候默默帮我们做了很多的事情，比如多个实体类之间有关联关系的话，我们不需要考虑在存储数据的时候怎么去建立数据与数据之间的关联，因为LitePal一切都帮我们做好了。

还是通过一个例子来看一下吧，Comment和News之间是多对一的关系，一条News中是可以包含多条评论的，因此我们就可以这样写：

Comment comment1 = new Comment(); 
comment1.setContent("好评！"); 
comment1.setPublishDate(new Date()); 
comment1.save(); 
Comment comment2 = new Comment(); 
comment2.setContent("赞一个"); 
comment2.setPublishDate(new Date()); 
comment2.save(); 
News news = new News(); 
news.getCommentList().add(comment1); 
news.getCommentList().add(comment2); 
news.setTitle("第二条新闻标题"); 
news.setContent("第二条新闻内容"); 
news.setPublishDate(new Date()); 
news.setCommentCount(news.getCommentList().size()); 
news.save(); 

可以看到，这里先是存储了一条comment1数据，然后存储一条comment2数据，接着在存储News之前先把刚才的两个Comment对象添加到了News的commentList列表当中，这样就表示这两条Comment是属于这个News对象的，最后再把News存储到数据库中，这样它们之间的关联关系就会自动建立了。

LitePal对集合数据的存储还专门提供了一个方法，比如说我们有一个News集合，那么应该怎样去存储这个集合中的每条News呢？传统情况下可以这样写：通过一个循环来遍历出这个集合中的每一个News对象，然后逐个调用save()方法。这样的写法当然是可以的，但是效率会比较低，因为调用save()方法的时候除了会执行存储操作之外，还会去分析News类的关联关系，那么每次循环都去重新分析一遍关联关系显然是比较耗时的。因此，LitePal提供了一个saveAll()方法，专门用于存储集合数据的，用法如下所示：

  List<News> newsList; 
  ... 
  DataSupport.saveAll(newsList);

 saveAll()方法接收一个Collection集合参数，只要把待存储的集合数据传入即可。这个方法可以完成和上面一段代码完全一样的功能，但效率却会高得多，而且写法也更加简单。

---

LitePal的修改和删除操作

public static int update(Class<?> modelClass, ContentValues values, long id) 

ContentValues values = new ContentValues();
values.put("title", "今日iPhone6发布");
DataSupport.update(News.class, values, 2);

 public static int updateAll(Class<?> modelClass, ContentValues values, String... conditions)

updateAll()方法表示修改多行记录，其中第一个参数仍然是Class，第二个参数还是ContentValues对象，第三个参数是一个conditions数组，用于指定修改哪些行的约束条件，返回值表示此次修改影响了多少行数据。比如说我们想把news表中标题为“今日iPhone6发布”的所有新闻的标题改成“今日iPhone6 Plus发布”，就可以这样写：

ContentValues values = new ContentValues();
values.put("title", "今日iPhone6 Plus发布");
DataSupport.updateAll(News.class, values, "title = ?", "今日iPhone6发布");

 重点我们看一下最后的这个conditions数组，由于它的类型是一个String数组，我们可以在这里填入任意多个String参数，其中最前面一个String参数用于指定约束条件，后面所有的String参数用于填充约束条件中的占位符(即?号)，比如约束条件中有一个占位符，那么后面就应该填写一个参数，如果有两个占位符，后面就应该填写两个参数，以此类推。

比如说我们想把news表中标题为“今日iPhone6发布”且评论数量大于0的所有新闻的标题改成“今日iPhone6 Plus发布”，就可以这样写：

ContentValues values = new ContentValues();
values.put("title", "今日iPhone6 Plus发布");
DataSupport.updateAll(News.class, values, "title = ? and commentcount > ?", "今日iPhone6发布", "0");

可以看出，通过占位符的方式来实现条件约束明显要比原生的API更加简单易用。

那么如果我们想把news表中所有新闻的标题都改成“今日iPhone6发布”，该怎么写呢？其实这就更简单了，只需要把最后的约束条件去掉就行了，如下所示：

ContentValues values = new ContentValues();
values.put("title", "今日iPhone6 Plus发布");
DataSupport.updateAll(News.class, values);

当然有些朋友可能会觉得这样用起来还是有点复杂，因为这个ContentValues对象很烦人，每次创建它的时候都要写很多繁琐的代码。没关系，LitePal也充分考虑了这种情况，提供了一种不需要ContentValues就能修改数据的方法，下面我们尝试使用这种新方法来完成上述同样的功能。

比如把news表中id为2的记录的标题改成“今日iPhone6发布”，就可以这样写：

News updateNews = new News();
updateNews.setTitle("今日iPhone6发布");
updateNews.update(2);

这次我们并没有用ContentValues，而是new出了一个News对象，把要修改的数据直接set进去，最后调用一下update()方法并传入id就可以了。不仅不用创建ContentValues对象，连表名都不用指定了，因为News对象默认就是修改的news表。

这是其中一种用法，那么如果我们想把news表中标题为“今日iPhone6发布”且评论数量大于0的所有新闻的标题改成“今日iPhone6 Plus发布”，就可以这样写：

News updateNews = new News();
updateNews.setTitle("今日iPhone6发布");
updateNews.updateAll("title = ? and commentcount > ?", "今日iPhone6发布", "0");

 但是这种用法有一点需要注意，就是如果我们想把某一条数据修改成默认值，比如说将评论数修改成0，只是调用updateNews.setCommentCount(0)这样是不能修改成功的，因为即使不调用这行代码，commentCount的值也默认是0。所以如果想要将某一列的数据修改成默认值的话，还需要借助setToDefault()方法。用法也很简单，在setToDefault()方法中传入要修改的字段名就可以了(类中的字段名)，比如说我们想要把news表中所有新闻的评论数清零，就可以这样写：

News updateNews = new News();
updateNews.setToDefault("commentCount");
updateNews.updateAll();

---

 使用LitePal删除数据

public static int delete(Class<?> modelClass, long id)

delete()方法接收两个参数，第一个参数是Class，传入我们要删除的那个类的Class就好，第二个参数是一个指定的id，表示我们要删除哪一行数据。

那么比如说我们想删除news表中id为2的记录，就可以这样写：

DataSupport.delete(News.class, 2);

需要注意的是，这不仅仅会将news表中id为2的记录删除，同时还会将其它表中以news id为2的这条记录作为外键的数据一起删除掉，因为外键既然不存在了，那么这么数据也就没有保留的意义了。

DataSupport中也提供了一个通过where语句来批量删除数据的方法，先看一下方法定义：

public static int deleteAll(Class<?> modelClass, String... conditions) 

看起来很眼熟吧？非常简单，deleteAll()方法接收两个参数，第一个参数是Class，传入我们要删除的那个类的Class就好，第二个参数是一个conditions数组，用于指定删除哪些行的约束条件，返回值表示此次删除了多少行数据，用法和updateAll()方法是基本相同的。

那么比如说我们想把news表中标题为“今日iPhone6发布”且评论数等于0的所有新闻都删除掉，就可以这样写：

　DataSupport.deleteAll(News.class, "title = ? and commentcount = ?", "今日iPhone6发布", "0");

而如果我们想把news表中所有的数据全部删除掉，就可以这样写：

DataSupport.deleteAll(News.class); 

在不指定约束条件的情况下，deleteAll()方法就会删除表中所有的数据了

除了DataSupport类中提供的静态删除方法之外，还有一个删除方法是作用于对象上的，即任何一个继承自DataSupport类的实例都可以通过调用delete()这个实例方法来删除数据。但前提是这个对象一定是要持久化之后的，一个非持久化的对象如果调用了delete()方法则不会产生任何效果
比如说下面这种写法：

    News news = new News();
    news.delete();

这里new出了一个News对象，这个对象明显是没有持久化的，那么此时调用delete()方法则不会删除任何数据。但如果我们之前将这个对象持久化过了，那么再调用delete()方法就会把这个对象对应的数据删除掉了，比如：

News news = new News();   
news.setTitle("这是一条新闻标题");   
news.setContent("这是一条新闻内容");   
news.save();   
...   
news.delete();

一个对象如果save过了之后，那就是持久化的了。除了调用save()方法之外，通过DataSupport中提供的查询方法从数据库中查出来的对象也是经过持久化的，查询的功能我们会在下篇博客中讲解。

另外还有一个简单的办法可以帮助我们判断一个对象是否是持久化之后的，DataSupport类中提供了一个isSaved()方法，这个方法返回true就表示该对象是经过持久化的，返回false则表示该对象未经过持久化。那么删除一个对象对应的数据也就可以这样写了：

News news;   
...   
if (news.isSaved()) {   
    news.delete();   
}  

---

查询

查询news表中id为1的这条记录,使用LitePal就可以这样写

News news = DataSupport.find(News.class, 1); 

 想要获取news表中的第一条数据，只需要这样写：

News firstNews = DataSupport.findFirst(News.class); 

 想要获取News表中的最后一条数据:

    News lastNews = DataSupport.findLast(News.class); 

 news表中id为1、3、5、7的数据都查出来,这时候用findAll()。这个方法的用法和find()方法是非常类似的，只不过它可以指定多个id，并且返回值也不再是一个泛型类对象，而是一个泛型类集合，如下所示：

　　List<News> newsList = DataSupport.findAll(News.class, 1, 3, 5, 7); 

 可以看到，首先我们是调用的findAll()方法，然后这个方法的第一个参数仍然是指定的泛型类，但是后面的参数就很随意了，你可以传入任意个id进去，findAll()方法会把所有传入的id所对应的数据全部查出来，然后一起返回到List<News>这个泛型集合当中。

虽说这个语法设计算是相当人性化，但是在有些场景或许不太适用，因为可能要你要查询的多个id已经封装到一个数组里了。那么没关系，findAll()方法也是接收数组参数的，所以说同样的功能你也可以这样写：

    long[] ids = newlong[] { 1, 3, 5, 7 };
    List<News> newsList = DataSupport.findAll(News.class, ids);

 查询所有数据的写法更简单，只需要这样写：

    List<News> allNews = DataSupport.findAll(News.class); 

连缀查询:

这种查询很灵活，可以根据我们实际的查询需求来动态配置查询参数。 那这里举个简单的例子，比如我们想查询news表中所有评论数大于零的新闻，就可以这样写：

List<News> newsList = DataSupport.where("commentcount > ?", "0").find(News.class); 

可以看到，首先是调用了DataSupport的where()方法，在这里指定了查询条件。where()方法接收任意个字符串参数，其中第一个参数用于进行条件约束，从第二个参数开始，都是用于替换第一个参数中的占位符的。那这个where()方法就对应了一条SQL语句中的where部分。

接着我们在where()方法之后直接连缀了一个find()方法，然后在这里指定一个泛型类，表示用于查询哪张表。那么上面的一段代码，查询出的结果和如下SQL语句是相同的：

    select * from users where commentcount > 0; 

但是这样会将news表中所有的列都查询出来，也许你并不需要那么多的数据，而是只要title和content这两列数据。那么也很简单，我们只要再增加一个连缀就行了，如下所示：

    List<News> newsList = DataSupport.select("title", "content") 
　　　　　　　　　　　　　　　.where("commentcount > ?", "0").find(News.class);  

可以看到，这里我们新增了一个select()方法，这个方法接收任意个字符串参数，每个参数要求对应一个列名，这样就只会把相应列的数据查询出来了，因此select()方法对应了一条SQL语句中的select部分。

那么上面的一段代码，查询出的结果和如下SQL语句是相同的：

    select title,content from users where commentcount > 0; 

 

比如说，我希望将查询出的新闻按照发布的时间倒序排列，即最新发布的新闻放在最前面，那就可以这样写：

 

    List<News> newsList = DataSupport.select("title", "content") 
　　　　　　　　　　　　　　　　.where("commentcount > ?", "0")
　　　　　　　　　　　　　　　　.order("publishdate desc").find(News.class); 

order()方法中接收一个字符串参数，用于指定查询出的结果按照哪一列进行排序，asc表示正序排序，desc表示倒序排序，因此order()方法对应了一条SQL语句中的order by部分。

那么上面的一段代码，查询出的结果和如下SQL语句是相同的：

    select title,content from users where commentcount > 0 orderby publishdate desc; 

然后呢，也许你并不希望将所有条件匹配的结果一次性全部查询出来，因为这样数据量可能会有点太大了，而是希望只查询出前10条数据，那么使用连缀同样可以轻松解决这个问题，代码如下所示：

List<News> newsList = DataSupport.select("title", "content")
　　.where("commentcount > ?", "0")
　　.order("publishdate desc").limit(10).find(News.class);

• 这里我们又连缀了一个limit()方法，这个方法接收一个整型参数，用于指定查询前几条数据，这里指定成10，意思就是查询所有匹配结果中的前10条数据。

  那么上面的一段代码，查询出的结果和如下SQL语句是相同的：

  select title,content from users where commentcount > 0 order by publishdate desc limit 10;
  

  刚才我们查询到的是所有匹配条件的前10条新闻，那么现在我想对新闻进行分页展示，翻到第二页时，展示第11到第20条新闻，这又该怎么实现呢？没关系，在LitePal的帮助下，这些功能都是十分简单的，只需要再连缀一个偏移量就可以了，如下所示：

  List<News> newsList = DataSupport.select("title", "content")
  .where("commentcount > ?", "0")
  .order("publishdate desc").limit(10).offset(10)
  .find(News.class); 
  

可以看到，这里我们又添加了一个offset()方法，用于指定查询结果的偏移量，这里指定成10，就表示偏移十个位置，那么原来是查询前10条新闻的，偏移了十个位置之后，就变成了查询第11到第20条新闻了，如果偏移量是20，那就表示查询第21到第30条新闻，以此类推。因此，limit()方法和offset()方法共同对应了一条SQL语句中的limit部分。

那么上面的一段代码，查询出的结果和如下SQL语句是相同的：

select title,content from users where commentcount > 0 orderby publishdate desc limit 10,10;

---

激进查询

不过，上述我们的所有用法中，都只能是查询到指定表中的数据而已，关联表中数据是无法查到的，因为LitePal默认的模式就是懒查询，当然这也是推荐的查询方式。那么，如果你真的非常想要一次性将关联表中的数据也一起查询出来，当然也是可以的，LitePal中也支持激进查询的方式，下面我们就来一起看一下。

不知道你有没有发现，刚才我们所学的每一个类型的find()方法，都对应了一个带有isEager参数的方法重载，这个参数相信大家一看就明白是什么意思了，设置成true就表示激进查询，这样就会把关联表中的数据一起查询出来了。

比如说，我们想要查询news表中id为1的新闻，并且把这条新闻所对应的评论也一起查询出来，就可以这样写：

News news = DataSupport.find(News.class, 1, true);
List<Comment> commentList = news.getCommentList(); 

可以看到，这里并没有什么复杂的用法，也就是在find()方法的最后多加了一个true参数，就表示使用激进查询了。这会将和news表关联的所有表中的数据也一起查出来，那么comment表和news表是多对一的关联，所以使用激进查询一条新闻的时候，那么该新闻所对应的评论也就一起被查询出来了。

激进查询的用法非常简单，就只有这么多，其它find()方法也都是同样的用法，就不再重复介绍了。但是这种查询方式LitePal并不推荐，因为如果一旦关联表中的数据很多，查询速度可能就会非常慢。而且激进查询只能查询出指定表的关联表数据，但是没法继续迭代查询关联表的关联表数据。因此，这里我建议大家还是使用默认的懒加载更加合适，至于如何查询出关联表中的数据，其实只需要在模型类中做一点小修改就可以了。修改News类中的代码，如下所示：

　　 public class News extends DataSupport{
    ...
   　　 public List<Comment> getComments() {
    　　　　return DataSupport.where("news_id = ?", String.valueOf(id)).find(Comment.class);
   　　 }
    }

可以看到，我们在News类中添加了一个getComments()方法，而这个方法的内部就是使用了一句连缀查询，查出了当前这条新闻对应的所有评论。改成这种写法之后，我们就可以将关联表数据的查询延迟，当我们需要去获取新闻所对应的评论时，再去调用News的getComments()方法，这时才会去查询关联数据。这种写法会比激进查询更加高效也更加合理。

原生查询

相信你已经体会到，LitePal在查询方面提供的API已经相当丰富了。但是，也许你总会遇到一些千奇百怪的需求，可能使用LitePal提供的查询API无法完成这些需求。没有关系，因为即使使用了LitePal，你仍然可以使用原生的查询方式(SQL语句)来去查询数据。DataSuppport类中还提供了一个findBySQL()方法，使用这个方法就能通过原生的SQL语句方式来查询数据了，如下所示：

    Cursor cursor = DataSupport.findBySQL("select * from news where commentcount>?", "0"); 

findBySQL()方法接收任意个字符串参数，其中第一个参数就是SQL语句，后面的参数都是用于替换SQL语句中的占位符的，用法非常简单。另外，findBySQL()方法返回的是一个Cursor对象，这和原生SQL语句的用法返回的结果也是相同的。

---

使用LitePal的聚合函数

LitePal中一共提供了count()、sum()、average()、max()和min()这五种聚合函数，基本上已经将SQL语句当中最常用的几种聚合函数都覆盖了，那么下面我们就来对这五种聚合函数的用法

count()

count()方法主要是用于统计行数的，刚才演示了如何通过SQL语句来统计news表中一共有多少行，那么下面我们来看一下如何通过LitePal来实现同样的功能，代码如下所示：

int result = DataSupport.count(News.class); 

你没有看错！就是这样一行代码就可以了。调用DataSupport类当中的count()方法，count()方法接收一个Class参数，用于指定去统计哪张表当中的数据，然后返回值是一个整型数据，也就是统计出的结果了。

除此之外，LitePal中所有的聚合函数都是支持连缀的，也就是说我们可以在统计的时候加入条件语句。比如说想要统计一共有多少条新闻是零评论的，就可以这样写：

    int result = DataSupport.where("commentcount = ?", "0").count(News.class); 

这个用法和我们在上一篇文章当中学到的连缀查询是比较像的，在DataSupport类中首先指定一个where语句用于条件约束，然后连缀一个count()方法，这样统计出的就是满足条件语句的结果了。连缀不仅适用于count()方法，也同样适用于下面我们将要介绍的所有方法，但由于用法都是相同的，后面就不再重复介绍了。

sum()

看完了count()方法应该是觉得非常简单吧，剩下的几个聚合函数也是同样简单的，我们继续来学习一下。

sum()方法主要是用于对结果进行求合的，比如说我们想要统计news表中评论的总数量，就可以这样写：

    int result = DataSupport.sum(News.class, "commentcount", int.class); 

sum()方法的参数要稍微多一点，我们来一一看下。第一个参数很简单，还是传入的Class，用于指定去统计哪张表当中的数据。第二个参数是列名，表示我们希望对哪一个列中的数据进行求合。第三个参数用于指定结果的类型，这里我们指定成int型，因此返回结果也是int型。

需要注意的是，sum()方法只能对具有运算能力的列进行求合，比如说整型列或者浮点型列，如果你传入一个字符串类型的列去求合，肯定是得不到任何结果的，这时只会返回一个0作为结果。

average()

average()方法主要是用于统计平均数的，比如说我们想要统计news表中平均每条新闻有多少评论，就可以这样写:

    double result = DataSupport.average(News.class, "commentcount"); 

其中average()方法接收两个参数，第一个参数不用说，仍然是Class。第二个参数用于指定列名的，表示我们想要统计哪一列的平均数。需要注意的是，这里返回值的类型是double型，因为平均数基本上都是会带有小数的，用double类型可以最大程序保留小数位的精度。

同样地，average()方法也只能对具有运算能力的列进行求平均值，如果你传入了一个字符串类型的列，也是无法得到任何结果的，这时同样只会返回一个0作为结果。

max()

max()方法主要用于求出某个列中最大的数值，比如我们想要知道news表中所有新闻里面最高的评论数是多少，就可以这样写：

int result = DataSupport.max(News.class, "commentcount", int.class); 

可以看到，max()方法接收三个参数，第一个参数同样还是Class，用于指定去统计哪张表当中的数据。第二个参数是列名，表示我们希望统计哪个列中的最大值。第三个参数用于指定结果的类型，根据实际情况来选择传入哪种类型就行了。

那么不用多说，max()方法也只能对具有运算能力的列进行求最大值的，希望你在使用的时候能够谨记这一点。

min()

min()方法主要用于求出某个列中最小的数值，比如我们想要知道news表中所有新闻里面最少的评论数是多少，就可以这样写：

    int result = DataSupport.min(News.class, "commentcount", int.class); 

min()方法和max()方法的用法基本上是一模一样的，参数也是完全相同，只是方法名变了一下。它们一个是求出某一列中的最大值，一个是求出某一列中的最小值，仅此而已。

News news;  
...  
if (news.isSaved()) {  
    news.delete();  
}