android 连接mysql orm_手把手带你撸一套Android简易ORM框架

ORM概念

对象关系映射(Object Relational Mapping)，通俗来讲就是建立关系型数据库与业务实体对象之间作一个映射关系。对于Java后端来说，例如mybatis、hibernate等，在Android平台下，常见的数据库映射框架有 GreenDAO、Realm等。废话不多说，进入正题！

实体模型建立

既然是映射，自然需要对数据库表的字段结构与实体类之间建立一个连接关系。我们采用注解，来通过实体类生成一个表的结构。

注解列

ID

通过 @Id 注解来标识表的ID字段。@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)public @interface Id {}

主键

通过 @Unique 注解来标识一个主键。@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)public @interface Unique {}

自增长

通过 @AutoIncrement 注解来标识一个自增长的键。@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)public @interface AutoIncrement {}

数据表的列

通过 @Column 注解来标识数据表的一个列，默认不能为null，可通过 nullable 属性修改。@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)public @interface Column {

boolean nullable() default false;

}

实体基类

首先，每一个表都有一个唯一的id，所以我们建立的基类里，包含了这个自增长的id。public abstract class BaseEntity {

@Id

@AutoIncrement

private Integer id; // 通过 @Id 与 @AutoIncrement 注解标识为自增长id

public BaseEntity() {

}    public Integer getId() {        return id;

}    public void setId(Integer id) throws DBException {        if (id 

}        this.id = id;

}

}

每一个继承实体基类的实体类，都必须生成他的 get 和 set 方法，对于 boolean 来说，为了便于存储与操作，我们在数据库应当把它转换为 1 和 0 的模式。例如：public class BookConfig extends BaseEntity {

@Column

protected String book_num;    @Column

protected String setting_key;    @Column(nullable = true)    protected String setting_value = "";    @Column

protected int status;    @Column(nullable = true)    protected int isModify = 1;    public BookConfig() {

}    public BookConfig(String book_num, String setting_key) {        this.book_num = book_num;        this.setting_key = setting_key;

}    public String getBook_num() {        return book_num;

}    public void setBook_num(String book_num) {        this.book_num = book_num;

}    public String getSetting_key() {        return setting_key;

}    public void setSetting_key(String setting_key) {        this.setting_key = setting_key;

}    public String getSetting_value() {        return setting_value;

}    public void setSetting_value(String setting_value) {        this.setting_value = setting_value;

}    public int getStatus() {        return status;

}    public void setStatus(int status) {        this.status = status;

}    public int getIsModify() {        return isModify;

}    public void setIsModify(int isModify) {        this.isModify = isModify;

}

}

这样，就创建了一个实体类了。为什么要去生成他的 get 和set 方法呢？这是因为我们需要通过反射来取出每一个字段，然后通过 get 和set 方法去设置字段的值。后面还会提到！

实体类映射成表结构

有个实体类之后，我们就需要把这个实体类转换成一个数据表，通过 @Column 注解去寻找实体类的每一个字段，然后拼接生成对应的SQL语句。/**

* 生成建表的SQL语句

*

* @param clazz        实体类

* @param strTableName 表名字

* @return

*/

