OrmLite的封装

    使用ormlite数据库时，我们通常对每一张表都会写一个Dao类，里面会定义CRUD等操作的方法，如果只有一两张表的话，这样做也不算麻烦，但是有多张表的话，就需要写很多个Dao类，就显得比较重复了。所以我们最好把CRUD方法写到一个类里，使用泛型，这样就可以根据传递过来的实体类获取Dao对象，调用各种数据库操作。为此，对OrmLite的使用做了一些封装。

    代码目录，

DatabaseHelper

    使用ormlite都要继承OrmLiteSqliteOpenHelper，在子类中实现onCreate、onUpgrade等方法，

1、onCreate(SQLiteDatabase database,ConnectionSource connectionSource)

    创建表，使用createTable(ConnectionSource connectionSource, Class<T> dataClass)创建

2、onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion)

    更新表，可以在表中添加一个字段，也可以删除表，使用dropTable(ConnectionSource connectionSource, Class<T> dataClass, boolean ignoreErrors)删除，删除完成后，如果该表还需要使用，那么还需要创建，创建操作：onCreate(database, connectionSource)

3、在构造方法中定义数据库名和版本号

    // Database Name
    private static String DB_NAME = "ormlite.db";
    // Database Version
    private static final int DB_VERSION = 1;
    public DatabaseHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    public DatabaseHelper(Context context, String databaseName, SQLiteDatabase.CursorFactory factory, int databaseVersion) {
        super(context, databaseName, factory, databaseVersion);
        // TODO Auto-generated constructor stub
    }

4、创建实例

    使用单例公布出一个创建实例的方法，用于获取helper实例

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

BaseDao

    一个抽象类，实现了常用的数据库操作方法。

getDao()，抽象方法，在BaseDao的实现类中实现，获取实体类的Dao。

    /**
     * 插入一条记录
     *
     * @param t
     */
    public void insert(T t) {
        try {
            Dao<T, Integer> dao = getDao();
            dao.create(t);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 插入一组记录，使用事务处理
     *
     * @param list
     */
    public void insertList(List<T> list) {
        if (list.size() <= 0) return;
        try {
            Dao<T, Integer> dao = getDao();
            DatabaseConnection databaseConnection = null;
            try {
                databaseConnection = dao.startThreadConnection();
                dao.setAutoCommit(databaseConnection, false);
                for (T t : list) {
                    dao.create(t);
//                    dao.createIfNotExists(t);
                }
                dao.commit(databaseConnection);
            } catch (SQLException e) {
                dao.rollBack(databaseConnection);
                e.printStackTrace();
            } finally {
                dao.endThreadConnection(databaseConnection);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    插入一组记录，采用事务处理(处理list一般都采用事务处理，这样在数据很大时可明显提高效率)。需要注意create和createIfNotExists的区别：后者是当记录不存在时创建，存在的话就跳过；前者当记录存在时也不创建，并且如果这一组记录中有一条存在了，那么这组记录也不会创建。所以使用的时候需要注意，不过可以使用 insertOrUpdate 来代替。

    /**
     * 插入或更新一组数据，使用事务处理
     *
     * @param list
     */
    public void insertOrUpdate(List<T> list) {
        if (list.size() <= 0) return;
        try {
            Dao<T, Integer> dao = getDao();
            DatabaseConnection databaseConnection = null;
            try {
                databaseConnection = dao.startThreadConnection();
                dao.setAutoCommit(databaseConnection, false);
                for (T t : list) {
                    dao.createOrUpdate(t);
                }
                dao.commit(databaseConnection);
            } catch (SQLException e) {
                dao.rollBack(databaseConnection);
                e.printStackTrace();
            } finally {
                dao.endThreadConnection(databaseConnection);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    删除和查询方法也都做了多个重载，可满足大多数情况，就不对每一个方法详述了。

BaseDaoImpl

    BaseDao的实现类，实现了getDao方法，

    @Override
    public Dao<T, Integer> getDao() throws SQLException {
        // TODO Auto-generated method stub
        Dao<T, Integer> dao = mDaoMap.get(clazz);
        if (null == dao) {
            dao = mDatabaseHelper.getDao(clazz);
            mDaoMap.put(clazz, dao);
        }
        return dao;
    }

    根据实体类获取Dao对象，放到HashMap中，避免重复获取。

Helper

    一个帮助类，主要用来获取实体类的Dao对象，如，

    private BaseDao<Student, Integer> mStudentDao;
    public BaseDao<Student, Integer> getStudentDao() {
        if (mStudentDao == null) {
            mStudentDao = new BaseDaoImpl<>(mContext, Student.class);
        }
        return mStudentDao;
    }

Utils

    工具类，定义了数据库文件拷贝到SD卡的方法。

实例简析

1、实体类Student.java，定义了表名和字段

@DatabaseTable(tableName = "table_student")
public class Student {

    @DatabaseField(id = true, uniqueCombo = true, columnName = "id")
    public int id;// 学号
    @DatabaseField(columnName = "name", canBeNull = false)
    public String name;// 姓名
    @DatabaseField(columnName = "profession")
    public String profession;// 专业

    public Student() {

    }

    public Student(int id, String name, String profession) {
        this.id = id;
        this.name = name;
        this.profession = profession;
    }

}

2、创建表

@Override
public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
// TODO Auto-generated method stub
try {
        TableUtils.createTable(connectionSource, Student.class);
    } catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
    }
}

@Override
public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
// TODO Auto-generated method stub
try {
        TableUtils.dropTable(connectionSource, Student.class, true);
        onCreate(database, connectionSource);
    } catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
    }
}

3、数据库操作

    private void add() {
        if (isEmpty(etId) || isEmpty(etName) || isEmpty(etProfession)) {
            Toast.makeText(this, "数据不能为空", Toast.LENGTH_SHORT).show();
            return;
        }
        int id = Integer.parseInt(etId.getText().toString());
        String name = etName.getText().toString();
        String profession = etProfession.getText().toString();
        Student student = new Student(id, name, profession);
        Helper.getInstance().getStudentDao().insert(student);
        updateListView();
    }

    private void delete() {
        if (isEmpty(etId)) {
            Toast.makeText(this, "id不能为空", Toast.LENGTH_SHORT).show();
            return;
        }
        int id = Integer.parseInt(etId.getText().toString());
        Helper.getInstance().getStudentDao().delete("id", id);
        updateListView();
    }

    private void update() {
        if (isEmpty(etId)) {
            Toast.makeText(this, "id不能为空", Toast.LENGTH_SHORT).show();
            return;
        }
        int id = Integer.parseInt(etId.getText().toString());
        String name = etName.getText().toString();
        String profession = etProfession.getText().toString();
        Student student = new Student(id, name, profession);
        Helper.getInstance().getStudentDao().update(student);
        updateListView();
    }

    private void query() {
        if (isEmpty(etId)) {
            Toast.makeText(this, "id不能为空", Toast.LENGTH_SHORT).show();
            return;
        }
        int id = Integer.parseInt(etId.getText().toString());
        Student student = Helper.getInstance().getStudentDao().query(new String[]{"id"}, new Object[]{id});
        mList.clear();
        mList.add(student);
        mAdapter.notifyDataSetChanged();
    }

    private void updateListView() {
        List<Student> list = Helper.getInstance().getStudentDao().queryAll();
        mList.clear();
        mList.addAll(list);
        mAdapter.notifyDataSetChanged();
    }

    private boolean isEmpty(EditText et) {
        if (et == null || et.getText() == null || "".equals(et.getText().toString())) {
            return true;
        }
        return false;
    }

    对数据库操作仅需一行代码就行了。

源码地址