Android-SQLiteOpenHelper里增删改查

Posted 2021-01-28 原创Android 努力学习 专一安卓 持之以恒

为什么要写一篇，android-SQLiteOpenHelper里增删改查，的文章呢；

　　因为之前的方式是：mysqliteOpenHelper（只负责 生成打开据库/生成打开表/升级表），在其他端：完成此数据库表的增删改查逻辑处理，这样代码有些分散

现在 MySQLiteOpenHelper（负责 生成打开据库 / 生成打开表 / 升级表 / 完成此数据库表的增删改查逻辑处理 / 还有其他表处理功能增加等等），这一个类全包了

 

---

 

 

MySQLiteOpenHelperStudent

注意事项：继承SQLiteOpenHelper抽象类 重写的创表方法，此SQLiteDatabase db 不能关闭

  1 package liudeli.datastorage.db;
  2 
  3 import android.content.ContentValues;
  4 import android.content.Context;
  5 import android.database.Cursor;
  6 import android.database.sqlite.SQLiteDatabase;
  7 import android.database.sqlite.SQLiteOpenHelper;
  8 import android.util.Log;
  9 
 10 import java.util.List;
 11 
 12 import liudeli.datastorage.entity.Student;
 13 
 14 /**
 15  *  数据库表管理
 16  *  MySQLiteOpenHelperStudent
 17  *  （负责 生成打开据库 / 生成打开表 / 升级表 /
 18  *        完成此数据库表的增删改查逻辑处理
 19  *       / 还有其他表处理功能增加等等）
 20  */
 21 public class MySQLiteOpenHelperStudent extends SQLiteOpenHelper {
 22 
 23     private final static String TAG = MySQLiteOpenHelperStudent.class.getSimpleName();
 24 
 25     /**
 26      * 数据库名称
 27      */
 28     private final static String DB_NAME = "student_info_manager.db";
 29 
 30     /**
 31      * 表名
 32      */
 33     private static final String TABLE_NAME = "studentTable";
 34 
 35     /**
 36      * 定义单例模式，可以被多次地方多次调用
 37      */
 38     private static MySQLiteOpenHelperStudent mySQLiteOpenHelperStudent;
 39 
 40     public static MySQLiteOpenHelperStudent getInstance(Context context) {
 41         if (null == mySQLiteOpenHelperStudent) {
 42             synchronized (MySQLiteOpenHelperStudent.class) {
 43                 if (null == mySQLiteOpenHelperStudent) {
 44                     mySQLiteOpenHelperStudent = new MySQLiteOpenHelperStudent(context, DB_NAME, null, 1);
 45                 }
 46             }
 47         }
 48         return mySQLiteOpenHelperStudent;
 49     }
 50 
 51     private MySQLiteOpenHelperStudent(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
 52         super(context, name, factory, version);
 53     }
 54 
 55 
 56     /**
 57      * 创表方法，注意：⚠️ 传递进来的 SQLiteDatabase database 不能关闭
 58      * @param database
 59      */
 60     private void createTable(SQLiteDatabase database) {
 61         String createTableSQL =  "CREATE TABLE IF NOT EXISTS " + TABLE_NAME + " (ID INTEGER PRIMARY KEY, "
 62                 + "name VARCHAR, "
 63                 + "age INTEGER, "
 64                 + "hobby  VARCHAR);";
 65         try {
 66             database.execSQL(createTableSQL);
 67         } catch (Exception e) {
 68             e.printStackTrace();
 69             Log.e(TAG, TAG + "创表异常：" + e.toString());
 70         }
 71 
 72         /**
 73          * 注意：⚠️
 74          * 这里不能关闭database
 75          * 一旦关闭就会 Caused by: java.lang.IllegalStateException:
 76          *             attempt to re-open an already-closed object: SQLiteDatabase:
 77          * 为什么不能在这里关闭呢？
 78          * 答：因为这个database，是在 public void onCreate ->传递过来的
 79          */
 80         /*finally {
 81             if (null != database) {
 82                 database.close();
 83             }
 84         }*/
 85     }
 86 
 87     /**
 88      * 删除表，会把表给删除，慎用
 89      * drop 表
 90      */
 91     public void dropTable() {
 92         SQLiteDatabase database = getWritableDatabase();
 93         String dropSQL = "drop table if exists " + TABLE_NAME;
 94         try {
 95             database.execSQL(dropSQL);
 96         } catch (Exception e) {
 97             e.printStackTrace();
 98             Log.d(TAG, "drop异常：" + e.toString());
 99         } finally {
100             if (null != database) {
101                 database.close();
102             }
103         }
104     }
105 
106     /**
107      * 清除表的数据
108      */
109     public void cleanUpData() {
110 
111         // delete from TableName;  //清空数据
112 
113         SQLiteDatabase database = getWritableDatabase();
114         String cleanUpDataSQL = "delete from " + TABLE_NAME;
115         try {
116             database.execSQL(cleanUpDataSQL);
117         } catch (Exception e) {
118             e.printStackTrace();
119             Log.d(TAG, "清除表的数据异常：" + e.toString());
120         } finally {
121             if (null != database) {
122                 database.close();
123             }
124         }
125     }
126 
127     /**
128      * 插入多条数据
129      * @param students 传递Student集合
130      */
131     public void insertData(List<Student> students) {
132         SQLiteDatabase database = getWritableDatabase();
133         try {
134             for (Student student : students) {
135                 ContentValues contentValues = new ContentValues();
136                 contentValues.clear();
137                 contentValues.put("name", student.getName());
138                 contentValues.put("age", student.getName());
139                 contentValues.put("hobby", student.getHobby());
140                 database.insert(TABLE_NAME, "_id", contentValues);
141             }
142         } catch (Exception e) {
143             e.printStackTrace();
144             Log.e(TAG, "insert多条异常：" + e.toString());
145         } finally {
146             if (null != database) {
147                 database.close();
148             }
149         }
150     }
151 
152     /**
153      * 插入单条
154      * @param contentValues 传递ContentValues
155      */
156     public void insertData(ContentValues contentValues) {
157         SQLiteDatabase database = getWritableDatabase();
158         try {
159             database.insert(TABLE_NAME, "_id", contentValues);
160         } catch (Exception e) {
161             e.printStackTrace();
162             Log.e(TAG, "insert单条异常：" + e.toString());
163         } finally {
164             if (null != database) {
165                 database.close();
166             }
167         }
168     }
169 
170     /**
171      * 查询需要的列名
172      */
173     private String[] columns = new String[]{"name", "age", "hobby"};
174 
175     /**
176      * 查询第一条数据
177      * @return 返回Student实体
178      */
179     public Student selectData() {
180         SQLiteDatabase database = getReadableDatabase();
181         Cursor cursor = null;
182         Student student = null;
183         try {
184             cursor = database.query(TABLE_NAME, columns, null, null, null, null, null);
185             if (cursor.moveToFirst()) {
186                 String name = cursor.getString(cursor.getColumnIndex("name"));
187                 int age = cursor.getInt(cursor.getColumnIndex("age"));
188                 String hobby = cursor.getString(cursor.getColumnIndex("hobby"));
189 
190                 student = new Student(name, age, hobby);
191             }
192         } catch (Exception e) {
193             e.printStackTrace();
194             Log.e(TAG, "select异常：" + e.toString());
195         } finally {
196             if (null != database) {
197                 database.close();
198             }
199 
200             if (null != cursor) cursor.close();
201         }
202         return student;
203     }
204 
205     /**
206      * 判断第一条数据是否存在
207      * @return 存在返回true，否则返回false
208      */
209     public boolean isMoveToFirst() {
210         boolean result;
211         SQLiteDatabase database = getReadableDatabase();
212         Cursor cursor = database.query(TABLE_NAME,
213                 columns,
214                 null,
215                 null,
216                 null,
217                 null,
218                 null);
219         result = cursor.moveToFirst();
220         database.close();
221         cursor.close();
222         return result;
223     }
224 
225     /**
226      *    .........  还可以增加很多操作表相关的行为
227      */
228 
229     /**
230      * 继承SQLiteOpenHelper抽象类 重写的创表方法，此SQLiteDatabase db 不能关闭
231      * @param db
232      */
233     @Override
234     public void onCreate(SQLiteDatabase db) {
235         createTable(db);
236     }
237 
238     /**
239      * 继承SQLiteOpenHelper抽象类 重写的升级方法
240      * @param db
241      * @param oldVersion
242      * @param newVersion
243      */
244     @Override
245     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
246     }
247 }

 

