ORMLite的使用

最新推荐文章于 2024-05-08 10:21:13 发布

原创最新推荐文章于 2024-05-08 10:21:13 发布 · 526 阅读

CC 4.0 BY-SA版权

android本身提供数据库操作的相关类，如android.database.sqlite.SQLiteOpenHelper。
但是需要自己来管理数据库、表的创建，自己写SQL语句来操作数据库，对于没有相关经验的android程序员来说，写SQL就有点小恶梦了……
所以android端的ORM框架也应运而生，正好在项目中用到相关的ORM框架，一起来学习一下（如果之前接触过hibernate的话做这个就忒简单了）。

参考： http://ormlite.com/

把一个“大象”装进数据库，总共分如下四步：

一、建立和数据库表相对应的实体类，并注意以下几点：
（1）在类前面用注解的方式声明表名： @DatabaseTable(tableName = "rkjbxx")

（2）在类的属性前面用注解的方式声明数据库表的字段名称：@DatabaseField(columnName = "GMSFHM")，

主键声明：generatedId = true，

如果需要把自定义的字段指定为主键的话需要声明：id=true,如：@DatabaseField(columnName = "ID",id = true)

（3）每一个属性需要提供get/set方法。

注：这里的属性命名都是大写的字母，为了和远程调用接口的结构相对应。

@DatabaseTable(tableName = "rkjbxx")
public class RkJbxxBean implements KvmSerializable {

	@DatabaseField(generatedId = true)
	public int id;

	/**
	 * 身份证号码
	 */
	@DatabaseField(columnName = "GMSFHM")
	public String GMSFHM;

	/**
	 * 姓名
	 */
	@DatabaseField(columnName = "XM")
	public String XM;


	/**
	 * @return id
	 */
	public int getId() {
		return id;
	}

	/**
	 * @param id 
	 */
	public void setId(int id) {
		this.id = id;
	}

	/**
	 * @return gMSFHM
	 */
	public String getGMSFHM() {
		return GMSFHM;
	}

	/**
	 * @param gMSFHM
	 */
	public void setGMSFHM(String gMSFHM) {
		GMSFHM = gMSFHM;
	}

	/**
	 * @return xM
	 */
	public String getXM() {
		return XM;
	}

	/**
	 * @param xM
	 */
	public void setXM(String xM) {
		XM = xM;
	}
}

二、建一个DatabaseHelper类，继承OrmLiteSqliteOpenHelper，其实OrmLiteSqliteOpenHelper继承android.database.sqlite.SQLiteOpenHelper
可以推断出OrmLiteSqlite其实也是对android原生DB操作的一个封装。
DatabaseHelper类的实现，基本上就是以下4步，几乎是不用变。

1、在构造方法中创建数据库文件

	private DatabaseHelper(Context context) {
		super(context, ROOT_PATH + TABLE_NAME, null, 1);
	}

2、在onCreate方法中创建数据库表

	@Override
	public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
		try {
			TableUtils.createTable(connectionSource, DictTable.class); // 创建数据字典表
			TableUtils.createTable(connectionSource, RkJbxxBean.class); // 创建人口基本信息表
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}</span>

3、在onUpgrade方法中先删除表，在创建新表

