利用SQLiteOpenHelper管理数据库 万能工具类

最新推荐文章于 2022-11-29 21:13:04 发布
最新推荐文章于 2022-11-29 21:13:04 发布
阅读量277 收藏
点赞数
文章标签： SQLiteOpenHelper 创建数据库很简单 很好用的工具 怎么创建数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15157651/article/details/51221754
版权 
使用起来超简单  ：
ThrustDBHelper thrustDBHelper = new ThrustDBHelper(this);
//添加一条数据
thrustDBHelper.addDataBase(new ThrustData));
//查询所有数据
List list<thrust> =  thrustDBHelper.findAll(ThrustData.class) 
 
具体用法 自己慢慢看 ， 很简单的   不懂得 可以加群来问我qq群： 164603384
 
package com.example.ndkreadfpga.db;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

import android.content.ContentValues;
import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

/**
 * 数据库管理工具
 * 
 * @author Raul
 * 
 */
public abstract class BaseDBHelper<T> {
	// 数据库名
	public static  String DATABASE_NAME = "TABLE_Data.db";
	// 数据库版本
	private static int DATABASE_VERSION = 1;

	public static final String TEST_DATA = "TEST_DATA"; // 坡度

	/********************************************** 创建表信息 **************************************/

	private final Context context;
	private DatabaseHelper DBHelper;
	public SQLiteDatabase db;

	/**
	 * 构造方法
	 * 
	 * @param ctx
	 */
	public BaseDBHelper(Context ctx,String dbName) {
		this.context = ctx;
		// // 得到版本值ֵ
		DATABASE_VERSION = getCurrentVersion(context);
		DATABASE_NAME = dbName;
		DBHelper = new DatabaseHelper(context);
	}

	@SuppressWarnings("finally")
	private static int getCurrentVersion(Context context) {

		int verCordeOld = 0;

		try {
			// 获取应用信息
			PackageInfo info = context.getPackageManager().getPackageInfo(
					context.getPackageName(), 0);

			// 得到应用版本�?
			verCordeOld = info.versionCode;

		} catch (NameNotFoundException e) {
			e.printStackTrace();
		} finally {
			return verCordeOld;
		}
	}
	
	public abstract  String createTab();
	
	private  class DatabaseHelper extends SQLiteOpenHelper {
		DatabaseHelper(Context context) {
			super(context, DATABASE_NAME, null, DATABASE_VERSION);
		}

		@Override
		public void onCreate(SQLiteDatabase db) {
			/**
			 * 在创建数据库连接时， 创建数据库表。
			 */
			String sqlString = createTab();
			Log.e("SQL", sqlString);
			db.execSQL(sqlString);
		}

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

			System.out.println("old version: " + oldVersion);
			System.out.println("new version: " + newVersion);

			db.execSQL("DROP TABLE IF EXISTS " + TEST_DATA);