继承SQLiteOpenHelper抽象类 重写的创表方法，此SQLiteDatabase db 不能关闭

/**
     * 创表方法，注意：⚠️ 传递进来的 SQLiteDatabase database 不能关闭
     * @param database
     */
    private void createTable(SQLiteDatabase database) {
        String createTableSQL =  "CREATE TABLE IF NOT EXISTS " + TABLE_NAME + " (ID INTEGER PRIMARY KEY, "
                + "name VARCHAR, "
                + "age INTEGER, "
                + "hobby  VARCHAR);";
        try {
            database.execSQL(createTableSQL);
        } catch (Exception e) {
            e.printStackTrace();
            Log.e(TAG, TAG + "创表异常：" + e.toString());
        }

        /**
         * 注意：⚠️
         * 这里不能关闭database
         * 一旦关闭就会 Caused by: java.lang.IllegalStateException:
         *             attempt to re-open an already-closed object: SQLiteDatabase:
         * 为什么不能在这里关闭呢？
         * 答：因为这个database，是在 public void onCreate ->传递过来的
         */
        /*finally {
            if (null != database) {
                database.close();
            }
        }*/
    }

一旦关闭，就会报以下错误：

Caused by: java.lang.IllegalStateException: attempt to re-open an already-closed object: SQLiteDatabase:

 

 

