Android 数据库—ORMlite 框架详情

前言

本篇博客记录一下笔者在实际开发中使用到的一个数据库框架，这个可以让我们快速实现数据库操作，避免频繁手写sql，提高我们的开发效率，减少出错的机率。

ORMlite是什么？

它的英文全称是Object Relational Mapping，意思是对象关系映射；是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。

面向对象是从软件工程基本原则(如耦合、聚合、封装)的基础上发展起来的，而关系数据库则是从数学理论发展而来的. 两者之间是不匹配的.而ORM作为项目中间件形式实现数据在不同场景下数据关系映射. 对象关系映射是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术.ORM就是这样而来的。

基于注解和反射的的方式,导致ormlite性能有着一定的损失(注解其实也是利用了反射的原理)

为什么要用ormlite？

优点：
1. 轻量级
2. 使用简单，易上手
3. 封装完善
4. 文档全面
缺点

1.基于反射，效率较低
2.缺少中文翻译文档

ORMlite的使用

建立映射关系
Ormlite与数据库的映射关系式通过注释来说明的。
注释分为对于表的和对于单个列的：@DatabaseTable ，注释表的， @DatabaseField 注释单个列的。
首先注释：table，@DatabaseTable 如果默认为类名的话，后面不需要添加类名注释。
然后：确定需要的字段，在字段上面添加注释：@DatabaseField 如果对字段有特别的要求，那么添加以下相关的注释，例如id

DatabaseTable(tableName = "school")  
public class School {  
    @DatabaseField(generatedId=true)  
    private int id;  
    public int getId() {  
        return id;  
    }  

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

下面通过注解的方式配置该类的持久化参数：

1.表名：

@DatabaseTable(tableName=”dataTableName”)
不指定的话表名就是类名。

2.字段
@DatabaseField
这个可以配置的属性有点多。
2.1 主键

< class=”brush:java;gutter:false;”>@DatabaseField(id=true)
2.2 列名

< class=”brush:java;gutter:false;”>@DatabaseField(columnName=”columnName”)
不指定的话就是和变量名一样的

2.3 数据类型

< class=”brush:java;gutter:false;”>@DatabaseField(dataType=DataType.INTEGER)
这个一般情况下都不用指定，可以根据java 类获得

2.4 默认值

< class=”brush:java;gutter:false;”>@DatabaseField(defaultValue=”0”)
2.5 长度

< class=”brush:java;gutter:false;”>@DatabaseField(width=13)
一般用于String型

2.6 能否为空

< class=”brush:java;gutter:false;”>@DatabaseField(canBeNull=false)
默认为True

2.7 是否自增长

< class=”brush:java;gutter:false;”>@DatabaseField(generatedId=true)
这是一些比较简单的，关于外键啥的下篇文章再说吧。

继承OrmLiteSqliteOpenHelper类定义数据库帮助类

在Android的开发中，google原版封装了一个SqliteOpenHelper，供开发者调用，在OrmLite中，对原版的工具进行了加强，提供一个继承自SqliteOpenHelper的OrmLiteSqliteOpenHelper工具。

public class MySqlOpenHelper extends OrmLiteSqliteOpenHelper {

    private Dao<Person, Integer> mPersonDao;
       //初始化表，创建表名，版本，游标工厂
    public MySqlOpenHelper(Context context) {
        super(context, "test", null, 1);
    }