public static String genCreateTableSQL(Class clazz, String strTableName) {     boolean isHaveKeyId = false;     boolean isHaveColumnAnnotation = false;

String strIdName = null;     // 反射获取实体类的所有字段

Field[] fields = Utils.getDeclaredField(clazz);     if (fields.length <= 0)         return null;

StringBuilder sb = new StringBuilder("CREATE TABLE IF NOT EXISTS " + strTableName + " ( ");

StringBuilder sbUnique = new StringBuilder("");     for (Field field : fields) {

// 添加 自增长id

if (field.isAnnotationPresent(Id.class)) {             // 一个表只能有一个id

if (isHaveKeyId)                 continue;

isHaveColumnAnnotation = true;

Id id = field.getAnnotation(Id.class);

strIdName = getColumnName(field);

sb.append(strIdName);

sb.append(" ");             // type

sb.append(fieldType2DBType(field.getGenericType().toString()));

sb.append(" ");             // primary key

sb.append("NOT NULL PRIMARY KEY ");             // is auto-increment

if (field.isAnnotationPresent(AutoIncrement.class)

&& (field.getGenericType().toString().equals("class java.lang.Integer") || field

.getGenericType().toString().equals("int"))) {

sb.append("AUTOINCREMENT");

}

sb.append(",");

isHaveKeyId = true;

} else if (field.isAnnotationPresent(Column.class)) {

// 添加其他列

Column col = field.getAnnotation(Column.class);

String strColName = getColumnName(field);

sb.append(strColName);

sb.append(" ");             // 数据类型

sb.append(fieldType2DBType(field.getGenericType().toString()));             // 是否可以为空

boolean canBeNull = col.nullable();             if (!canBeNull) {

sb.append(" NOT NULL");

}

sb.append(",");             // is unique

if (field.isAnnotationPresent(Unique.class)) {

sbUnique.append("CONSTRAINT \"u" + strColName.toLowerCase() + "\" UNIQUE (\"" + strColName + "\"),");

}

isHaveColumnAnnotation = true;

}

}     // nothing

if (!isHaveColumnAnnotation && !isHaveKeyId)         return null;     // unique

sb.append("CONSTRAINT \"u" + strIdName.toLowerCase() + "\" UNIQUE (\"" + strIdName + "\")");     if (sbUnique.length() > 0) {

sb.append(",");

sb.append(sbUnique.deleteCharAt(sbUnique.length() - 1));

}     // end

sb.append(" )");     return sb.toString();

}/**

* Java属性类型转换为数据库数据类型

*

* @param fieldGenericTyp

* @return

*/private static String fieldType2DBType(String fieldGenericTyp) {    if (fieldGenericTyp.equals("class java.lang.String")) {        return "VARCHAR";

} else if (fieldGenericTyp.equals("class java.lang.Boolean") || fieldGenericTyp.equals("boolean")

|| fieldGenericTyp.equals("class java.lang.Integer") || fieldGenericTyp.equals("int")

|| fieldGenericTyp.equals("class java.lang.Long") || fieldGenericTyp.equals("long")

|| fieldGenericTyp.equals("class java.lang.Short") || fieldGenericTyp.equals("short")

|| fieldGenericTyp.equals("class java.lang.Byte") || fieldGenericTyp.equals("byte")) {        return "INTEGER";

} else if (fieldGenericTyp.equals("class [B")) {        return "BLOB";

} else if (fieldGenericTyp.equals("class java.lang.Float") || fieldGenericTyp.equals("float")) {        return "float";

} else if (fieldGenericTyp.equals("class java.lang.Double") || fieldGenericTyp.equals("double")) {        return "double";

}    return null;

}

这样的话，我们只要调用以下代码，就可以生成SQL语句。例如：String sql = ORMUtils.genCreateTableSQL(BookConfig.class, "book_config");

数据库操作封装

