`
wiley
  • 浏览: 253731 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

android数据库操作(二)

阅读更多
package cn.madfinger.android.core;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.json.JSONException;
import org.json.JSONObject;

import android.content.ContentValues;
import android.database.Cursor;
import android.util.Log;
import cn.madfinger.android.core.util.DateUtils;
import cn.madfinger.android.core.util.PageList;
import cn.madfinger.android.core.util.StrUtils;
import cn.madfinger.android.core.util.impl.PageListImpl;

/**
 * 数据库操作基类
 * 
 * @author wiley
 *
 * @param <T>
 */

public abstract class AbstractBaseDao<T extends AbstractBaseModel> {
	protected static String TAG = AbstractBaseDao.class.getSimpleName();
	private static Map<String, Integer> TYPES = new HashMap<String, Integer>();
	public static final int TYPE_STRING=1;
	public static final int TYPE_INTEGER=2;
	public static final int TYPE_LONG=3;
	public static final int TYPE_SHORT=4;
	public static final int TYPE_FLOAT=5;
	public static final int TYPE_DOUBLE=6;
	
	static {
		TYPES.put("date", TYPE_STRING);
		TYPES.put("string", TYPE_STRING);
		TYPES.put("integer", TYPE_INTEGER);
		TYPES.put("int", TYPE_INTEGER);
		TYPES.put("long", TYPE_LONG);
		TYPES.put("short", TYPE_SHORT);
		TYPES.put("float", TYPE_FLOAT);
		TYPES.put("double", TYPE_DOUBLE);
	}
	//protected SQLiteDatabase dbHandler;
	protected SqliteHelper sqliteHelper;

	public AbstractBaseDao() {

	}

	public void setSqliteHelper(SqliteHelper sqliteHelper) {
		this.sqliteHelper = sqliteHelper;
	}
	
	
	public long getCount(){
		return getCount(null, null, null, null);
	}
	
	public long getCount(String selection, String[] selectionArgs){
		return getCount(selection, selectionArgs, null, null);
	}
	
	public long getCount(String selection, String[] selectionArgs,String groupBy, String having){
		String sqlString="SELECT COUNT(*) AS NUM FROM "+this.getEntityClass().getSimpleName();
		if(!StrUtils.isEmpty(selection)){
			sqlString+=" "+selection;
		}
		if(!StrUtils.isEmpty(groupBy)){
			sqlString+=" "+groupBy;
			if(!StrUtils.isEmpty(having)){sqlString+=having;}
		}
		Cursor cursor=this.execSql(sqlString,selectionArgs);
		cursor.moveToFirst();
		return cursor.getLong(0);
	}

	public PageList<Map<String, Object>> queryPageList(String[] columns,int pageNum, int maxPerPage){
		return queryPageList(columns, null, null, null, null, null, pageNum, maxPerPage);
	}
	
	public PageList<Map<String, Object>> queryPageList(String[] columns,String selection, String[] selectionArgs,int pageNum, int maxPerPage){
		return queryPageList(columns, selection, selectionArgs, null, null, null, pageNum, maxPerPage);
	}
	
	public PageList<Map<String, Object>> queryPageList(String[] columns,String selection, String[] selectionArgs,String orderBy,int pageNum, int maxPerPage){
		return queryPageList(columns, selection, selectionArgs, null, null, orderBy, pageNum, maxPerPage);
	}
	
	public PageList<Map<String, Object>> queryPageList(String[] columns,String selection, String[] selectionArgs,String groupBy, String having, String orderBy,int pageNum, int maxPerPage){
		long recordCount=getCount(selection,selectionArgs,groupBy,having);
		PageListImpl<Map<String, Object>> page = new PageListImpl<Map<String, Object>>();
		page.calculatePageInfo(pageNum, maxPerPage, recordCount);
		Cursor cursor=sqliteHelper.getReaderHandler().query(this.getEntityClass().getSimpleName(), columns, selection, selectionArgs, groupBy, having, orderBy,maxPerPage+","+page.getStartRecordNum());
		List<Map<String, Object>> list=cursor2List(cursor,columns);
		page.setDataList(list);
		return page;
	}
	
	public PageList<T> getPageList(int pageNum, int maxPerPage){
		return getPageList(null, null, null, null, null, pageNum, maxPerPage);
	}
	
	public PageList<T> getPageList(String selection, String[] selectionArgs,int pageNum, int maxPerPage){
		return getPageList(selection, selectionArgs, null, null, null, pageNum, maxPerPage);
	}
	
	public PageList<T> getPageList(String selection, String[] selectionArgs,String orderBy,int pageNum, int maxPerPage){
		return getPageList(selection, selectionArgs, null, null, orderBy, pageNum, maxPerPage);
	}
	
	public PageList<T> getPageList(String selection, String[] selectionArgs,String groupBy, String having, String orderBy,int pageNum, int maxPerPage){
		long recordCount=getCount(selection, selectionArgs, groupBy, having);
		PageListImpl<T> page = new PageListImpl<T>();
		page.calculatePageInfo(pageNum, maxPerPage, recordCount);
		String sqlString="SELECT * FROM "+this.getEntityClass().getSimpleName();
		if(!StrUtils.isEmpty(selection)){
			sqlString+=" "+selection;
		}
		if(!StrUtils.isEmpty(groupBy)){
			sqlString+=" "+groupBy;
			if(!StrUtils.isEmpty(having)){sqlString+=having;}
		}
		if(!StrUtils.isEmpty(orderBy)){
			sqlString+=" "+orderBy;
		}
		sqlString+=" LIMIT "+maxPerPage+" OFFSET "+page.getStartRecordNum();
		Cursor cursor=this.execSql(sqlString);
		List<T> list=cursor2List(cursor);
		page.setDataList(list);
		return page;
	}
	
	public List<Map<String,Object>> queryList(String[] columns){
		return queryList(columns, null, null, null, null, null);
	}
	
	public List<Map<String,Object>> queryList(String[] columns, String selection, String[] selectionArgs){
		return queryList(columns, selection, selectionArgs, null, null, null);
	}
	
	public List<Map<String,Object>> queryList(String[] columns, String selection, String[] selectionArgs,String orderBy){
		return queryList(columns, selection, selectionArgs, null, null, orderBy);
	}
	
	public List<Map<String,Object>> queryList(String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy){
		Cursor cursor=queryCursor(columns, selection, selectionArgs, groupBy, having, orderBy);
		return cursor2List(cursor,columns);
	}
	
	public Cursor queryCursor(String[] columns){
		return queryCursor(columns, null, null, null, null, null);
	}
	
	public Cursor queryCursor(String[] columns, String selection, String[] selectionArgs){
		return queryCursor(columns, selection, selectionArgs, null, null, null);
	}
	
	public Cursor queryCursor(String[] columns, String selection, String[] selectionArgs,String orderBy){
		return queryCursor(columns, selection, selectionArgs, null, null, orderBy);
	}
	
	
	public Cursor queryCursor(String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy){
		return sqliteHelper.getReaderHandler().query(this.getEntityClass().getSimpleName(), columns, selection, selectionArgs, groupBy, having, orderBy);
	}
	
	public List<T> getList(){
		return getList(null, null, null, null, null);
	}
	
	public List<T> getList(String selection, String[] selectionArgs){
		return getList(selection, selectionArgs, null, null, null);
	}
	
	public List<T> getList(String selection, String[] selectionArgs,String orderBy){
		return getList(selection, selectionArgs, null, null, orderBy);
	}
	
	public List<T> getList(String selection, String[] selectionArgs,String groupBy, String having, String orderBy){
		Cursor cursor=getCursor(selection, selectionArgs, groupBy, having, orderBy);
		List<T> list=cursor2List(cursor);
		return list;
	}
	
	public Cursor getCursor(){
		return getCursor(null, null, null, null, null);
	}
	
	public Cursor getCursor(String selection, String[] selectionArgs){
		return getCursor(selection, selectionArgs, null, null, null);
	}
	
	public Cursor getCursor(String selection, String[] selectionArgs,String orderBy){
		return getCursor(selection, selectionArgs, null, null, orderBy);
	}
	
	public Cursor getCursor(String selection, String[] selectionArgs,String groupBy, String having, String orderBy){
		String sqlString="SELECT * FROM "+this.getEntityClass().getSimpleName();
		if(!StrUtils.isEmpty(selection)){
			sqlString+=" "+selection;
		}
		if(!StrUtils.isEmpty(groupBy)){
			sqlString+=" "+groupBy;
			if(!StrUtils.isEmpty(having)){sqlString+=having;}
		}
		if(!StrUtils.isEmpty(orderBy)){
			sqlString+=" "+orderBy;
		}
		Cursor cursor=execSql(sqlString,selectionArgs);
		return cursor;
	}

	public T getById(String id){
		if(StrUtils.isEmpty(id))return null;
		String sqlString="SELECT * FROM "+this.getEntityClass().getSimpleName()+" WHERE id=?";
		Cursor cursor=execSql(sqlString, new Object[]{id});
		List<T> list=cursor2List(cursor);
		if(StrUtils.isEmpty(list)||list.size()==0)return null;
		return list.get(0);
	}

	public void saveOrUpdate(T obj) {
		String sqlString;
		List<Object> objList = new LinkedList<Object>();
		String tmp = "";
		String tmp2 = "";
		int i = 0;
		boolean isInsert=StrUtils.isEmpty(obj.getId());
		if(isInsert)obj.setId(UUID.randomUUID().toString().replaceAll("-", ""));
		JSONObject json = obj.toJSON();
		Iterator<?> it = json.keys();
		while (it.hasNext()) {
			String field = (String) it.next();
			if(!isInsert&&field.equals("id"))continue;
			if (i++ != 0) {
				tmp += ",";
				if(isInsert)tmp2 += ",";
			}
			tmp += isInsert?field:field+"=?";
			if(isInsert)tmp2 += "?";
			try {
				Object value = json.get(field);
				if(value instanceof Date){
					value=DateUtils.date2String((Date)value);
				}
				objList.add(value);
			} catch (JSONException e) {
				//e.printStackTrace();
				Log.e(TAG, e.getMessage());
			}
		}
		if(isInsert){
			sqlString = "INSERT INTO " + obj.getClass().getSimpleName() + "("
			+ tmp + ") VALUES(" + tmp2 + ")";
		}else{
			objList.add(obj.getId());
			sqlString = "UPDATE " + obj.getClass().getSimpleName()
			+ " SET "+tmp+" WHERE id=?";
		}
		execSql(sqlString, objList.toArray());		
	}
	
	public void delete(String id){
		if(StrUtils.isEmpty(id))return;
		String sqlString="DELETE FROM "+this.getEntityClass().getSimpleName()+" WHERE id=?";
		execSql(sqlString, new Object[]{id});
	}
	
	public void delete(T obj) {
		if(StrUtils.isEmpty(obj.getId()))return;
		delete(obj.getId());
	}
	
	public int delete(String whereClause, String[] whereArgs){
		return sqliteHelper.getWriterHandler().delete(this.getEntityClass().getSimpleName(), whereClause, whereArgs);
	}
	
	public long insert(ContentValues values){
		return sqliteHelper.getWriterHandler().insert(this.getEntityClass().getSimpleName(), null, values);
	}
	
	public int update(ContentValues values, String whereClause, String[] whereArgs){
		return sqliteHelper.getWriterHandler().update(this.getEntityClass().getSimpleName(), values, whereClause, whereArgs);
	}
	
	public Cursor execSql(String sqlString) {
		return execSql(sqlString,null);
	}
	
	public Cursor execSql(String sqlString,Object[] bindArgs){
		Log.d(TAG, "SQL:\r\n"+sqlString);
		if(!StrUtils.isEmpty(bindArgs)){
			for (int i = 0; i < bindArgs.length; i++) {
				Log.d(TAG, ""+i+"="+bindArgs[i]);
			}
		}
		Cursor cursor=null;
		if(StrUtils.startsWith(sqlString, "select")){
			//String[] tmps=(String[])Array.newInstance(String.class, bindArgs.length);
			String[] strArgs=StrUtils.isEmpty(bindArgs)?null:Arrays.asList(bindArgs).toArray(new String[]{});
			cursor=sqliteHelper.getReaderHandler().rawQuery(sqlString,strArgs);
		}else{
			sqliteHelper.getWriterHandler().execSQL(sqlString,bindArgs);
		}
		return cursor;
	}
	
	@SuppressWarnings("unchecked")
	public List<Map<String,Object>> cursor2List(Cursor cursor,String[] columns){
		Log.d(TAG, "RESULT:");
		List<Map<String,Object>>  rtnlist=null;
		if(StrUtils.isEmpty(cursor)||cursor.getCount()==0)return rtnlist;
		T t=(T)this.getEntityObject();
		Map<String,String> fieldMap=t.toFieldMap();
		/*Iterator<String> it=fieldMap.keySet().iterator();
		while (it.hasNext()) {
			String key = (String) it.next();
			fieldMap.put(key.toUpperCase(), fieldMap.get(key));
			fieldMap.remove(key);
		}*/
		rtnlist=new ArrayList<Map<String,Object>>();
		while (cursor.moveToNext()) {
			//String[] columnNames=cursor.getColumnNames();
			Map<String,Object> map=new HashMap<String, Object>();
			for (String column : columns) {
				String column2=""+Character.toUpperCase(column.charAt(0))+column.substring(1);
				String columnType=fieldMap.get(column2);
				Object obj=getValue(cursor, column, columnType);
				map.put(column, obj);
			}
			JSONObject json=new JSONObject(map);
			Log.d(TAG,json.toString());
			rtnlist.add(map);
		}
		return rtnlist;
	}
	
	@SuppressWarnings("unchecked")
	public List<T> cursor2List(Cursor cursor){
		Log.d(TAG, "RESULT:");
		List<T> rtnlist=null;
		if(StrUtils.isEmpty(cursor)||cursor.getCount()==0)return rtnlist;
		rtnlist=new ArrayList<T>();
		T obj=null;
		while (cursor.moveToNext()) {
			obj=(T)this.getEntityObject();
			Map<String, String> fieldMap=obj.toFieldMap();
			Iterator<String> it=obj.toFieldSet().iterator();
			while (it.hasNext()) {
				String fieldName = (String) it.next();
				try {
					String fieldType=fieldMap.get(fieldName);
					Class clazz=getGenericClass(fieldType);
					Method method=obj.getClass().getMethod("set"+fieldName, clazz);
					Object objArg=getValue(cursor,fieldName,fieldType);
					if(fieldType.equalsIgnoreCase("date")){
						objArg=DateUtils.string2Date(objArg.toString(), 1);
					/*}else if(fieldType.equalsIgnoreCase("float")){
						objArg=StrUtils.fixFloat2(Float.parseFloat(objArg.toString()));
					}else if(fieldType.equalsIgnoreCase("double")){
						objArg=StrUtils.fixDouble2(Double.parseDouble(objArg.toString()));
					*/}
					method.invoke(obj, objArg);
				} catch (Exception e) {
					//e.printStackTrace();
					Log.e(TAG, e.getMessage());
					continue;
				}
			}
			Log.d(TAG,obj.toJSONString());
			rtnlist.add(obj);
		}
		return rtnlist;
	}
	
	protected Class<?> getEntityClass() {
		return getGenericClass(this.getClass(), 0);
	}

	@SuppressWarnings("unchecked")
	protected Class getGenericClass(Class clazz, int index) {
		Type genType = clazz.getGenericSuperclass();
		if (genType instanceof ParameterizedType) {
			Type[] params = ((ParameterizedType) genType)
					.getActualTypeArguments();
			if ((params != null) && (params.length >= (index - 1))) {
				return (Class) params[index];
			}
		}// end if.
		return null;
	}

	protected Object getEntityObject() {
		Class<?> clazz = this.getEntityClass();
		Object obj = null;
		try {
			obj = clazz.newInstance();
		} catch (Exception e) {
			Log.e(TAG, e.getMessage());
		}
		return obj;
	}
	
	private int getTypeIndex(String typeString) {
		typeString=typeString.toLowerCase();
		return TYPES.containsKey(typeString)?TYPES.get(typeString):0;
	}
	
	@SuppressWarnings("unchecked")
	private Class getGenericClass(String type){
		if(type.equalsIgnoreCase("string")){
			return String.class;
		}else if(type.equalsIgnoreCase("date")){
			return Date.class;
		}else if(StrUtils.startsWith(type, "int")){
			return int.class;
		}else if(StrUtils.startsWith(type, "short")){
			return short.class;
		}else if(StrUtils.startsWith(type, "long")){
			return long.class;
		}else if(StrUtils.startsWith(type, "float")){
			return float.class;
		}else if(StrUtils.startsWith(type, "double")){
			return double.class;
		}else{
			return Object.class;
		}
	}
	
	private Object getValue(Cursor cursor,String fieldName,String fieldType){
		int columnIndex=cursor.getColumnIndex(fieldName.toUpperCase());
		Object objArg=null;
		switch (getTypeIndex(fieldType)) {
		case TYPE_DOUBLE:
			objArg=cursor.getDouble(columnIndex);
			break;
		case TYPE_FLOAT:
			objArg=cursor.getFloat(columnIndex);
			break;
		case TYPE_INTEGER:
			objArg=cursor.getInt(columnIndex);
			break;
		case TYPE_LONG:
			objArg=cursor.getLong(columnIndex);
			break;
		case TYPE_SHORT:
			objArg=cursor.getShort(columnIndex);
			break;
		case TYPE_STRING:
		default:
			objArg=cursor.getString(columnIndex);
		}
		return objArg;
	}
}

 

分享到:
评论

相关推荐

    android数据库操作封装

    "android数据库操作封装"主要是为了提高代码的可读性、可维护性和复用性,通过创建自定义的数据访问对象(DAO)层和数据库帮助类来实现。 1. 数据库Helper类: 在Android中,我们通常会创建一个继承自`...

    android数据库操作实例

    总结来说,这个"android数据库操作实例"涵盖了Android应用中使用SQLite数据库的基础知识,包括创建数据库、定义表结构、插入、查询、更新和删除数据等操作。通过学习这个实例,开发者可以更好地理解如何在Android...

    Android 数据库操作 以及命令行上操作sqlite

    本文将深入探讨Android中的SQLite数据库操作以及如何在命令行上操作SQLite。 首先,让我们了解Android如何与SQLite交互。在Android中,我们通常通过SQLiteOpenHelper类来创建、升级和访问数据库。这个类提供了方法...

    android数据库操作demo

    本"android数据库操作demo"主要展示了如何在Android应用中进行SQLite数据库的基本操作,包括增、删、改、查四大功能。下面我们将详细探讨这些知识点。 首先,要创建一个SQLite数据库,我们需要创建一个`...

    你想要Android数据库操作精华(安全、并发、单例等)

    本Demo——"你想要的Android数据库操作精华(安全、并发、单例等)",旨在深入探讨如何在Android Studio环境下进行高效且安全的数据库操作,包括使用数据库框架、数据库加密、并发控制以及单例模式的应用。...

    android数据库操作Demo

    本示例"android数据库操作Demo"提供了一个基础的教程,涵盖了数据库的基本操作,包括添加数据(增)、删除数据(删)、查询数据(查)和更新数据(改)。我们将深入探讨这些核心概念。 首先,Android使用SQLite作为...

    Android 数据库操作

    在这个"Android 数据库操作"主题中,我们将深入探讨如何在Android应用中使用SQLite3进行数据库的创建、查询、插入、更新和删除等操作。 首先,让我们了解Android中的SQLite数据库的基本概念。每个Android应用都有一...

    android 数据库操作封装类 继承可用

    在Android开发中,数据库操作是常见的任务之一,用于存储和检索应用程序的数据。为了简化这一过程,开发者通常会创建一个数据库帮助类(DataBaseHelper)来封装SQLite数据库的操作。在这个场景下,我们有一个名为`...

    Android数据库操作命令

    Android数据库sqlite操作命令指导,同时可以快速调试定位问题点,并获取有用信息。

    Android数据库ORM封装

    总结来说,Android数据库ORM封装使得数据库操作更加简便,通过Room框架,我们可以以声明式的方式定义数据库操作,同时保持代码的清晰和可维护性。`DataBaseDemo`项目则提供了具体的实现示例,有助于你在实际项目中...

    android数据库实例二

    本教程将深入探讨"android数据库实例二",帮助开发者系统地掌握Android中SQLite数据库的使用。 首先,我们要理解SQLite的基本概念。SQLite是一个轻量级的、嵌入式的、支持SQL的数据库引擎,它无需单独的服务进程,...

    android 数据库操作小插件

    android sqlite 操作工具包

    Android数据库SQLite详解

    本文将深入探讨SQLite在Android中的使用,包括基本概念、数据库操作以及实际应用示例。 ### 1. SQLite基本概念 - **数据库**: 数据库是存储和组织数据的结构化系统,SQLite在Android中表现为一个数据库文件,扩展...

    Android数据库完美框架和示例

    在Android开发中,数据库是应用数据持久化的重要方式。Android提供了SQLite数据库系统...在`DemoDateBase`压缩包中,应该包含了这个框架的实现代码,你可以下载并参考其中的细节,进一步学习和实践Android数据库操作。

    android数据库应用实例

    为了提高数据库性能,可以考虑使用索引、避免在循环中执行数据库操作、批量插入数据等策略。同时,合理设计表结构,减少冗余数据,也是优化的关键。 11. 数据库安全与备份 考虑到数据安全,开发者需要对敏感信息...

    Android数据库框架GreenDAO的基本操作

    在应用启动时,使用DaoMaster.DevOpenHelper创建并升级数据库,然后通过DaoSession管理数据库操作。 基本操作包括: 1. 插入数据:使用 DaoSession 的 insert() 方法可以将实体对象插入到数据库中。 2. 查询数据:...

    Android实验报告Sqlite数据库操作.pdf

    Android SQLite 数据库操作报告 一、实验目的 Android 实验报告的主要目的是熟悉 Android 平台的文件操作、掌握 Android SQLite 数据库的设计和应用、熟悉 XML 和 JSON 文件的读取。通过本实验,用户可以掌握 ...

    Android异步操作数据库

    你可以创建一个`AsyncTask`子类,将数据库操作放入`doInBackground()`方法中,然后在`onPostExecute()`方法中更新UI。这样,数据库操作不会影响主线程,提升应用响应速度。 2. **Handler-Looper-Message机制** 另...

    android数据库实例.pdf

    Android数据库实例 Android数据库实例是指在Android应用程序中使用的数据库系统,用于存储和管理应用程序的数据。在Android系统中, SQLite数据库是最常用的数据库管理系统,它提供了一个轻量级的关系数据库管理...

    android 项目数据库操作

    在Android开发中,数据库操作是不可或缺的一部分,尤其是在构建复杂应用程序时。Android系统支持SQLite数据库,一个轻量级的关系型数据库,适用于移动设备。本项目"android 项目数据库操作"主要探讨了如何在Android...

Global site tag (gtag.js) - Google Analytics