    @Override
    public void onCreate(SQLiteDatabase arg0, ConnectionSource arg1) {

        try {
            //创建数据表
            TableUtils.createTableIfNotExists(arg1, Person.class);
        } catch (java.sql.SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onUpgrade(SQLiteDatabase arg0, ConnectionSource arg1, int arg2,
            int arg3) {

    }
  }
  public class DBHelper extends OrmLiteSqliteOpenHelper{  


    private final static int DATABASE_VERSION = 1;  
    Dao<Student, Integer> mStudentDao;  
    Dao<School, Integer> mSchoolDao;  
    private static final String DB_NAME = "orm";  
    private static DBHelper mDbHelper;  

    private DBHelper(Context context) {  
        super(context, DB_NAME, null, DATABASE_VERSION);  
    }  


    public static DBHelper getInstance(Context context) {  
        if (mDbHelper == null) {  
            mDbHelper = new DBHelper(context);  
        }  
        return mDbHelper;  
    }  

    @Override  
    public void onCreate(SQLiteDatabase arg0, ConnectionSource arg1) {  
        try {  
            TableUtils.createTableIfNotExists(connectionSource, Student.class);  
            TableUtils.createTableIfNotExists(connectionSource, School.class);  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }  
    }  


    @Override  
    public void onUpgrade(SQLiteDatabase arg0, ConnectionSource arg1, int arg2,  
            int arg3) {  
    }  

    public Dao<Student, Integer> getStudentDao() throws SQLException {  
        if (mStudentDao == null) {  
            mStudentDao = getDao(Student.class);  
        }  
        return mStudentDao;  
    }  

    public Dao<School, Integer> getSchoolDao() throws SQLException {  
        if (mSchoolDao == null) {  
            mSchoolDao = getDao(School.class);  
        }  
        return mSchoolDao;  
    }  


}  

如果写过android的SqliteOpenHelper对这个继承类的写法一定不会陌生。
我解释一下这个的写法：
· 构造函数：
必须调用父类的构造函数，能给它提供的参数有：来自android的context，数据库名称，和版本号。
· GetInstance方法：
这个只是为了方便，让DbHelper只保留一个对象的实例，即单例模型。
· OnCreate
实现父类的抽象方法，创建数据库。
· OnUpgrade
在构造方法中的version如果改变的话，调用这个方法，至于想做什么，这个你来定。常用于app 的版本更新。
· getStudentDao和 getSchoolDao
获取数据库的dao对象，这些dao对象用于后来的数据库操作。dao的声明时泛型了两个参数，第一个是dao操作的关联对象，第二个是标记数据表的ID。这个ID一般很少使用，除非对数据表的ID进行操作的时候。

定义Bean的DAO，对数据库进行增、删、改、查
Dao是一个很重要的类， 这些Dao对象用于以后的数据库操作，其包含两个泛型,第一个泛型表DAO操作的类，第二个是标记数据表的ID。

插入操作

这些方法使用起来都比较简单，我们只需将自己的Bean传入到下列方法中即可

create:插入一条数据
createIfNotExists:如果不存在则插入
createOrUpdate:如果存在则更新

查询操作
OrmLite为我提供了一系列的查询操作，方法很多，而且很多都是只看方法名就可以知道的，这里就不逐一介绍了，在这里介绍一下如何使用QueryBuilder进行复杂查找。

首先调用personDao.queryBuilder();获得该Dao下的QueryBuilder对象，
接下来设置QueryBuilder的查询条件，
最后通过QueryBuilder的query方法获得List对象，

下面介绍几个常用的builder下的查询，
1.多字段条件查询：

QueryBuilder builder = dao.queryBuilder();
builder.where().eq("字段名1","条件1").and.eq(""字段名2","条件2");
builder.query();

2.查询并按顺序输出

QueryBuilder<Person, Integer> builder = dao.queryBuilder();
builder.orderBy("字段名", true);
builder.query();

orderBy的方法第一参数表示按那个字段进行排序，第二个参数表示是否为升序。
3.分页查询

QueryBuilder<Person, Integer> builder = dao.queryBuilder();
builder.offset(10);//表示查询的起始位置
builder.limit(10);//表示总共获取的对象数量
builder.query();

Demo第1颗栗子

依赖

 compile 'com.j256.ormlite:ormlite-android:5.0'

建立映射关系

//映射关系即时对应关系 .1.类名与表名 2.变量与列名
@DatabaseTable(tableName = "t_person")
public class Person {
    @DatabaseField(columnName = "_id", generatedId = true)
    private int id;
    @DatabaseField(columnName = "name")
    private String name;
    @DatabaseField(columnName = "age")
    private int age;
    //强制要求  无参构造函数 与get/set方法
    public Person() {
    }
    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

创建Helper，继承 ormlite的Helper

public class MyHelper extends OrmLiteSqliteOpenHelper {
    private static final String databaseName = "orm.db";
    private static final SQLiteDatabase.CursorFactory factory = null;
    private static final int databaseVersion = 1;
    //2.1.2.设置数据名称,版本，游标工厂
    public MyHelper(Context context) {
        super(context, databaseName, factory, databaseVersion);
    }
    @Override
    public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
        //2.2.创建表 TableUtils为Ormlite提供一个表操作工具  参1.数据库实例 参2.javaBean类
        try {
            TableUtils.createTable(connectionSource,Person.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
    }
}

增删改查

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //使用Orm设计创建一个封装好的数据库框架
        // 对象关系模型映射 Object Relation Mapping  使用开发者在数据库操作时感觉在操作集合的增删改查    //注解变量:以@开头,可以标注在类，方法，成员变量。
        //步骤二。使用Ormlite保存数据，修改数据，查找数据
        //2.3.增删改查
    }
    public void crud(View view) {
       // testAdd();
        try {
            Dao<Person, Integer> dao = new MyHelper(this).getDao(Person.class);
            //根据 id进行删除
            dao.deleteById(1);
            //查询所有
            List<Person> persons = dao.queryForAll();
            System.out.println(persons);
            //update(dao);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

     /**更新**/
    private void update(Dao<Person, Integer> dao) throws SQLException {
        //2.3.3.修改记录
        Person person = dao.queryForId(1);
        person.setAge(81);
        person.setName("白马1");
        //更新
        dao.update(person);
        List<Person> persons = dao.queryForAll();
        System.out.println(persons);
    }

    //2.3.2.调用查询所有方法
    private void testQuery(Dao<Person, Integer> dao) throws SQLException {
        //查询所有
        List<Person> persons = dao.queryForAll();
        //查询指定id的记录
        Person person = dao.queryForId(1);
        System.out.println(person) ;
    }

    private void testAdd() {
        //2.3.1.增加
        //创建javaBean
        Person person=new Person();
        person.setName("黑马1");
        person.setAge(18);
        try {
            //泛型1.操作javaBean 2.id的类型
            //获取dao
            Dao<Person, Integer> dao = new MyHelper(this).getDao(Person.class);
            //创建记录
            dao.create(person);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}