Android数据库框架——ORMLite轻量级的对象关系映射(ORM)Java

 

Android数据库框架——ORMLite轻量级的对象关系映射(ORM)Java

---

事实上，我想写数据库的念头已经很久了，在之前写了一个答题系统的小项目那只是初步的带了一下数据库，数据库是比较强大的，不是我们三言两语就能解决的，我一直想抽个时间自己再过一遍Sqlite和JDBC的，但是，大家也知道，琐事比较多，我们来说一下数据库的框架吧，事实上市面上，我觉得还可以的数据库框架有两个，ORMLite和GreenDao，我以前做的运动类的应用上，就需要存储大量的运动数据，我们最开始是在本地写数据库的，那也是比较老的逻辑了，后来我们准备重构项目的时候，我决定把数据库也重构一下，因为我们当时的应用读取速度来还是比较慢的，比如你有一两年的数据之类的，我后来就研究了一下这两个框架，虽然我最后采用的是GreenDao，但是ORMLite也是研究了一会儿，所以，接下来，我将把这两个框架分两篇文章来分析，首先就是ORMLite了,网上还是有很多关于他们的文章的，所以我也是准备站在巨人的肩膀上，首先他们之间的优缺点，也有前辈写了，你可以参考一下

• SQLite数据库框架ORMLite与GreenDao的简单比较

而且鸿洋老师也写了两篇关于ORMLite的文章

• Android ORMLite 框架的入门用法
• Android 快速开发系列 ORMLite 框架最佳实践

但是就算他们写了，我觉得我再根据自己的逻辑去讲一遍，很多人还是会收益的，我自信我的文笔应该还是算不错的，而且我是基于Androidstudio来讲的。嘻嘻，话不多说，我们来新建一个项目：

一.准备工作

在以前，我们写数据库时怎么写的？那就是频繁的去写SQLiteOpenHelper了，所以后来在我们开发中，很多人就喜欢封装他们，提高性能，也就出现了很多的数据库框架，ORMLite算是一个佼佼者了

• 官网：http://ormlite.com/
• jar下载:http://ormlite.com/releases/

我们根据官方文档来看这个框架是怎么样集成的，官网上有共有四个步骤

• http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_1.html#Getting-Started

知道他需要两个jar,一个android的，一个core的可以直接去下载

然后添加到libs目录下,然后右键——Add As Library就算是添加成功了，紧接着，我们在xml中写个按钮用来创建表和保存数据

     id="@+id/btn_create_save"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="创建表 | 保存数据" />
1
2
3
4
5
1
2
3
4
5

二.Bean类

OK，我们继续看文档，他需要编写一个bean类来声明一些表明和字段的

既然如此，那我们就创建好了，这个类可不简单，它主要通过注解去注明表单信息，然后映射给整个数据库，我们看

package com.lgl.ormlite;

import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;

/**
 * bean类，对应的整个数据库的表单信息，帮助我们映射到整个数据库当中
 * Created by LGL on 2016/6/26.
 */
//配置表名
@DatabaseTable(tableName = "user_info")
public class User {
    //配置主键 id
    @DatabaseField(generatedId = true)
    private int id;
    //名称
    @DatabaseField(columnName = "name")
    private String name;
    //描述
    @DatabaseField(columnName = "desc")
    private String desc;