表创建完之后，我们就需要封装一些基本数据库操作的方法，也就是增删改查。 首先，建立一个操作方法接口：public interface IDAO {

/**

* get the sqlite database object

*

* @return

*/

SQLiteDatabase getDatabase();    /**

* init table name and entityClass

*

* @param tableName

* @param clazz

*/

void initTable(String tableName, Class clazz);    /**

* get count of entities

*

* @return

* @throws DBException

*/

long getCount() throws DBException;    boolean isTableExist(String tableName) throws DBException;    /**

* check table exists

*

* @return

* @throws DBException

*/

boolean isTableExist() throws DBException;    /**

* create table

*

* @throws DBException

*/

void createTable() throws DBException;    /**

* create table

*

* @param tableName table name

* @throws DBException

*/

 void createTable(Class entityClass, String tableName) throws DBException;    /**

* drop table

*

* @throws DBException

*/

void dropTable() throws DBException;    /**

* drop all table

*

* @throws DBException

*/

void dropAllTable() throws DBException;    /**

* save database entity

*

* @param entity

* @throws DBException

*/

void save(T entity) throws DBException;    /**

* delete database entity by id(primary key)

*

* @param id

* @throws DBException

*/

void delete(int id) throws DBException;    /**

* delete database entity by ids(primary key)

*

* @param ids

* @throws DBException

*/

void delete(int[] ids) throws DBException;    /**

* delete all data

*

* @throws DBException

*/

void deleteAll() throws DBException;    /**

* update entity

*

* @param entity

* @throws DBException

*/

void update(T entity) throws DBException;    /**

* update entity by a condition string

*

* @param condition part of the update SQL command after keyword 'WHERE'

*                  (i.e."UPDATE Person SET age = 35 WHERE condition")

*                  (e.g. condition -- "name = 'Richard' OR name = 'Jefferson'")

* @param entity

* @throws DBException

*/

void updateByCondition(String condition, T entity) throws DBException;    /**

* find entity by id

*

* @param id

* @return

* @throws DBException

*/

T find(int id) throws DBException;    /**

* find last entity

*

* @return

* @throws DBException

*/

T findLastEntity() throws DBException;    /**

* find entities by a condition string

*

* @param condition part of the select SQL command after keyword 'WHERE'

*                  (i.e."SELECT * FROM Person WHERE condition")

*                  (e.g. condition -- "name = 'Richard' OR name = 'Jefferson'")

* @return

*/

List findByCondition(String condition) throws DBException;    /**

* find all entities

*

* @return

* @throws DBException

*/

List findAll() throws DBException;

}

接口主要封装了一些比较常用的增删改查方法，当然了，特别复杂的操作，还是需要配合SQL语句来进行执行，但是这样已经可以满足一些常用的基本操作了。

接着我们需要来具体实现这一系列方法：public class DAO extends SQLiteOpenHelper implements IDAO {

private Context mContext;    private String mDBName;    private String mTableName;    private int mVersion;    private SQLiteDatabase db;    private Field[] fields;    private Class entityClass;    public DBUpdateInfo info = new DBUpdateInfo();    /**

* constructor. only for operate the database and cannot operate the specified table.

*

* @param context to use to open or create the database

* @param dbName  of the database name, it will be stored in /data/data/%package_name%/files

* @param version number of the database (starting at 1)

*/

public DAO(Context context, String dbName, int version) {        this(context, dbName, null, null, version);

}    /**

* constructor

*

* @param context     to use to open or create the database

* @param dbName      of the database name, it will be stored in /data/data/%package_name%/files

* @param tableName   the name of table to needs to be operated

* @param entityClass class for entity

* @param version     number of the database (starting at 1)

*/

public DAO(Context context, String dbName, String tableName, Class entityClass, int version) {        super(context, dbName, null, version);        this.mContext = context;        this.mDBName = dbName;        this.mTableName = tableName;        this.mVersion = version;        this.db = getWritableDatabase();        this.fields = Utils.getDeclaredField(entityClass);        this.entityClass = entityClass;

}    @Override

public void onCreate(SQLiteDatabase db) {

}    @Override

public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

info.isUpdate = true;

info.from = oldVersion;

info.to = newVersion;

}    @Override

public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {

info.isUpdate = true;

info.from = oldVersion;

info.to = newVersion;

}    @Override

public void initTable(String tableName, Class clazz) {        this.mTableName = tableName;        this.entityClass = clazz;        this.fields = Utils.getDeclaredField(entityClass);

}    @Override

public SQLiteDatabase getDatabase() {        return db == null ? (db = getWritableDatabase()) : db;

}    @Override