			this.onCreate(db);

		}
	}

	/**
	 * 打开一个数据库连接。
	 * 
	 * @return
	 * @throws SQLException
	 */
	public BaseDBHelper open() throws SQLException {
		db = DBHelper.getWritableDatabase();
		return this;
	}

	/**
	 * 关闭数据库连接
	 */
	public void close() {
		DBHelper.close();
	}

	/**
	 *插入操作。
	 * 
	 * @param entity
	 * @param initialValues
	 * @return
	 */
	public long insert(String entity, ContentValues initialValues) {
		return db.insert(entity, null, initialValues);
	}

	/**
	 *获取数据库表信息。
	 * 
	 * @param entity
	 * @param cols
	 * @param selection
	 * @return
	 */
	public Cursor get(String entity, String[] cols, String selection) {
		Cursor mCursor = db.query(true, entity, cols, selection, null, null,
				null, null, null);
		return mCursor;
	}

	/**
	 * 获取数据库表信息。
	 * 
	 * @param entity
	 * @param cols
	 * @param selection
	 * @param order
	 * @return
	 */
	public Cursor get(String entity, String[] cols, String selection,
			String order) {
		Cursor mCursor = db.query(true, entity, cols, selection, null, null,
				null, order, null);
		return mCursor;
	}

	/**
	 *  更新数据库
	 * 
	 * @param entity
	 * @param selection
	 * @param initialValues
	 * @return
	 */
	public boolean update(String entity, ContentValues initialValues,
			String selection) {
		return db.update(entity, initialValues, selection, null) > 0;
	}

	/**
	 * 清空数据库表。
	 * 
	 * @param entity
	 */
	public void delete(String entity) {
		db.delete(entity, null, null);
	}

	/**
	 * 清空数据库表。
	 * 
	 * @param entity
	 * @param selection
	 */
	public void delete(String entity, String selection) {
		db.delete(entity, selection, null);
	}

	public void drop(String[] entity) {
		db.execSQL("DROP TABLE IF EXISTS diary");
	}

	/**
	 * @return the db
	 */
	public SQLiteDatabase getDb() {
		return db;
	}
	
	/**
	 * Add a data 
	 * @param entity  
	 * @return
	 */
	public long addDataBase(T entity) {
		SQLiteDatabase sqLiteDatabase  = this.open().getDb();
		ContentValues cValues = new ContentValues();
		try {
			Field[] fs = entity.getClass().getDeclaredFields();
			for (int i = 0; i < fs.length; i++) {
				Field field = fs[i];
				field.setAccessible(true);
				Object val = null; //
				if (field.get(entity) != null)
					val = field.get(entity);
				if (val != null && !val.equals("")
						&& !field.getName().endsWith("Id")) {
					
					String type = field.getType().getName();// 得到此属性的类型
					if (type.contains("String")) {
						cValues.put(field.getName(), String.valueOf(val));
					} else if (type.contains("Integer") || type.contains("int")) {
						cValues.put(field.getName(), Integer.parseInt(String.valueOf(val)));
					}else if (type.contains("long") || type.contains("Long")){
						cValues.put(field.getName(), Long.parseLong(String.valueOf(val)));
					}else if (type.contains("float") || type.contains("Float")){
						cValues.put(field.getName(), Float.parseFloat(String.valueOf(val)));
					}else {
						cValues.put(field.getName(), String.valueOf(val));
					}
				}
			}
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		long lg = sqLiteDatabase.insert(entity.getClass().getSimpleName(), null,
				cValues);// 
		Log.e("SQL", lg+"");
		sqLiteDatabase.close();
		return lg;
	}
	
	/**
	 * 
	 * According to the entity object delete data
	 * 
	 * @param entity
	 * @return
	 */
	public int deleteByOne(T entity) {
		int result = -1;
		db = open().getDb();
		try {
			Field[] fs = entity.getClass().getDeclaredFields();
			for (int i = 0; i < fs.length; i++) {
				Field f = fs[i];
				f.setAccessible(true); // 设置些属性是可以访问�?
				String ss = fs[i].getName();
				int val = 0;
				if (ss.endsWith("Id")) {
					if (f.get(entity) != null)
						val = (Integer) f.get(entity);
					if (val != 0) {
						String whereClause = ss + "=?";// 删除的条�?
						String[] whereArgs = { val + "" };// 删除的条件参�?
						result = db.delete(entity.getClass().getSimpleName(),
								whereClause, whereArgs);// 执行删除
						db.close();
						break;
					}
				}
			}
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return result;
	}
	
	
	/**
	 * According to the Class(Table Name) object query all the data
	 * 
	 * @param entity
	 * @return
	 */
	public List<T> findAll(Class<T> entity) {
		List<T> tables = new ArrayList<T>();
		db = open().getDb();
		try {
			String sqlString = "select * from " + entity.getSimpleName();
			Cursor c = db.rawQuery(sqlString, null);
			// Cursor c = database.query(cla.getSimpleName(), null, null, null,
			// null, null, null);// 查询并获得游�?
			tables = getList(c,entity);
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		return tables;
	}

	public List<T> getList(Cursor c,Class<T> entity) throws InstantiationException,
			IllegalAccessException {
		// TODO Auto-generated method stub
		List<T> tables = new ArrayList<T>();
		T taT = null;
		Field[] fs = entity.getDeclaredFields();
		while (c.moveToNext()) {
			taT = (T) entity.newInstance();
			for (int i = 0; i < fs.length; i++) {
				Field field = fs[i];
				field.setAccessible(true);
				String type = field.getType().getName();// 得到此属性的类型
				if (type.contains("String")) {
					String nameString = field.getName();
					String valueString = c.getString(c
							.getColumnIndex(nameString));
					field.set(taT, valueString);
				} else if (type.contains("Integer") || type.contains("int")) {
					String nameString = field.getName();
					int valueString = c.getInt(c.getColumnIndex(nameString));
					field.set(taT, valueString);
				}else if (type.contains("long") || type.contains("Long")){
					String nameString = field.getName();
					long valueString = c.getLong(c.getColumnIndex(nameString));
					field.set(taT, valueString);
					
				}else if (type.contains("float") || type.contains("Float")){
					String nameString = field.getName();
					float valueString = c.getFloat(c.getColumnIndex(nameString));
					field.set(taT, valueString);
				}else {
					String nameString = field.getName();
					String valueString = c.getString(c
							.getColumnIndex(nameString));
					field.set(taT, valueString);

				}
			}
			tables.add(taT);
		}
		return tables;
	}
	
}
 
package com.example.ndkreadfpga.db;
import java.util.ArrayList;
import java.util.List;
import android.R.integer;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import com.example.ndkreadfpga.entity.DataEntity;
import com.example.ndkreadfpga.entity.OriginalData;
import com.example.ndkreadfpga.entity.ThrustData;
public class ThrustDBHelper extends BaseDBHelper<ThrustData> {
 public static final String TABLE_NAME = ThrustData.class.getSimpleName();
 private SQLiteDatabase sqLiteDatabase;
 public ThrustDBHelper(Context ctx) {
  super(ctx,TABLE_NAME);
  // TODO Auto-generated constructor stub
  //重新创建数据库 不然第二个表创建不出来
 }
 
 @Override
 public String createTab() {
  // TODO Auto-generated method stub
  String sqlString = "create table " + TABLE_NAME
    + "(thrustId  integer primary key autoincrement , "
    + "steelNum  varchar(10), " 
    + "fromNum  varchar(10) , " 
    + "toNum  varchar(10) , "
    + "thrust integer,"
    + "isUnusual integer,"
    + "date  long);";
  return sqlString;
 }
 /**
  * 根据钢轨编号查数据
  * 
  * @param steelNum
  *          
  * @throws IllegalAccessException
  * @throws InstantiationException
  */
 public List<ThrustData> selectBySteelNum(String steelNum){
  // TODO Auto-generated method stub
  try {
   sqLiteDatabase = open().getDb();
   // select * from person order by id
   String sql = "select * from " + TABLE_NAME + " where steelNum = ?";
   String[] selectionArgs = { steelNum };
   Cursor cursor = sqLiteDatabase.rawQuery(sql, selectionArgs);
   return getList(cursor, ThrustData.class);
   
  } catch (Exception e) {
   // TODO: handle exception
   e.printStackTrace();
  }
  return new ArrayList<ThrustData>();
 }
 
 
 /**
  * 根据时间查数据
  * 
  * @param steelNum
  *          
  * @throws IllegalAccessException
  * @throws InstantiationException
  */
 public List<ThrustData> selectBySteelNumByDate(String date){
  // TODO Auto-generated method stub
  try {
   sqLiteDatabase = open().getDb();
   // select * from person order by id
   String sql = "select * from " + TABLE_NAME + " where date = ?";
   String[] selectionArgs = { date };
   Cursor cursor = sqLiteDatabase.rawQuery(sql, selectionArgs);
   return getList(cursor, ThrustData.class);
   
  } catch (Exception e) {
   // TODO: handle exception
   e.printStackTrace();
  }
  return new ArrayList<ThrustData>();
 }
 
 /**
  * 根据钢轨编号和日期查数据
  * @param steelNum
  * @param date
  * @return
  */
 
 public List<ThrustData> selectBySteelNum(String steelNum,String date){
  // TODO Auto-generated method stub
  try {
   sqLiteDatabase = open().getDb();
   // select * from person order by id
   String sql = "select * from " + TABLE_NAME + " where steelNum = ? and date = ?";
   String[] selectionArgs = { steelNum ,date};
   Cursor cursor = sqLiteDatabase.rawQuery(sql, selectionArgs);
   return getList(cursor, ThrustData.class);
  } catch (Exception e) {
   // TODO: handle exception
   e.printStackTrace();
  }
  return new ArrayList<ThrustData>();
 }
 
 /**
  * 根据钢轨异常和日期查数据
  * @param steelNum
  * @param date
  * @return
  */
 
 public List<ThrustData> selectBySteelNumByIsUnusual(String isUnusual,String date){
  // TODO Auto-generated method stub
  try {
   sqLiteDatabase = open().getDb();
   // select * from person order by id
   String sql = "select * from " + TABLE_NAME + " where isUnusual = ? and date = ?";
   String[] selectionArgs = { isUnusual ,date};
   Cursor cursor = sqLiteDatabase.rawQuery(sql, selectionArgs);
   return getList(cursor, ThrustData.class);
  } catch (Exception e) {
   // TODO: handle exception
   e.printStackTrace();
  }
  return new ArrayList<ThrustData>();
 }
 
 
 /**
  * 根据钢轨编号，是否异常 和日期查数据 
  * @param steelNum
  * @param date
  * @return
  */
 
 public List<ThrustData> selectBySteelNum(String steelNum,String date,String isUnusual){
  // TODO Auto-generated method stub
  try {
   sqLiteDatabase = open().getDb();
   // select * from person order by id
   String sql = "select * from " + TABLE_NAME + " where steelNum = ? and date = ? and isUnusual = ?";
   String[] selectionArgs = { steelNum ,date,isUnusual+""};
   Cursor cursor = sqLiteDatabase.rawQuery(sql, selectionArgs);
   return getList(cursor, ThrustData.class);
  } catch (Exception e) {
   // TODO: handle exception
   e.printStackTrace();
  }
  return new ArrayList<ThrustData>();
 }
 
}

 
package com.example.ndkreadfpga.entity;

public class ThrustData {
 /**
  * 
  */
 public ThrustData() {
  // TODO Auto-generated constructor stub
 }
 public int thrustId;
 public String steelNum = "1"; //轨道编号
 public String fromNum = "1"; // 起点
 public String toNum = "2"; // 终点
 public int thrust = 3; // 受力值
 public int isUnusual = 0; // 师傅异常
 public long date = 16000000; // 时间
 public ThrustData(String steelNum,String fromNum,String toNum,int thrust,int isUnusual,long date) {
  // TODO Auto-generated constructor stub
  this.steelNum = steelNum;
  this.fromNum = fromNum;
  this.toNum = toNum;
  this.thrust = thrust;
  this.isUnusual = isUnusual;
  this.date =date;
 }
}
qq_15157651
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SQLiteOpenHelper对数据库进行版本管理
xiangrikui0109的博客
02-28 5412
我们在编写数据库应用软件时，需要考虑这样的问题： 在用户初次使用软件时创建出应用使用到的数据库表结构及添加一些初始化记录 在软件升级的时候，也需要对数据表结构进行更新。 SQLiteOpenHelper的抽象类，必须继承它才能使用，它是通过对数据库版本进行管理来实现前面提出的需求。为了实现对数据库版本进行管理，SQLiteOpenHelper类提供了两个重要的方法，分别是onCreate(SQ
SQLiteOpenHelper 类
blue的博客
06-27 482
SQLiteOpenHelper 是Android提供的一个管理数据库的工具类,可以用于管理数据库创建和版本更新.一般的用法是创建 SQLiteOpenHelper 的子类,并扩展它的onCreate(SQLiteDatabase db)方法和 onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)方法. 常用方法如下: getR
Android学习 | 08.SQLiteOpenHelper
M_Nobody的博客
08-01 4717
SQLiteOpenHelper是android系统提供的用于创建及操作数据库的工具类。该类中提供了创建、升级、降级时的回调方法,对应onCreate(),onUpgrade(),onDowngrade()。在使用时可以根据app功能进行覆写相应的方法，从而实现正确的存储数据...
android 学习笔记——SQLiteOpenHelper类的简单使用
小王的博客
11-29 1298
本文记录SQLiteOpenHelper类的简单使用，函数说明都加在注释里，如有错误的地方请及时指正。ContentValues类似于map,相对于map，它提供了存取数据对应的put（String key，xxx Value）和getAsXxx(String key)方法，key为字段名称，value为字段值，Xxx指的是各种常用的数据类型，如：String、integet等。
基于SQLiteOpenHelper封装的SQLite操作jar包
05-09
在原有的SQLiteOpenHelper基础上进行的封装，更加方便使用，常用的增删改查方法无需在重新覆写，内文档说明如何使用，只需阅读一次终生受益。
SQLite数据库存储数据使用
sinat_35073873的博客
11-05 1166
package com.example.tyxiong.myapplication;import android.app.Activity; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteException; imp
android 项目利用SQLiteOpenHelper创建数据库文件Demo
10-17
android项目添加数据库，利用SQLiteOpenHelper创建数据库文件的Demo
Android　SqliteOpenHelper数据库的基本使用
11-19
数据库的使用,包含增删改查,是使用android 内置的数据库助手类实现的
SQLiteOpenHelper数据库
11-16
SQLiteOpenHelper数据库的简单使用，仅供学习，适合初学者
利用SQLiteOpenHelper实现SQLite数据的写入和查询
09-16
利用SQLiteOpenHelper实现SQLite数据的写入和查询，本例以输入学生信息：学号、姓名、年龄、性别，可以保存到数据库，可以输入学号，查询学生信息，并显示在listview。
android studio使用SQLiteOpenHelper()建立数据库的方法
08-24
主要介绍了android studio使用SQLiteOpenHelper()建立数据库的方法，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
SQLiteOpenHelper类
紫风幻雪的博客
08-29 3561
一、SQLiteOpenHelper类：SQLiteDatabase 三、封装MySQLiteOpenHelper 类：
SqlLite的工具类SQLiteOpenHelper
weixin_34067980的博客
08-06 135
2019独角兽企业重金招聘Python工程师标准>>> ...
SQLiteDatabase、SQLiteOpenHelper以及封装
苦心人天不负
05-13 1308
这几天学习Android，对UI和数据库有了一些基本的认识，所以尝试的做了一个记事本。 记事本的思路是一个ListView用于展示日记，一个编辑页面用于添加、修改、删除一条日记信息。 首先是SQLiteOpenHelper类 package com.frozencloud.mynote.date; import android.content.Context; import android
android sqlite 工具类,SqlLite的工具类SQLiteOpenHelper
weixin_36211244的博客
05-25 394
packagecom.zhxjz.map.util;importjava.util.List;importorg.apache.commons.lang.math.NumberUtils;importandroid.content.Context;importandroid.database.Cursor;importandroid.database.sqlite.SQLiteData...
AndroidSqlite增删改查的基本使用带工具类
梦想起于用户使用量
03-30 5097
文章参考地：http://blog.csdn.net/codeeer/article/details/30237597/ 一.SQLite的介绍 1.SQLite简介 SQLite是一款轻型的数据库，是遵守ACID的关联式数据库管理系统，它的设计目标是嵌入  式的，而且目前已经在很多嵌入式产品中使用了它，它占用资源非常的低，在嵌入式设备中，可能只需要几百K的内存就够了。它能够支持 W
最常用的设计模式之单例模式---安卓数据库为例
weixin_30315905的博客
08-05 96
今天我们来谈谈设计模式中的单例模式，单例模式也叫单件模式。他的意思是： 一个类只有一个实例。 如果你初次听到这个模式，可能不太理解这个模式到底有什么用。这里举一些例子给大家。 比如我有一个工具箱窗体 每点击一次按钮 都会实例化一个工具箱，用户点击多次，就会弹出多次工具箱窗口，所以在这里，我们就需要工具箱这个类只有一个实例，就要用到我们的单例模式了。 今天就以安卓里sqlite的访问操...
SQLiteOpenHelper数据库工具包
rimuweinuan_的博客
02-17 292
CreateTable.java package com.example.util; import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import android.database.sql
android 数据库工具类
最新发布
09-01
通过使用数据库工具类，我们可以简化对数据库的操作和管理。它提供了一种封装性很强、易用且可靠的方式来处理数据库的相关操作，使我们的开发工作更加高效。同时，数据库工具类还提供了数据的增删改查等基本操作，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值