Android之SQLite数据库操作

最新推荐文章于 2023-03-29 10:08:40 发布
最新推荐文章于 2023-03-29 10:08:40 发布
阅读量1.4k 收藏
点赞数
分类专栏： Android 文章标签： Android SQLite 工具类 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011290399/article/details/9275839
版权

前些日子，搞了个Android项目，接触到了SQLite数据库

个人感觉有点麻烦：

1、数据库字段的修改，需要修改实体类，DAO类的字段的增加、修改、删除

2、传统的JDBC思想，体力劳动，十分浪费程序员的精力

3、程序耦合性太高，不够灵活

怎样才能将SQLite的DAO类使用的如同Hibernate一样简单呢？

Android的本身提供了SQLiteOpenHelper类、SQLiteDatabase类用作数据库方面的处理，很遗憾的是这两个类中没能提供如同Hibernate中Criteria类的操作

没办法，只能自己手工封装了，一切为了能有使用Hibernate的感觉

下面就给大家看代码了

首先定义一个BaseDAO的接口类，没太多的内容，就是实现类的方法汇总，这里呢就不提供了，让我们直接来看BaseDAO的实现类好了，尼玛，别说坑爹啊……

首先来看实现类的属性、构造函数、工具方法：

	private DataBaseHelper helper;
	private JavaBeanReflect reflect = JavaBeanReflect.getInstance();
	private static Map<Class<? extends Object>, Class<? extends Object>> clsMap = new HashMap<Class<? extends Object>, Class<? extends Object>>();

	static {
		clsMap.put(int.class, Integer.class);
		clsMap.put(long.class, Long.class);
		clsMap.put(float.class, Float.class);
		clsMap.put(double.class, Double.class);
		clsMap.put(boolean.class, Boolean.class);
		clsMap.put(byte.class, Byte.class);
		clsMap.put(short.class, Short.class);
	}

	public SQLiteDAO(Context context) {
		helper = new DataBaseHelper(context);
	}

	/**
	 * 获得更改数据库操作权限
	 * @return
	 */
	public SQLiteDatabase getWriteDataBase() {
		return helper.getWritableDatabase();
	}

	/**
	 * 获得读取数据库操作权限
	 * @return
	 */
	public SQLiteDatabase getReadDataBase() {
		return helper.getReadableDatabase();
	}

	/**
	 * 关闭数据库连接操作，释放资源
	 * @param db		SQLiteDataBase对象
	 * @param cursor	Cursor对象
	 */
	public void freeResource(SQLiteDatabase db, Cursor cursor) {
		if (cursor != null) {
			cursor.close();
		}
		if (db != null) {
			db.close();
		}
	}

	/**
	 * 将数据封装的ContentValues对象中
	 * 用于新增、更新数据操作
	 * @param t	实体类对象
	 * @return	ContentValues对象
	 */
	public <T> ContentValues setAttribute(T t) {
		ContentValues values = new ContentValues();
		Field[] fields = reflect.getDeclaredFields(t.getClass());
		for (Field field : fields) {
			if (!"id".equals(field.getName())) {
				values.put(field.getName(), String.valueOf(reflect.getFieldValue(t, field)));
			}
		}
		return values;
	}

	/**
	 * 提取Cursor对象中的数据，并封装进实体类对象中
	 * @param cursor	Cursor对象
	 * @param entity	实体类字节码
	 * @return			实体类对象
	 * @throws Exception
	 */
	public <T> T setAttribute(Cursor cursor, Class<T> entity) throws Exception {
		if (cursor != null) {
			Field[] fields = reflect.getDeclaredFields(entity);
			String[] columns = cursor.getColumnNames();
			T t = entity.newInstance();
			for (Field field : fields) {
				Class<? extends Object> cls = field.getType();
				for (String column : columns) {
					cls = getBasicClass(cls);
					boolean isBool = isBasicType(cls);
					if (isBool) {
						if (column.equalsIgnoreCase(field.getName())) {
							String str = cursor.getString(cursor.getColumnIndex(column));
							if (str == null) {
								break;
							}
							Constructor<? extends Object> con = cls.getConstructor(String.class);
							Object obj = con.newInstance(str);
							field.setAccessible(true);
							field.set(t, obj);
						}
					} else {
						Object obj = setAttribute(cursor, cls);
						field.set(t, obj);
					}
				}
			}
			return t;
		}
		return null;
	}

	/**
	 * 获得包装类
	 * @param cls
	 * @return
	 */
	private Class<? extends Object> getBasicClass(Class<? extends Object> cls) {
		Class<? extends Object> _cls = clsMap.get(cls);
		if (_cls == null) {
			_cls = cls;
		}
		return _cls;
	}

	/**
	 * 判断是否为基本类型
	 * @param cls
	 * @return
	 */
	private boolean isBasicType(Class<? extends Object> cls) {
		if (Integer.class.equals(cls) || Long.class.equals(cls)
				|| Float.class.equals(cls) || Double.class.equals(cls)
				|| Boolean.class.equals(cls) || Byte.class.equals(cls)
				|| Short.class.equals(cls) || String.class.equals(cls)) {
			return true;
		}
		return false;
	}

	/**
	 * 将实体类属性字段封装到String数组中
	 * @param entity	实体类Class文件
	 * @return			String[]数组
	 */
	public <T> String[] getColumns(Class<T> entity) {
		Field[] fields = reflect.getDeclaredFields(entity);
		String[] columns = new String[fields.length];
		for (int i = 0; i < fields.length; i++) {
			columns[i] = fields[i].getName();
		}
		return columns;
	}

	/**
	 * 封装SQL查询中的where子句
	 * @param paramNames	where子句条件参数
	 * @return
	 */
	public String getSelection(String[] paramNames) {
		if (paramNames.length > 0) {
			StringBuilder builder = new StringBuilder();
			for (String str : paramNames) {
				builder.append(str + " = ? and ");
			}
			if (builder.length() > 0) {
				builder.delete(builder.lastIndexOf("?") + 1, builder.length());
			}
			return builder.toString();
		}
		return null;
	}

	/**
	 * 封装SQL模糊查询中的where子句
	 * @param paramNames
	 * @return
	 */
	public String getBlurSelection(String[] paramNames) {
		if (paramNames.length > 0) {
			StringBuilder builder = new StringBuilder();
			for (String str : paramNames) {
				builder.append(str + " like ? and ");
			}
			if (builder.length() > 0) {
				builder.delete(builder.lastIndexOf("?") + 1, builder.length());
			}
			return builder.toString();
		}
		return null;
	}

	public String[] getBlurValues(String[] values) {
		String[] temps = new String[values.length];
		for (int i = 0; i < values.length; i++) {
			temps[i] = "%" + values[i] + "%";
		}
		return temps;
	}

	/**
	 * 获得分页查询条件
	 * @param start	分页开始位置
	 * @param max	分页显示数目
	 * @return
	 */
	public String getLimit(int start, int max) {
		return start + "," + max;
	}

	/**
	 * 获得排序查询条件
	 * @param order	排序字段集合
	 * @return
	 */
	public String getOrder(Map<String, String> order) {
		if (order != null) {
			StringBuilder builder = new StringBuilder();
			Set<String> keys = order.keySet();
			for (String key : keys) {
				String str = order.get(key);
				if ("asc".equals(str) || "desc".equals(str)) {
					builder.append(key + " " + str + ", ");
				}
			}
			if (builder.length() > 0) {
				builder.delete(builder.lastIndexOf(","), builder.length());
			}
			return builder.toString();
		}
		return null;
	}