public long getCount() throws DBException {        if (TextUtils.isEmpty(mTableName))            return 0;        try {

openDB(true);

String sql = "SELECT COUNT(*) FROM " + mTableName;

LogUtils.d(sql);

Cursor cursor = db.rawQuery(sql, null);

cursor.moveToFirst();            long total = cursor.getLong(0);            return total;

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_GET_COUNT);

} finally {

closeDB();

}

}    @Override

public boolean isTableExist(String tableName) throws DBException {        boolean isExist = false;        if (TextUtils.isEmpty(tableName))            return isExist;        try {

openDB(false);

String sql = "SELECT COUNT(*) FROM Sqlite_master WHERE TYPE ='table' AND NAME ='" + tableName.trim() + "' ";

LogUtils.d(sql);

Cursor cursor = db.rawQuery(sql, null);            if (cursor.moveToNext()) {                int count = cursor.getInt(0);                if (count > 0) {

isExist = true;

}

}            return isExist;

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_IS_TABLE_EXISTS);

} finally {

closeDB();

}

}    @Override

public boolean isTableExist() throws DBException {        return !TextUtils.isEmpty(mTableName) && isTableExist(mTableName);

}    @Override

public void createTable() throws DBException {

createTable(entityClass, mTableName);

}    @Override

public  void createTable(Class entityClass, String tableName) throws DBException {        try {

openDB(true);

String sql = ORMUtils.genCreateTableSQL(entityClass, tableName);

LogUtils.i(sql);

db.execSQL(sql);

} catch (Exception e) {

e.printStackTrace();            throw new DBException(ErrMsg.ERR_CREATE_TABLE, e);

} finally {

closeDB();

}

}    @Override

public void dropTable() throws DBException {        try {

openDB(true);

String sql = "DROP TABLE " + mTableName;

LogUtils.d(sql);

db.beginTransaction();

db.execSQL(sql);

db.setTransactionSuccessful();

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_DROP_TABLE, e);

} finally {

db.endTransaction();

closeDB();

}

}    @Override

public void dropAllTable() throws DBException {

String strTabSql = "select name from sqlite_master where type='table' order by name";

LogUtils.d("dropAllTable:" + strTabSql);        try {

openDB(false);

db.beginTransaction();

Cursor cursor = db.rawQuery(strTabSql, null);            while (cursor.moveToNext()) {

String name = cursor.getString(0);                if (name.equals("sqlite_sequence")) {                    continue;

}

String sql = "DROP TABLE " + name;

LogUtils.d(sql);

db.execSQL(sql);

}

db.setTransactionSuccessful();

} catch (Exception e) {

e.printStackTrace();            throw new DBException(ErrMsg.ERR_DROP_TABLE, e);

} finally {

db.endTransaction();

closeDB();

}

}    @Override

public void save(T entity) throws DBException {

ContentValues values;        try {

openDB(true);

values = Utils.putValue(fields, entity);            if (values == null || values.size() <= 0) {                throw new DBException(ErrMsg.ERR_SAVE_PARAM);

}            long flag = db.insert(mTableName, null, values);            if (flag 

}

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_SAVE_PARAM, e);

} finally {

closeDB();

}

}    @Override

public void delete(int id) throws DBException {

delete(new int[]{id});

}    @Override