Student实体：

package liudeli.datastorage.entity;

public class Student {

    private String name;
    private int age;
    private String hobby;

    public Student() {
    }

    public Student(String name, int age, String hobby) {
        this.name = name;
        this.age = age;
        this.hobby = hobby;
    }

    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 String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name=\'" + name + \'\\\'\' +
                ", age=" + age +
                ", hobby=\'" + hobby + \'\\\'\' +
                \'}\';
    }
}

 

测试代码：

package liudeli.datastorage;

import android.app.Activity;
import android.content.ContentValues;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

import liudeli.datastorage.db.MySQLiteOpenHelperStudent;
import liudeli.datastorage.entity.Student;

public class MySQLiteActivity extends Activity {

    private MySQLiteOpenHelperStudent mySQLiteOpenHelperStudent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my_sqlite);

        mySQLiteOpenHelperStudent = MySQLiteOpenHelperStudent.getInstance(this);

        /**
         * 初始化数据
         */
        ContentValues contentValues = new ContentValues();
        contentValues.put("name", "刘刘" + System.currentTimeMillis());
        contentValues.put("age", 26);
        contentValues.put("hobby", "爱写博客" + System.currentTimeMillis());

        mySQLiteOpenHelperStudent.insertData(contentValues);
    }

    /**
     * 查询
     * @param view
     */
    public void query(View view) {
        Student student = mySQLiteOpenHelperStudent.selectData();
        if (student != null) {
            Log.d("sql", "student.toString:" + student.toString());
        }
    }

    /**
     * 是否有第一条数据
     * @param view
     */
    public void query1(View view) {
        Toast.makeText(this, mySQLiteOpenHelperStudent.isMoveToFirst() + "", Toast.LENGTH_LONG).show();
    }

    /**
     * drop表 删除表
     * @param view
     */
    public void  dropTable(View view) {
        mySQLiteOpenHelperStudent.dropTable();
    }

    /**
     * 插入很多数据
     * @param view
     */
    public void installMany(View view) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("李李", 11, "AAAAAAA"));
        students.add(new Student("李李22", 222, "BBBB"));
        students.add(new Student("李李33", 333, "CCC"));
        students.add(new Student("李李44", 444, "DDD"));
        mySQLiteOpenHelperStudent.insertData(students);
    }

    /**
     * 清除表数据
     * @param view
     */
    public void cleanUpData(View view) {
        mySQLiteOpenHelperStudent.cleanUpData();
    }
}

 

测试代码的布局：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="query"
        android:text="查询"
        android:layout_weight="0"
        />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="是否有第一条数据"
        android:onClick="query1"
        android:layout_weight="0"
        />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="drop表 删除表"
        android:onClick="dropTable"
        android:layout_weight="0"
        />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="插入很多数据"
        android:onClick="installMany"
        android:layout_weight="0"
        />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="cleanUpData"
        android:text="清除表数据"
        />

</LinearLayout>