@Override
	public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int arg2, int arg3) {
		try {
			TableUtils.dropTable(connectionSource, DictTable.class, true);
			TableUtils.dropTable(connectionSource, RkJbxxBean.class, true);
			onCreate(database, connectionSource);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

4、根据实体类名去获得相应的Dao对象，并把该对象缓存起来（实体类对应数据库的一个表，Dao对象就是对该表的操作对象）

public synchronized Dao getDao(Class clazz) throws SQLException {
		Dao dao = null;
		String className = clazz.getSimpleName();

		if (daos.containsKey(className)) {  // 具有缓存功能
			dao = daos.get(className);
		}
		if (dao == null) {
			dao = super.getDao(clazz);
			daos.put(className, dao);
		}
		return dao;
	}</span>

三、建立对各个数据表操作的封装类（用二中的4获得的Dao对象进行操作）

public class RkjbxxDao {
    private final static String TAG = RkjbxxDao.class.getSimpleName();
    private Dao<RkJbxxBean, Integer> rkjbxxDao;  
    private DatabaseHelper helper;  
  
    public RkjbxxDao(Context context) {  
         try {  
            helper = DatabaseHelper.getHelper(context);   // 获得DatabaseHelper
            rkjbxxDao = helper.getDao(RkJbxxBean.class);  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }  
    }  

    /**
     * 
     * @Title: add 
     * @Description: 增加一条记录
     * @param rkJbxx
     * @return
     * @throws
     */
    public int add(RkJbxxBean rkJbxx) {
    	Log.d(TAG, "add() start");
    	int id = -1;
    	try {  
    		RkJbxxBean rkJbxx_new = rkjbxxDao.createIfNotExists(rkJbxx);
    		id = rkJbxx_new.getId();
    		Log.d(TAG, "add() success id = " + id);
        } catch (SQLException e) {  
            e.printStackTrace();  
        }
    	Log.d(TAG, "add() end");
    	return id;
    }
    
    /**
     * 
     * @Title: update 
     * @Description: 更新一条记录
     * @param rkJbxx
     * @throws
     */
    public void update(RkJbxxBean rkJbxx){
    	Log.d(TAG, "update() start");
    	try {
    		rkjbxxDao.update(rkJbxx);
		} catch (SQLException e) {
			e.printStackTrace();
		}
    	Log.d(TAG, "update() end");
    }
}</span>

四、把数据存到数据库

RkjbxxDao rkjbxxDao = new RkjbxxDao(this);
RkJbxxBean bean = new RkJbxxBean();
bean.setGMSFHM("1234567");
bean.setXM("abc")
int id = rkjbxxDao.add(bean); // 保存
bean.setXM("abcdef")
rkjbxxDao.update(bean);   // 更新</span>

//===============补充（20161122）==============

打开指定的（既有的）数据库

//============================================

private DBHelper(Context context) {
File file = new File(DB_DIR + DB_NAME);


if (file.exists()) {
SQLiteDatabase db = SQLiteDatabase.openDatabase(file.getPath(), null,SQLiteDatabase.OPEN_READWRITE);
connectionSource = new AndroidConnectionSource(db);
}
}


/**
* 获取dao
* 
* @param clazz
* @return
* @throws SQLException
*/
public <D extends Dao<T, ?>, T> D getDao(Class<T> clazz) throws Exception {
if (connectionSource != null) {
return DaoManager.createDao(connectionSource, clazz);
}
return null;
}

// ====================补充（20161128）=======================

执行自定义的sql语句，并解析结果

//==========================================================

try {
	GenericRawResults<String[]>  results = dao.queryRaw(sb.toString(), new RawRowMapper() {
		@Override
		public TaskInfoModel mapRow(String[] columnNames, String[] resultColumns) throws SQLException {
			List columns = Arrays.asList(columnNames);
			TaskInfoModel task = new TaskInfoModel();
			task.setCollectTime(resultColumns[columns.indexOf("CollectTime")]);
			task.setCompareState(Integer.valueOf(resultColumns[columns.indexOf("CompareState")]));
			task.setId(resultColumns[columns.indexOf("ID")]);
			task.setLocalCompareID(resultColumns[columns.indexOf("LocalCompareID")]);
			task.setNetCompareID(resultColumns[columns.indexOf("NetCompareID")]);
			task.setTableSouce(resultColumns[columns.indexOf("TableSouce")]);
			task.setTaskID(resultColumns[columns.indexOf("TaskID")]);
			task.setUpdateTime(resultColumns[columns.indexOf("UpdateTime")]);
			task.setUserName(resultColumns[columns.indexOf("UserName")]);
			return task;
		}
	});

	Iterator iterator = results.iterator();
	while (iterator.hasNext()) {
		TaskInfoModel task = (TaskInfoModel) iterator.next();
		tasks.add(task);
	}
} catch (SQLException e) {
	SysUtilManager.saveCrashInfo2File(e);
}

// ====================补充（20161221）=======================
关于一些where条件的使用
//==========================================================

	/**
	 *  
	 * @param whenStart     核验开始时间
	 * @param whenStop      核验结束时间
	 * @param columnName    列名
	 * @param columnValue   列值
	 * @return
	 */
	public ArrayList<SingleComparisionModel> queryByConditions_new(String whenStart,String whenStop,String columnName,String columnValue){

		ArrayList<SingleComparisionModel> models = null;
		try {
			Where<SingleComparisionModel, Integer> where = dao.queryBuilder().where();
			where.ne("ID", "");   // ID为主键，这个条件永真。用于连接后续的"and"
			if(!TextUtils.isEmpty(whenStart)){
				Date start = StringUtil.transformString(whenStart,StringUtil.DATE_FORMATTER_FOUR);
				where.and().ge("CollectTime", start);  // 大于开始时间
			}
			if(!TextUtils.isEmpty(whenStop)){
				Date stop = StringUtil.transformString(whenStop,StringUtil.DATE_FORMATTER_FOUR);
				where.and().le("CollectTime", stop);   // 小于结束时间
			}
			if(!TextUtils.isEmpty(columnName) && !TextUtils.isEmpty(columnValue)){
				where.and().like(columnName,"%" + columnValue + "%");
			}
			String sql = where.getStatement();
			models = (ArrayList<SingleComparisionModel>) where.query();
			Log.d("lixm", "queryByConditions_new , sql = " + sql);
		} catch (Exception e) {
			SysLogService.getInstance().insertSysLog("lixm", "queryByConditions_new , Exception : " + e.getMessage());
		}
		return models;
	}