public void delete(int[] ids) throws DBException {        int length = ids == null ? 0 : ids.length;        if (length <= 0) {            throw new DBException(ErrMsg.ERR_DEL_PARAM);

}

Field pkField = ORMUtils.getPKField(fields);        if (pkField == null) {            throw new DBException(ErrMsg.ERR_GET_PRIMARY_KEY);

}

Class pkType = pkField.getType();

String columnName = ORMUtils.getColumnName(pkField);        try {

openDB(true);

StringBuilder sbSql = new StringBuilder("DELETE FROM " + mTableName + " WHERE " + columnName);            if (ids.length == 1) {

sbSql.append(" = ");

} else {

sbSql.append(" in (");

}

String strSep = "";            if (pkType == String.class) {

strSep = "'";

}

StringBuilder strEntityIds = new StringBuilder("");            for (Serializable id : ids) {

strEntityIds.append(strSep);

strEntityIds.append(id);

strEntityIds.append(strSep);

strEntityIds.append(",");

}

strEntityIds.deleteCharAt(strEntityIds.length() - 1);

sbSql.append(strEntityIds.toString());            if (ids.length > 1) {

sbSql.append(")");

}

LogUtils.d(sbSql.toString());

db.execSQL(sbSql.toString());

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_DEL, e);

} finally {

closeDB();

}

}    @Override

public void deleteAll() throws DBException {        try {

openDB(true);

String delSql = "DELETE FROM " + mTableName;

String revSeqSql = "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + mTableName + "'";

db.beginTransaction();

db.execSQL(delSql);

db.execSQL(revSeqSql);

db.setTransactionSuccessful();

LogUtils.d(delSql);

LogUtils.d(revSeqSql);

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_DEL, e);

} finally {

db.endTransaction();

closeDB();

}

}    @Override

public void update(T entity) throws DBException {        if (entity == null) {            throw new DBException(ErrMsg.ERR_UPDATE_PARAM);

}

Field pkField = ORMUtils.getPKField(fields);        if (pkField == null) {            throw new DBException(ErrMsg.ERR_GET_PRIMARY_KEY);

}

Object pkValue = Utils.getPropValue(entity, pkField, entityClass);        if (pkValue == null) {            throw new DBException(ErrMsg.ERR_GET_PRIMARY_KEY_VALUE);

}

ContentValues values;        try {

openDB(true);

values = Utils.putValue(fields, entity);            if (values.size() <= 0) {                throw new DBException(ErrMsg.ERR_UPDATE_PARAM);

}            int flag = db.update(mTableName, values, pkField.getName() + "=?",                    new String[]{String.valueOf(pkValue)});            if (flag 

}

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_UPDATE, e);

} finally {

closeDB();

}

}    @Override

public void updateByCondition(String condition, T entity) throws DBException {        if (entity == null) {            throw new DBException(ErrMsg.ERR_UPDATE_PARAM);

}

ContentValues values;        try {

openDB(true);

values = Utils.putValue(fields, entity);

values.remove("id");            if (values.size() <= 0) {                throw new DBException(ErrMsg.ERR_UPDATE_PARAM);

}            int flag = db.update(mTableName, values, condition, null);            if (flag 

}

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_UPDATE, e);

} finally {

closeDB();

}

}    @Override

public T find(int id) throws DBException {

Field pkField = ORMUtils.getPKField(fields);        if (pkField == null) {            throw new DBException(ErrMsg.ERR_GET_PRIMARY_KEY);

}

String columnName = ORMUtils.getColumnName(pkField);        try {

openDB(true);

String sql = "SELECT * FROM " + mTableName + " WHERE " + columnName + "=?";

LogUtils.d(sql);

Cursor cursor = db.rawQuery(sql, new String[]{id + ""});

List objList = Utils.cursor2Entity(entityClass, cursor);            if (objList != null && objList.size() > 0) {                return objList.get(0);

}

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_FIND, e);

} finally {

closeDB();

}        return null;

}    @Override

public T findLastEntity() throws DBException {

Field pkField = ORMUtils.getPKField(fields);        if (pkField == null) {            throw new DBException(ErrMsg.ERR_GET_PRIMARY_KEY);

}

String columnName = ORMUtils.getColumnName(pkField);        try {

openDB(true);

String sql = "SELECT * FROM " + mTableName + " ORDER BY " + columnName + " desc LIMIT 1";

LogUtils.d(sql);

Cursor cursor = db.rawQuery(sql, new String[]{});

List objList = Utils.cursor2Entity(entityClass, cursor);            if (objList != null && objList.size() > 0) {                return objList.get(0);

}

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_FIND, e);

} finally {

closeDB();

}        return null;

}    @Override