以上代码都有注释，也就不需要过多的解释了

不过有人会问JavaBeanReflect类代码有木有，贴在最后

下面是实现类实现的新增操作

	@Override
	public <T> long saveEntity(String tabName, T t) {
		if (StringUtils.isEmpty(tabName)) {
			return -1;
		}
		if (t == null) {
			return -1;
		}
		ContentValues values = setAttribute(t);
		SQLiteDatabase db = getWriteDataBase();
		db.beginTransaction();
		long id = db.insert(tabName, null, values);
		db.setTransactionSuccessful();
		db.endTransaction();
		freeResource(db, null);
		return id;
	}
不好意思，这个没有注释，大家就凑合着看吧

删除操作

	public <T> int deleteByID(String tabName, int id) {
		if (StringUtils.isEmpty(tabName)) {
			return -1;
		}
		String sql = "id = ?";
		SQLiteDatabase db = getWriteDataBase();
		db.beginTransaction();
		int i = db.delete(tabName, sql, new String[] { String.valueOf(id) });
		db.setTransactionSuccessful();
		db.endTransaction();
		freeResource(db, null);
		return i;
	}
修改操作 

	public <T> int updateEntity(String tabName, T t) {
		if (StringUtils.isEmpty(tabName)) {
			return -1;
		}
		ContentValues values = setAttribute(t);
		String sql = "id = ?";
		SQLiteDatabase db = getWriteDataBase();
		db.beginTransaction();
		int i = db.update(tabName, values, sql,
				new String[] { String.valueOf(JavaBeanReflect.getInstance()
						.getFieldValue(t, "id")) });
		db.setTransactionSuccessful();
		db.endTransaction();
		freeResource(db, null);
		return i;
	}
