Android上ORMLite的配置和简单使用

ORMLite和GreenDao是Android上最流行的ORM(对象关系映射)框架

现在来简单梳理下ORMLite在Android上的简单使用

1.在官网下载jar包,将这两个jar包放在libs目录下,然后同步工程(也就是将这两个jar包添加进library)

2.创建一个java类(User.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(id = 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的表

2. @DatabaseField() : 代表此字段是数据库当中的一个列名
   例如:
   @DatabaseField(id = true)
   private int id; 代表id是此表的主键

   @DatabaseField(columnName = “name”)
   private String name; 代表name对应于user表中的name字段

   更多@DatabaseField()括号中的注解请参考 :　ORMLite注解小计

3.新建一个继承自OrmLiteSqliteOpenHelper的类DatabaseHelper,主要用于创建、更新数据库，也可以用来获取数据库操作对象dao

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获取dao对象,用来操作数据库(增删改查)

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

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

上面只罗列了删除(delete),还有增(create)、改（update）、查（query）的方法

（建议）自己封装一个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;
    }


    /**
     * 使用QueryBuilder查询
     */
    public List<User> 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();
            return users;
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return null;
    }

}

基本的使用就介绍到此,如果希望更加深入的了解,建议移步 官网