public List findByCondition(String condition) throws DBException {        if (TextUtils.isEmpty(condition)) {            throw new DBException(null);

}        try {

openDB(true);

String sql = "SELECT * FROM " + mTableName + " WHERE " + condition;

LogUtils.d(sql);

Cursor cursor = db.rawQuery(sql, new String[]{});

List objList = Utils.cursor2Entity(entityClass, cursor);            if (objList != null && objList.size() > 0) {                return objList;

}

} catch (Exception e) {            throw new DBException(null);

} finally {

closeDB();

}        return null;

}    @Override

public List findAll() throws DBException {        try {

openDB(true);

String sql = "SELECT * FROM " + mTableName;

LogUtils.d(sql);

Cursor cursor = db.rawQuery(sql, new String[]{});

List objList = Utils.cursor2Entity(entityClass, cursor);            if (objList != null && objList.size() > 0) {                return objList;

}

} catch (Exception e) {            throw new DBException(ErrMsg.ERR_FIND, e);

} finally {

closeDB();

}        return null;

}    /**

* Create and/or open a database that will be used for reading and writing.

*

* @param checkTable True if need check mTableName, false otherwise

* @throws DBException

*/

private void openDB(boolean checkTable) throws DBException {        if (checkTable && TextUtils.isEmpty(mTableName)) {            throw new DBException(ErrMsg.ERR_IS_TABLE_EXISTS);

}

db = getWritableDatabase();

}    /**

* Releases a reference to the database

* closing the database if the last reference was released.

*/

private void closeDB() {        if (db != null && db.isOpen()) {

db.close();

}

}    /**

* database version update information

*/

public class DBUpdateInfo {

public boolean isUpdate = false;        public int from;        public int to;

}

}

那么，数据库查询出来的行，如何转换为实体呢？ 就是通过实体类的 set 方法去赋值。/**

* 数据库查询->实体对象

*/public static  List cursor2Entity(Class clazz, Cursor cursor) throws DBException {

List objList = new ArrayList<>();

Field[] fields = getDeclaredField(clazz);    try {        if (cursor.moveToFirst()) {            while (!cursor.isAfterLast()) {

T obj = clazz.newInstance();                for (int i = 0; i 

String strColName = cursor.getColumnName(i);                    for (Field field : fields) {                        if (field.getName().equals(strColName)) {

strColName = toUpperCaseFirstOne(strColName);                            if (cursor.getType(i) == Cursor.FIELD_TYPE_NULL) {                                continue;

} else if (cursor.getType(i) == Cursor.FIELD_TYPE_FLOAT) {

clazz.getMethod("set" + strColName, field.getType()).invoke(obj,

cursor.getFloat(i));

} else if (cursor.getType(i) == Cursor.FIELD_TYPE_INTEGER) {                                if (field.getGenericType().toString().equals("class java.lang.Boolean")

|| field.getGenericType().toString().equals("boolean")) {                                    // e.g. boolean isOk; public boolean isOk(){ return isOk; }   public void setOk(){}

clazz.getMethod("set" + strColName.replaceFirst("Is", ""), field.getType()).invoke(obj,

cursor.getInt(i) == 1 ? true : false);

} else if (field.getGenericType().toString().equals("class java.lang.Integer")

|| field.getGenericType().toString().equals("int")) {

clazz.getMethod("set" + strColName, field.getType()).invoke(obj,

cursor.getInt(i));

} else if (field.getGenericType().toString().equals("class java.lang.Long")

|| field.getGenericType().toString().equals("long")) {

clazz.getMethod("set" + strColName, field.getType()).invoke(obj,

(long) cursor.getInt(i));

} else if (field.getGenericType().toString().equals("class java.lang.Short")

|| field.getGenericType().toString().equals("short")) {

clazz.getMethod("set" + strColName, field.getType()).invoke(obj,

(short) cursor.getInt(i));

} else if (field.getGenericType().toString().equals("class java.lang.Byte")

|| field.getGenericType().toString().equals("byte")) {

clazz.getMethod("set" + strColName, field.getType()).invoke(obj,

(byte) cursor.getInt(i));

}

} else if (cursor.getType(i) == Cursor.FIELD_TYPE_STRING) {

clazz.getMethod("set" + strColName, field.getType()).invoke(obj,

cursor.getString(i));

} else if (cursor.getType(i) == Cursor.FIELD_TYPE_BLOB) {

clazz.getMethod("set" + strColName, field.getType()).invoke(obj,

cursor.getBlob(i));

} else {                                throw new DBException(null);

}                            break;

}

}

}

objList.add(obj);

cursor.moveToNext();

}            return objList;

}

} catch (Exception e) {

e.printStackTrace();        throw new DBException(null);

}    return objList;

}