根据ID查询操作 

	@Override
	public <T> T findByID(String tabName, Class<T> entity, int id) {
		if (StringUtils.isEmpty(tabName)) {
			return null;
		}
		String[] columns = getColumns(entity);
		String selection = "id = ?";
		String[] values = new String[] { String.valueOf(id) };
		SQLiteDatabase db = getReadDataBase();
		Cursor cursor = db.query(tabName, columns, selection, values, null, null, null);
		T t = null;
		while (cursor.moveToNext()) {
			try {
				t = setAttribute(cursor, entity);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		freeResource(db, cursor);
		return t;
	}
查询所有数据集合(单张表) 

	public <T> List<T> findAll(String tabName, Class<T> entity) {
		if (StringUtils.isEmpty(tabName)) {
			return null;
		}
		String[] columns = getColumns(entity);
		SQLiteDatabase db = getReadDataBase();
		Cursor cursor = db.query(tabName, columns, null, null, null, null, null);
		List<T> list = new ArrayList<T>();
		while (cursor.moveToNext()) {
			try {
				T t = setAttribute(cursor, entity);
				list.add(t);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		freeResource(db, cursor);
		return list;
	}
分页查询操作 
	public <T> List<T> findAll(String tabName, Class<T> entity, int start, int max) {
		if (StringUtils.isEmpty(tabName)) {
			return null;
		}
		String[] columns = getColumns(entity);
		String limit = getLimit(start, max);
		SQLiteDatabase db = getReadDataBase();
		Cursor cursor = db.query(tabName, columns, null, null, null, null, null, limit);
		List<T> list = new ArrayList<T>();
		while (cursor.moveToNext()) {
			try {
				T t = setAttribute(cursor, entity);
				list.add(t);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		freeResource(db, cursor);
		return list;
	}
排序查询操作 

	public <T> List<T> findAll(String tabName, Class<T> entity, Map<String, String> order) {
		if (StringUtils.isEmpty(tabName)) {
			return null;
		}
		String[] columns = getColumns(entity);
		String orderBy = getOrder(order);
		SQLiteDatabase db = getReadDataBase();
		Cursor cursor = db.query(tabName, columns, null, null, null, null, orderBy);
		List<T> list = new ArrayList<T>();
		while (cursor.moveToNext()) {
			try {
				T t = setAttribute(cursor, entity);
				list.add(t);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		freeResource(db, cursor);
		return list;
	}
分页、排序一起来的就不上代码了，上面两个结合一下就好了

条件查询操作：

	public <T> List<T> findByPropery(String tabName, Class<T> entity, String[] paramNames, String[] values) {
		if (StringUtils.isEmpty(tabName)) {
			return null;
		}
		String[] columns = getColumns(entity);
		String selection = getSelection(paramNames);
		SQLiteDatabase db = getReadDataBase();
		Cursor cursor = db.query(tabName, columns, selection, values, null, null, null);
		List<T> list = new ArrayList<T>();
		while (cursor.moveToNext()) {
			try {
				T t = setAttribute(cursor, entity);
				list.add(t);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		freeResource(db, cursor);
		return list;
	}
模糊查询操作 

	public <T> List<T> findByBlur(String tabName, Class<T> entity, String[] paramNames, String[] values) {
		if (StringUtils.isEmpty(tabName)) {
			return null;
		}
		String[] columns = getColumns(entity);
		String selection = getBlurSelection(paramNames);
		values = getBlurValues(values);
		SQLiteDatabase db = getReadDataBase();
		Cursor cursor = db.query(tabName, columns, selection, values, null, null, null);
		List<T> list = new ArrayList<T>();
		while (cursor.moveToNext()) {
			try {
				T t = setAttribute(cursor, entity);
				list.add(t);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		freeResource(db, cursor);
		return list;
	}
JavaBeanReflect类代码 

/**
 * 针对JavaBean操作的反射工具类
 * @author Francis-ChinaFeng
 * @version 1.0 2013-07-08
 */
public class JavaBeanReflect {

	/**
	 * 单例模式
	 */
	private static JavaBeanReflect reflect = new JavaBeanReflect();

	private JavaBeanReflect() { }

	public static JavaBeanReflect getInstance() {
		return reflect;
	}

	/**
	 * 获得实体类中的属性信息数组
	 * @param entity
	 * @return
	 */
	public <T> Field[] getDeclaredFields(Class<T> entity) {
		return entity.getDeclaredFields();
	}

	/**
	 * 获得实体类中属性对应的值
	 * @param t
	 * @param field
	 * @return
	 */
	public <T> Object getFieldValue(T t, Field field) {
		field.setAccessible(true);
		Object obj = null;
		try {
			obj = field.get(t);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		field.setAccessible(false);
		return obj;
	}

	/**
	 * 获得实体类中属性对应的值
	 * @param t
	 * @param fieldName
	 * @return
	 */
	public <T> Object getFieldValue(T t, String fieldName) {
		try {
			Field field = t.getClass().getDeclaredField(fieldName);
			return getFieldValue(t, field);
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		}
		return null;
	}
}

虽然没有将代码全贴出来，不过也就那么几个方法

增加：新增实体类，批量增加

删除：根据ID删除、根据属性删除、模糊删除

更新：根据ID更新、根据属性更新、模糊更新

查询全部，代码全贴

根据属性查询：按照全部添加分页、排序操作

模糊查询同属性查询一样

这样，DAO实现类也就封装好了

如果在实际情况中的业务需求还需要其他复杂的操作，大家可以拓展下

Hibernate也可以使用该封装方法的思想

拍砖请联系QQ：920656263

希望对大家有所帮助~~  谢谢


 * 备注：
 * 因为查询操作中使用的是反射的技术
 * 故以封装好的程序暂时无法支持DATE数据类型
 * 如果需求DATE数据类型
 * 1、请重写setAttribute(Cursor cursor, Class<T> entity)方法，或者自定义操作方法
 * 2、请使用System.currentTimeMillis()方法获取long类型的时间值，在业务层进行业务处理















Francis-ChinaFeng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Sqlite 数据库使用方法
Jsonuu的博客
12-12 1054
import android.annotation.SuppressLint; import android.content.ContentValues; import android.content.Context; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import andr...
Android SQLite数据库基本操作
指点
02-10 2167
程序的最主要的功能在于对数据进行操作，通过对数据进行操作来实现某个功能。而数据库就是很重要的一个方面的，Android中内置了小巧轻便，功能却很强的一个数据库–SQLite数据库。那么就来看一下在Android程序中怎么去操作SQLite数据库来实现一些需求的吧，仍然以一个小例子开始： 在创建Android项目之前，我们应该想一下我们要定义的数据库的相关信息和里面的表格的相关信息，为了日后数据库的
Android 操作本地 SQLite数据库
m0_54130475的博客
06-30 1902
Android 操作本地 SQLite数据库
Android操作SQLite数据库
weixin_33905756的博客
07-19 58
2019独角兽企业重金招聘Python工程师标准>>> ...
Android-操作SQLite数据库（二）
往事似水拂流年的博客
06-19 198
一、概述 在操作SQLite数据库（一）中，我们为了判断底层数据库是否包含news_inf数据表，采用的处理方法十分繁琐，程序先尝试向news_inf数据表中插入记录，如果程序抛出异常，则在异常捕获catch块中创建news_inf数据表，然后再插入记录。在本例程中，使用更为优雅的方式来操作数据库——SQLiteOpenHelper类 在实际项目中很少使用SQLiteDatabase的方法来打...
Android中SQLite数据库查看工具
最新发布
05-07
SQLite是一个进程内的库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。它是一个零配置的数据库，这意味着与其他数据库不一样，您不需要在系统中配置。 就像其他数据库，SQLite 引擎不是一个...
Android编程之SQLite数据库操作方法详解
08-29
"Android编程之SQLite数据库操作方法详解" Android编程之SQLite数据库操作方法详解 SQLite是Android应用程序中常用的嵌入式数据库，它支持SQL语言，并且只利用很少的内存就有很好的性能。此外，它还是开源的，任何...
Android使用SQLite数据库的示例
01-05
Android中SQLite数据库的使用 1、创建SQLite数据库 SQLiteDatabase db= SQLiteDatabase.openOrCreateDatabase( /data/data/ + getPackageName() + /test.db, null); 执行完这条语句，可以在adb shell下进入/data/...
安卓 - 使用SQLite数据库
IKZWJ0516的博客
12-12 3251
SQLite是D. Richard Hipp用C语言编写的开源嵌入式数据库引擎。它支持大多数的SQL92标准，并且可以在所有主要的操作系统上运行。
Android之Sqlite数据库操作实例
11-16
Android之Sqlite数据库操作实例
Java-泛型
weixin_45196232的博客
03-29 113
规定好某个位置的类型1、规定集合容器的元素类型2、成员变量的类型3、规定方法的参数的类型4、规定方法的返回值的类型public class 类名 < E1 , E2 , E3 > {//类中的成员变量，方法的参数和返回类型，局部变量都可以使用泛型 }
Spring jdbc基础类
weixin_33932129的博客
05-09 89
为什么80%的码农都做不了架构师？>>> ...
[会写代码的健身爱好者成长史]之spring-security
DreamStat的博客
02-11 1103
1.什么是spring-security? spring-security是spring家族推出的一个安全校验权限框架，一般中大型项目都会采用这个框架 2.准备工作 2.1 添加依赖 <!--redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spri
Android之SQLite数据库的使用
02-10 5万+
SQLite是比较小而功能比较全的关系型数据库，下面介绍一下SQLite数据库的使用方法，及增删改查操作。 创建一个Android项目； 首先我们需要创建一个DatabaseHelper这个助手类，源码： package cn.android.sword.sqlite.db; import android.content.Context; import android.database.s
Android 开发之 Sqlite数据库操作
Not_Important的博客
09-01 338
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
android之利用SQLite数据库实现登陆和注册
zhangziyangup
12-19 3263
首先，说一下SQLite的概念： SQLite 是一个开源的嵌入式关系数据库，它可以减少应用程序管理数据的开销 ， SQLite 可移植性好 、 很容易使用 、 很小 、 高效而且可靠 。目前在Android 系统中集成的是 SQLite3 版本 ，SQLite 不支持静态数据类型 ， 而是使用列关系 。 这意味着它的数据类型不具有表列属性 ， 而具有数据本身的属性 。 当某个值插入数据库时， ...
Android中SQLite应用详解
t225com
08-26 1854
上次我向大家介绍了SQLite的基本信息和使用过程，相信朋友们对SQLite已经有所了解了，那今天呢，我就和大家分享一下在Android中如何使用SQLite。 现在的主流移动设备像Android、iPhone等都使用SQLite作为复杂数据的存储引擎，在我们为移动设备开发应用程序时，也许就要使用到SQLite来存储我们大量的数据，所以我们就需要掌握移动设备上的SQLite开发技巧。对于Andr...
Carson带你学Android：SQLlite数据库操作全解析(SQLiteOpenHelper类)
热门推荐
Carson带你学Android
11-20 6万+
前言 SQLite数据库操作在Android开发中非常常用 今天我将带大家全面了解关于SQLite数据库的操作（增、删、查、改） 目录1. SQLite数据库介绍 SQLite是Android内置的一个小型、关系型、属于文本型的数据库。 Android提供了对 SQLite数据库的完全支持，应用程序中的任何类都可以通过名称来访问任何的数据库，但是应用程序之外的就不能访问。Android中，通过S
Android应用SQLite数据库操作详解
"这篇教程详细介绍了如何在Android环境中创建和使用SQLite数据库，旨在帮助开发者为Android应用程序构建数据库操作功能。SQLite是一个轻量级、开源且跨平台的SQL数据库，常用于移动设备上存储结构化数据。Android...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值