Android中的ORMLite的简单使用

前段时间学习了GreenDao,对比了下,ORMLite更加的简单一些.参考其他的博文 SQLite数据库框架ORMLite与GreenDao的简单比较 GreenDao和ORMLite使用的频率比较高,但是GreenDao的效率更加的高一些.

本篇文章就针对ORMLite的使用做一个简单点的介绍

1.从官网下载core库jar包,android上的jar包

下载成功后复制进libs文件夹,同步工程

2.创建一个java类,通过注解,将此java对象和数据库中的表格关联起来

@DatabaseTable(tableName = "user")
public class User {

    public User() {
    }

    public User(int id, String name, String age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @DatabaseField(generatedId = true)
    private int id;

    @DatabaseField(columnName = "name")
    private String name;

    @DatabaseField(columnName = "age")
    private String age;

    @DatabaseField(columnName = "address")
    private String address;


    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 getAge() {
        return age;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

1. @DatabaseTable(tableName = “user”) : 代表User类映射到数据库当中的user表(table)
2. DatabaseField()的”( )”中可以有以下的值
   @DatabaseField(generatedId = true) : 代表主键自动增长
   @DatabaseField(id= true) : 代表此字段是主键
   @DatabaseField(columnName = “name”) : 代表此字段对应于数据当中的name
   还有更多 : 请参考 ORMLite注解

3.创建一个DatabaseHelper类,继承自OrmLiteSqliteOpenHelper,用来管理数据库的创建和更新,还可以通过此类获取数据库的操作对象

public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
    private static final String DB_NAME = "ormtest.db";
    private static final int DB_VERSION = 1;

    private Dao<User, Integer> userDao;

    private DatabaseHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    private static volatile DatabaseHelper mInstance;

    /**
     * 单例模式,获取DatabaseHelper的唯一实例
     *
     * @param context
     * @return
     */
    public static DatabaseHelper getInstance(Context context) {
        if (mInstance == null) {
            synchronized (DatabaseHelper.class) {
                if (mInstance == null) {
                    mInstance = new DatabaseHelper(context);
                }
            }
        }

        return mInstance;
    }


    /**
     * 如果还没有这个数据库的时候就会创建数据库,同时创建表格
     *
     * @param sqLiteDatabase
     * @param connectionSource
     */
    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) {

        try {
            //创建表
            TableUtils.createTable(connectionSource, User.class);

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 升级数据库
     *
     * @param sqLiteDatabase
     * @param connectionSource
     * @param i
     * @param i1
     */
    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int i, int i1) {
        try {
            TableUtils.dropTable(connectionSource, User.class, true);
            onCreate(sqLiteDatabase, connectionSource);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放资源
     */
    @Override
    public void close() {
        super.close();
        userDao = null;
    }
}

4.在上面的DatabaseHelper创建完成以后,此时我们直接可以获取到XXDao的对象,就可以进行增(create)删(delete)改(update)查(query)了

 DatabaseHelper helper = DatabaseHelper.getInstance(this);
        try {
            Dao<User, Integer> dao = helper.getDao(User.class);
            dao.delete(new User());//删除一条数据

        } catch (SQLException e) {
            e.printStackTrace();
        }

但是这里建议真毒每一张table封装一个dao,这样一个dao只映射数据库当中的一张表格,例如这里封装了一个UserDao,里面包含了基本的增、删、改、查的方法:

public class UserDao {
    private DatabaseHelper mHelper;
    private Dao<User, Integer> mDao;

    private static volatile UserDao mUserDao;

    private UserDao(Context context) {
        if (mDao == null) {
            if (mHelper == null) {
                mHelper = DatabaseHelper.getInstance(context);
            }

            try {
                mDao = mHelper.getDao(User.class);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static UserDao getInstance(Context context) {
        if (mUserDao == null) {
            synchronized (UserDao.class) {
                if (mUserDao == null) {
                    mUserDao = new UserDao(context);
                }
            }
        }

        return mUserDao;
    }


    /**
     * Create a new row in the database from an object
     * 创建一条新的记录到数据库中
     *
     * @param user
     * @return 是否插入成功
     */
    public boolean insert(User user) {
        boolean flag = false;
        try {
            //插入或者更新的行数,单条插入成功就是1
            int i = mDao.create(user);
            flag = i == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return flag;
    }

    /**
     * 批量插入数据
     *
     * @param user
     * @return 是否插入成功
     */
    public boolean insertAll(List<User> user) {
        boolean flag = false;
        try {
            //插入或者更新的行数,单条插入成功就是1
            int i = mDao.create(user);
            flag = i == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return flag;
    }

    /**
     * 删除一条数据
     *
     * @param user
     * @return
     */
    public boolean delete(User user) {
        boolean flag = false;
        try {
            int rowCount = mDao.delete(user);
            flag = rowCount == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 批量删除
     *
     * @param users
     * @return
     */
    public boolean deleteAll(List<User> users) {
        boolean flag = false;
        try {
            int rowCount = mDao.delete(users);
            flag = rowCount == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 更新数据
     *
     * @param user
     * @return
     */
    public boolean update(User user) {
        boolean flag = false;
        try {
            int rowCount = mDao.update(user);
            flag = rowCount == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 批量更新
     *
     * @param users
     * @return
     */
    public boolean updateAll(List<User> users) {
        boolean flag = true;
        try {
            for (User user : users) {
                int rowCount = mDao.update(user);
                boolean b = rowCount == 1 ? true : false;
                if (!b) {
                    flag = false;
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return flag;
    }


    public void query() {
        QueryBuilder<User, Integer> builder = mDao.queryBuilder();
        Where<User, Integer> where = builder.where();
        try {
            //相当于:select * from user where name = '张三' and age > 20
            where.and(where.eq("name","张三"),where.ge("age",20));

            //下面这条语句相当于:select * from user where (name = '张三' and age > 20 ) or address = '陕西'
            where.and(where.eq("name","张三"),where.ge("age",20)).or().eq("address","陕西");
            List<User> users = where.query();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

}

请参考ORMLite官方参考文档
ORMLite官网
ORMLite官方doc文档