相反的，更新保存数据的时候，我们需要从实体对象取值。public static  ContentValues putValue(Field[] fields, T entity) throws DBException {

ContentValues values = new ContentValues();    for (Field field : fields) {        if (!field.isAccessible())

field.setAccessible(true);

String strColName = ORMUtils.getColumnName(field);        if (strColName == null)            continue;        try {            if (field.getGenericType().toString().equals("class java.lang.String")) {

values.put(strColName, (String) (field.get(entity)));

} else if (field.getGenericType().toString().equals("class java.lang.Boolean")

|| field.getGenericType().toString().equals("boolean")) {

values.put(strColName, (((Boolean) (field.get(entity))) ? 1 : 0));

} else if (field.getGenericType().toString().equals("class java.lang.Byte")

|| field.getGenericType().toString().equals("byte")) {

values.put(strColName, (Byte) field.get(entity));

} else if (field.getGenericType().toString().equals("class [B")) {

values.put(strColName, (byte[]) field.get(entity));

} else if (field.getGenericType().toString().equals("class java.lang.Double")

|| field.getGenericType().toString().equals("double")) {

values.put(strColName, (Double) field.get(entity));

} else if (field.getGenericType().toString().equals("class java.lang.Float")

|| field.getGenericType().toString().equals("float")) {

values.put(strColName, (Float) field.get(entity));

} else if (field.getGenericType().toString().equals("class java.lang.Integer")

|| field.getGenericType().toString().equals("int")) {

values.put(strColName, (Integer) field.get(entity));

} else if (field.getGenericType().toString().equals("class java.lang.Long")

|| field.getGenericType().toString().equals("long")) {

values.put(strColName, (Long) field.get(entity));

} else if (field.getGenericType().toString().equals("class java.lang.Short")

|| field.getGenericType().toString().equals("short")) {

values.put(strColName, (Short) field.get(entity));

} else {                throw new DBException(null);

}

} catch (IllegalAccessException e) {

e.printStackTrace();            throw new DBException(null);

}

}    return values;

}

到这一步，映射关系就基本结束了。 我们可以通过以下方式调用：DAO dao = new DAO<>(mContext, getDatabaseFullName(dbName), tableName, clazz, dbVer);if (!TextUtils.isEmpty(tableName) && !dao.isTableExist()) {    // 如果表不存在，则创建！

dao.createTable();

}

dao.findAll(); // 查询所有dao.findLastEntity(); // 查询最后一条数据// ...

数据库升级

细心的童鞋会发现，DBUpdateInfo 这个类，就是用来表示数据库版本是否发生了变化，所以我们可以通过监听的方式，去判断数据库版本是否升级。if (dao.info.isUpdate) {

dao.info.isUpdate = false;     if (listener != null) {

listener.onUpdate(dao, dao.info.from, dao.info.to);

}

}

到此，封装就基本结束了。