使用原生的操作方法
首先实现一个databaseopenhelper继承sqliteopenhelper
public class databaseopenhelper extends sqliteopenhelper {
//数据库版本号
private static int init_version = 1;
private static final string tag = "databaseopenhelper";
/**
*
* @param context 上下文
* @param name 数据库名称
* @param factory
* @param version 当前数据库的版本，值必须是整数并且是递增的状态
*/
public databaseopenhelper(context context, string name, sqlitedatabase.cursorfactory factory, int version) {
super(context, name, factory, version);
}
public databaseopenhelper(context context,string name,int version){
this(context,name,null,version);
}
public databaseopenhelper(context context,string name){
this(context,name,init_version);
}
@override
public void oncreate(sqlitedatabase db) {
log.e(tag,"创建数据库表");
//创建了数据库并创建一个叫records的表
//sqlite数据创建支持的数据类型： 整型数据，字符串类型，日期类型，二进制的数据类型
string sql = "create table user(id integer primary key autoincrement,name varchar(20) not null);";
//execsql用于执行sql语句
//完成数据库的创建
db.execsql(sql);
//数据库实际上是没有被创建或者打开的，直到getwritabledatabase()
// 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
}
@override
public void onupgrade(sqlitedatabase db, int oldversion, int newversion) {
log.e(tag,"更新数据库");
}
}
操作数据库各种简单的方法
/**
* 创建数据库
*/
private void createdb() {
// 创建sqliteopenhelper子类对象
databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db");
//数据库实际上是没有被创建或者打开的，直到getwritabledatabase()
// 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
sqlitedatabase database = helper.getwritabledatabase();
}
/**
* 更新数据库
*/
private void upgradedb() {
databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
sqlitedatabase database = helper.getwritabledatabase();
}
/**
* 插入数据
*/
private void insertdb() {
log.e(tag, "插入数据");
// 创建sqliteopenhelper子类对象
databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
//数据库实际上是没有被创建或者打开的，直到getwritabledatabase()
// 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
sqlitedatabase database = helper.getwritabledatabase();
// 创建contentvalues对象
contentvalues values = new contentvalues();
// 向该对象中插入键值对
values.put("id", 1);
values.put("name", "唐嫣");
// 调用insert()方法将数据插入到数据库当中
database.insert("user", null, values);
//使用sql插入数据
/*string sql = "insert into user(id,name) values(1,'杨幂')";
database.execsql(sql);*/
//关闭数据库
database.close();
}
/**
* 更新数据
*/
private void updatedb() {
log.e(tag, "更新数据");
// 创建sqliteopenhelper子类对象
databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
//数据库实际上是没有被创建或者打开的，直到getwritabledatabase()
// 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
sqlitedatabase database = helper.getwritabledatabase();
// 创建一个contentvalues对象
contentvalues values = new contentvalues();
values.put("name","刘诗诗");
// 调用update方法修改数据库
database.update("user",values,"id=?",new string[]{"1"});
/*string sql = "update user set name='刘亦菲' where id=1";
database.execsql(sql);*/
database.close();
}
/**
* 查询数据
*/
private void selectdb() {
log.e(tag, "查询数据");
// 创建sqliteopenhelper子类对象
databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
//数据库实际上是没有被创建或者打开的，直到getwritabledatabase()
// 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
sqlitedatabase database = helper.getwritabledatabase();
// 调用sqlitedatabase对象的query方法进行查询
// 返回一个cursor对象：由数据库查询返回的结果集对象
cursor cursor = database.query("user", new string[]{"id", "name"}, "id=?", new string[]{"1"}, null, null, null);
stringbuilder builder = new stringbuilder();
//将光标移动到下一行，从而判断该结果集是否还有下一条数据
//如果有则返回true，没有则返回false
while (cursor.movetonext()) {
string id = cursor.getstring(cursor.getcolumnindex("id"));
string name = cursor.getstring(cursor.getcolumnindex("name"));
builder.append("id:" id).append("==>name:" name).append("\n");
}
tvcontent.settext(builder.tostring());
database.close();
}
/**
* 删除数据
*/
private void delete() {
log.e(tag, "删除数据");
// 创建sqliteopenhelper子类对象
databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
//数据库实际上是没有被创建或者打开的，直到getwritabledatabase()
// 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
sqlitedatabase database = helper.getwritabledatabase();
//删除数据
database.delete("user","id=?",new string[]{"1"});
/*string sql = "delete from user where id = 1";
database.execsql(sql);*/
database.close();
}
/**
* 删除数据库
*/
private void deletedb() {
log.e(tag, "删除数据库");
// 创建sqliteopenhelper子类对象
databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
//数据库实际上是没有被创建或者打开的，直到getwritabledatabase()
// 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
sqlitedatabase database = helper.getwritabledatabase();
//删除数据库
boolean detedb = deletedatabase("test_db");
tvcontent.settext("是否被删除:" detedb);
}
使用greendao操作数据库
配置
1、在你使用的module(一般不修改就是app)的build.gradle中导入greendao的依赖
//greendao的依赖 compile 'org.greenrobot:greendao:3.2.2'
2、然后还是在你所使用的module(一般不修改就是app)的build.gradle中配置
在最顶部加上
//使用greendao
apply plugin: 'org.greenrobot.greendao'
//然后在如下文件中配置
android {
//greendao配置
greendao {
//版本号，升级是可配置
schemaversion 1
daopackage '此处配置greendao自动生成文件的包路径'
targetgendir 'src/main/java'
}
}
3、然后在你的project的build.gradle中配置
//greendao3.0的依赖 classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'
4、然后在application中配置，还有其他的配置方式
public class practiceapplication extends application {
private static daosession daosession;
@override
public void oncreate() {
super.oncreate();
//配置数据库
setupdatabase();
}
/**
* 配置数据库
*/
private void setupdatabase() {
//创建数据库
daomaster.devopenhelper helper = new daomaster.devopenhelper(getapplicationcontext(),"test_shop.dp",null);
//获取可读可写数据库
sqlitedatabase database = helper.getwritabledatabase();
//获取数据库对象
daomaster daomaster = new daomaster(database);
//获取dao对象管理者
daosession = daomaster.newsession();
}
public static daosession getdaoinstance(){
return daosession;
}
}
上面配置已经完成，接下来我们就来使用
/**
* 添加数据，如果有重复就覆盖
*/
private void insertdata() {
shop shop = new shop(1l,"苹果","5",500,"www.img.com","www.baidu.com",shop.type_cart);
practiceapplication.getdaoinstance().getshopdao().insertorreplace(shop);
}
/**
* 删除数据
*/
private void deletedata() {
practiceapplication.getdaoinstance().getshopdao().deletebykey(1l);
}
/**
* 修改数据
*/
private void updatedata() {
shop shop = new shop(1l,"橘子","5",500,"www.img.com","www.baidu.com",shop.type_cart);
practiceapplication.getdaoinstance().getshopdao().update(shop);
}
/**
* 查询类型为shop.type_cart的数据
*/
private void querydata() {
list list = practiceapplication.getdaoinstance().getshopdao().querybuilder().where(shopdao.properties.type.eq(shop.type_cart)).list();
stringbuilder builder = new stringbuilder();
for (shop shop : list) {
builder.append(shop.getid() "\n")
.append(shop.getname() "\n")
.append(shop.getprice() "\n")
.append(shop.getsellnum() "\n")
.append(shop.getimg "\n")
.append(shop.getaddress() "\n")
.append(shop.gettype() "\n");
}
tvcontent.settext(builder.tostring());
}
/**
* 查询所有数据
*/
private void queryall() {
list list = practiceapplication.getdaoinstance().getshopdao().loadall();
stringbuilder builder = new stringbuilder();
for (shop shop : list) {
builder.append(shop.getid() "\n")
.append(shop.getname() "\n")
.append(shop.getprice() "\n")
.append(shop.getsellnum() "\n")
.append(shop.getimg "\n")
.append(shop.getaddress() "\n")
.append(shop.gettype() "\n");
}
tvcontent.settext(builder.tostring());
}
还可以如下写法，就是第四步不配置,使用的时候才来创建数据库，但是我觉得最好按照上面的步骤来，
创建一个数据库管理类dbmanager
public class dbmanager {
private static final string db_name = "test_qmui";
private context context;
private daomaster.devopenhelper helper;
private static dbmanager dbmanager;
private dbmanager(context context){
this.context = context;
helper = new daomaster.devopenhelper(context,db_name,null);
}
/**
* 创建dbmanager
* @param context
* @return
*/
public static dbmanager getinstance(context context) {
if (null == dbmanager) {
synchronized (dbmanager.class) {
return new dbmanager(context);
}
}
return dbmanager;
}
/**
* 获取数据库的操作类
* @return
*/
public daosession getwritedaosession(){
if(null == helper){
//创建数据库
helper = new daomaster.devopenhelper(context,db_name,null);
}
//获取可读可写数据库
sqlitedatabase database = helper.getwritabledatabase();
//获取数据库对象
daomaster daomaster = new daomaster(database);
return daomaster.newsession();
}
/**
* 获取数据库的操作类
* @return
*/
public daosession getreaddaosession(){
if(null == helper){
helper = new daomaster.devopenhelper(context,db_name,null);
}
//获取可读数据库
sqlitedatabase database = helper.getreadabledatabase();
//获取数据库对象
daomaster daomaster = new daomaster(database);
//获取dao对象管理者
return daomaster.newsession();
}
}
操作数据库
public class handleuserdao {
private context context;
public handleuserdao(context context){
this.context = context;
}
/**
* 插入数据
* @param user
*/
public void insert(user user){
userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
userdao.insert(user);
}
/**
* 查询所有数据
* @return
*/
public list querylist(){
userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
return userdao.loadall();
}
/**
* 根据条件查询
* @param username
* @return
*/
public list querylist(string username){
userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
return userdao.querybuilder().where(userdao.properties.username.gt(username))
.orderasc(userdao.properties.username).build().list();
}
/**
* 删除所有数据
*/
public void deleteall(){
userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
userdao.deleteall();
}
/**
* 删除指定数据
* @param username
*/
public void delete(string username){
userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
user user = userdao.querybuilder().where(userdao.properties.username.eq(username)).build().unique();
if(null != user){
userdao.deletebykey(user.getid());
}
}
/**
* 更新所有数据
* @param user
*/
public void update(user user){
userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
userdao.update(user);
}
}
