一个封装类教你学会SQLite数据库

最新推荐文章于 2024-01-24 14:44:20 发布

凉幽

最新推荐文章于 2024-01-24 14:44:20 发布

阅读量385

点赞数

分类专栏： android 文章标签：数据库 sqlite 数据存储

android 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

目录(?)[+]

数据库操作类的命名一般以Dao为结尾，什么是Dao呢？

DAO(Data Access Object) 数据访问对象是第一个面向对象的数据库接口

数据实体类

public class Tree {
    private int id;
    private String name;
    private int age;
    private float price;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public Tree() {
    }

    public Tree(String name, int age, float price) {
        this.name = name;
        this.age = age;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Tree{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", price=" + price +
                '}';
    }
}
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

数据库操作封装类

public class TreeDBDao {

    private static final String DB_NAME = "tree.db";//数据库名称
    private static final String TABLE_NAME = "treeinfo";//数据表名称
    private static final int DB_VERSION = 1;//数据库版本

    //表的字段名
    private static String KEY_ID = "id";
    private static String KEY_NAME = "name";
    private static String KEY_AGE = "age";
    private static String KEY_PRICE = "price";

    private SQLiteDatabase mDatabase;
    private Context mContext;
    private TreeDBOpenHelper mDbOpenHelper;//数据库打开帮助类


    public TreeDBDao(Context context) {
        mContext = context;
    }

    //打开数据库
    public void openDataBase() {
        mDbOpenHelper = new TreeDBOpenHelper(mContext, DB_NAME, null, DB_VERSION);
        try {
            mDatabase = mDbOpenHelper.getWritableDatabase();//获取可写数据库
        } catch (SQLException e) {
            mDatabase = mDbOpenHelper.getReadableDatabase();//获取只读数据库
        }
    }

    //关闭数据库
    public void closeDataBase() {
        if (mDatabase != null) {
            mDatabase.close();
        }
    }

    //插入一条数据
    public long insertData(Tree tree) {
        ContentValues values = new ContentValues();
        values.put(KEY_NAME, tree.getName());
        values.put(KEY_AGE, tree.getAge());
        values.put(KEY_PRICE, tree.getPrice());
        return mDatabase.insert(TABLE_NAME, null, values);
    }

    //删除一条数据
    public long deleteData(long id) {
        return mDatabase.delete(TABLE_NAME, KEY_ID + "=" + id, null);
    }

    //删除所有数据
    public long deleteAllData() {
        return mDatabase.delete(TABLE_NAME, null, null);
    }

    //更新一条数据
    public long updateData(long id, Tree tree) {
        ContentValues values = new ContentValues();
        values.put(KEY_NAME, tree.getName());
        values.put(KEY_AGE, tree.getAge());
        values.put(KEY_PRICE, tree.getPrice());
        return mDatabase.update(TABLE_NAME, values, KEY_ID + "=" + id, null);
    }

    //查询一条数据
    public List<Tree> queryData(long id) {
        Cursor results = mDatabase.query(TABLE_NAME, new String[]{KEY_ID, KEY_NAME, KEY_AGE, KEY_PRICE},
                KEY_ID + "=" + id, null, null, null, null);
        return convertToTree(results);
    }

    //查询所有数据
    public List<Tree> queryDataList() {
        Cursor results = mDatabase.query(TABLE_NAME, new String[]{KEY_ID, KEY_NAME, KEY_AGE, KEY_PRICE},
                null, null, null, null, null);
        return convertToTree(results);

    }

    private List<Tree> convertToTree(Cursor cursor) {
        int resultCounts = cursor.getCount();
        if (resultCounts == 0 || !cursor.moveToFirst()) {
            return null;
        }
        List<Tree> mTreeList = new ArrayList<>();
        for (int i = 0; i < resultCounts; i++) {
            Tree tree = new Tree();
            tree.setId(cursor.getInt(0));
            tree.setName(cursor.getString(cursor.getColumnIndex(KEY_NAME)));
            tree.setAge(cursor.getInt(cursor.getColumnIndex(KEY_AGE)));
            tree.setPrice(cursor.getFloat(cursor.getColumnIndex(KEY_PRICE)));
            mTreeList.add(tree);
            cursor.moveToNext();
        }
        return mTreeList;
    }

    /**
     * 数据表打开帮助类
     */
    private static class TreeDBOpenHelper extends SQLiteOpenHelper {

        public TreeDBOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
            super(context, name, factory, version);
        }

        @Override
        public void onCreate(SQLiteDatabase db) {
            final String sqlStr = "create table if not exists " + TABLE_NAME + " (" + KEY_ID + " integer primary key autoincrement, " + KEY_NAME + " text not null, " + KEY_AGE + " integer," + KEY_PRICE + " float);";
            db.execSQL(sqlStr);
        }

        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            final String sqlStr = "DROP TABLE IF EXISTS " + TABLE_NAME;
            db.execSQL(sqlStr);
            onCreate(db);
        }
    }
}
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

使用方法

TreeDBDao mDBDao = new TreeDBDao(MainActivity.this);//实例化对象
mDBDao.openDataBase();//打开数据库

//增删改查操作

mDBDao.insertData(new Tree("GreenTree", 12, 2321.5f));//增加数据
mDBDao.deleteData(1);//删除数据
mDBDao.updateData(1, new Tree("RedTree", 20, 5200f));//更新数据
mDBDao.deleteAllData();//删除所有数据

List<Tree> list = mDBDao.queryData(1);//查询id为1的数据
Log.v("-->", list.get(0).toString());

List<Tree> lists = mDBDao.queryDataList();//查询所有数据
for (Tree tree : lists) {
   Log.v("-->", tree.toString());
}


  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
  
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

存储结果

这里写图片描述

原创

凉幽

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
一个封装类教你学会SQLite数据库

版权声明：本文为博主原创文章，未经博主允许不得转载。目录(?)[+]数据库操作类的命名一般以Dao为结尾，什么是Dao呢？DAO(Data Access Object) 数据访问对象是第一个面向对象的数据库接口数据实体类public class Tree { private int id; private String name; pri
复制链接

扫一扫