    //空构造
    public User(){

    }
    //构造方法
    public User(int id, String name, String desc) {
        this.id = id;
        this.name = name;
        this.desc = desc;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

写起来还是逻辑性很强的，如果需要一些特别的参数的话，可以参考一下官网上的项目描述，首先在User类上添加@DatabaseTable(tableName = “user_info”)，标明这是数据库中的一张表名字为user_info，然后分别在属性上添加@DatabaseField(columnName = “name”) ，columnName的值为该字段在数据中的列名，@DatabaseField(generatedId = true) ，generatedId 表示id为主键且自动生成，好了，到这里，我们继续看官方的文档了

三.Dao类

官网写的很详细呀，我们跟着造轮子既可呀，嘿嘿，那我们就来写这个Dao类吧，注意，注释写的很清楚了哦！

package com.lgl.ormlite;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.support.ConnectionSource;
import com.j256.ormlite.table.TableUtils;

import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

/**
 * Dao类
 * Created by LGL on 2016/6/26.
 */
public class DataBaseHelper extends OrmLiteSqliteOpenHelper {

    //创建数据库名称
    private static final String DATABASE_NAME = "ormlite_sql.db";
    //版本号
    private static final int DATABASE_VERSION = 1;
    //存放Dao
    private Map maps = new HashMap<>();

    //单例模式
    private static DataBaseHelper instance;

    public static synchronized DataBaseHelper getInstance(Context context) {
        if (instance == null) {
            synchronized (DataBaseHelper.class) {
                if (instance == null) {
                    instance = new DataBaseHelper(context);
                }
            }
        }
        return instance;
    }

    /**
     * 获得数据库的访问对象
     *
     * @param cls
     * @return
     * @throws SQLException
     */
    public synchronized Dao getDao(Class cls) throws SQLException {
        Dao dao = null;
        //通过反射获得类的名称
        String clsName = cls.getSimpleName();
        //是否存在该对象
        if (maps.containsKey(clsName)) {
            dao = maps.get(clsName);
        } else {
            dao = super.getDao(cls);
            maps.put(clsName, dao);
        }
        return dao;
    }

    /**
     * 关闭所有操作
     */
    public void close() {
        super.close();
        //获取所有的map键值对置空
        for (String key : maps.keySet()) {
            Dao dao = maps.get(key);
            dao = null;
        }
    }

    //构造方法
    public DataBaseHelper(Context context) {
        //上下文，数据库名，null,版本号
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    //创建数据库
    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) {
        try {
            //对数据库的创建以及表的建立
            TableUtils.clearTable(connectionSource, User.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //更新数据库
    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int i, int i1) {
        try {
            //调用更新就删除数据库
            TableUtils.dropTable(connectionSource, User.class, true);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

到这里，我们的前期都OK了，紧接着，我们就可以去操作这些数据了

四.UserDao类

这个类主要是对数据的初始化和操作的

package com.lgl.ormlite;

import android.content.Context;

import com.j256.ormlite.dao.Dao;

import java.sql.SQLException;

/**
 * 数据库操作类
 * Created by LGL on 2016/6/26.
 */
public class UserDao {

    //上下文
    private Context mContext;
    //主键查询
    private DaouserDao;
    //Dao类
    private DataBaseHelper helper;

    public UserDao(Context mContext) {
        this.mContext = mContext;
        //创建数据库
        helper = DataBaseHelper.getInstance(mContext);
        try {
            //操作Dao
            userDao = helper.getDao(User.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void  addUser(User user){
        try {
            userDao.create(user);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

五.增

OK,基本上现在可以去实际的操作了，这个UserDao类我们等下还需要去完善，现在先这样，我们去实现按钮的点击事件

    //点击事件
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_create_save:
                userDao = new UserDao(this);
                User user = new User();
                user.setName("lgl");
                user.setDesc("Android");
                userDao.addUser(user);
                break;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13

到这里，我们就可以去操作了，我们去看数据库，打开DDMS

当然，你也可以打开看看

既然插入成功了，那我们尝试一下多条语句的插入吧

           case R.id.btn_create_save:
                User user = new User();
                user.setName("lgl");
                user.setDesc("Android");
                userDao.addUser(user);

                User user1 = new User();
                user.setName("zhangsan");
                user.setDesc("IOS");
                userDao.addUser(user1);

                User user2 = new User();
                user.setName("lisi");
                user.setDesc("python");

                userDao.addUser(user2);
                break;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

OK,运行一下

六.改

我们继续操作UserDao这个类

    //更新User
    public void updateUser(User user) {
        try {
            userDao.update(user);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

既然可以更新，那我们写个按钮

     id="@+id/btn_update"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="修改数据" />
1
2
3
4
5
1
2
3
4
5

写完之后，我们就可以执行了

       case R.id.btn_update:
                //我们可以修改id为1的这个数据
                User user3 = new User();
                user3.setId(1);
                user3.setName("lgl帅哥");
                userDao.updateUser(user3);
                break;
1
2
3
4
5
6
7
1
2
3
4
5
6
7

我们可以看下结果

OK,这就是我们的改了，我们可以封装一下

    /**
     * 根据ID来更新
     * @param user
     * @param id
     */
    public void updateById(User user,Integer id){
        try {
            userDao.updateId(user,id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

还有一个修改方法

/**
     * 修改数据，支持多条
     *
     * @param user
     */
    public void updateUserByBuilder(User user) {
        try {
            UpdateBuilder builder = userDao.updateBuilder();
            builder.updateColumnValue("name", user.getName()).where().eq("id", 1);
            builder.update();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

七.删除

删除我们可以根据条件删除，就直接贴代码了

   /**
     * 删除
     *
     * @param user
     */
    public void deleteUser(User user) {
        //删除的方法比较多，根据的条件也比较多
        try {
            userDao.delete(user);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 多个对象的删除操作
     *
     * @param users
     */
    public void deleteMulUser(List users) {
        try {
            userDao.delete(users);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据ID删除
     *
     * @param ids
     */
    public void deleteUserById(List ids) {
        try {
            userDao.deleteIds(ids);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

你要删除直接调用就好了

八.查

查算是比较多的场景了，我们也可以多条件查询，看我们全部查询的例子

   /**
     * 全部查询
     *
     * @return
     */
    public List listAll() {
        try {
            return userDao.queryForAll();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13

但是我们一般也不会用到全部查询，条件查询才是必须的，所以我们再新建一个按钮

    id="@+id/btn_query"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="查询数据" />
1
2
3
4
5
6
1
2
3
4
5
6

OK.我们就可以查询了，我们写个单表查询

/**
     * 查询单张表
     *
     * @return
     */
    public List<User> queryBuilder() {
        List<User> list = null;
        //查询器
        QueryBuilder<User, Integer> queryBuilder = userDao.queryBuilder();
        //声明where条件
        Where<User, Integer> where = queryBuilder.where();
        //查询sesc字段的name是哪个值
        try {
            where.eq("name", "lgl");
            where.and();
            where.eq("desc", "Android");
            where.prepare();
            list = queryBuilder.query();
            //select * from user_info where name = 'lgl' and desc = 'Android'
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

注意在点击事件里

 case R.id.btn_query:
     List list = userDao.queryBuilder();
     Log.i(TAG, list.toString());
   break;
1
2
3
4
1
2
3
4

好的，我们现在看Log

我们多条件查询

    /**
     * 多条件查询
     *
     * @return
     */
    public List<User> queryBuilders() {
        List<User> list = null;
        QueryBuilder<User, Integer> queryBuilder = userDao.queryBuilder();
        Where<User, Integer> where = queryBuilder.where();
        try {
            where.or(where.and(where.eq("", ""), where.eq("", "")), where.and(where.eq("", ""), where.ge("", ""))).query();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里我们就不演示了

最后，只能说，ORMLite是比较强大的，我们如果真的要去理解他的话，还是得去看他的API文档，不然真的无从下手，我这篇博文也只是希望大家能对ORMLite有个大概的了解，不敢妄自说精通，好的，本篇博客到这里也就结束了，如果大家觉得还不错的话，不妨点个赞！

Demo下载：http://download.csdn.net/detail/qq_26787115/9562367