Introducción de esta sección:

En esta sección continuamos aprendiendo la tercera forma de almacenamiento y acceso de datos en Android: la base de datos SQLite. A diferencia de otras bases de datos SQL, no necesitamos instalar un software de base de datos adicional en el teléfono; el sistema Android ya integra esta base de datos. No necesitamos, como con otros software de bases de datos (Oracle, MSSQL, MySql, etc.), instalarlo, completar la configuración correspondiente, ni cambiar puertos. Eso es todo por la introducción; a continuación aprenderemos sobre esto.


1. Conceptos básicos

1) ¿Qué es SQLite? ¿Por qué usar SQLite? ¿Cuáles son las características de SQLite?

Respuesta: A continuación, deja que el cerdito te lo explique con calma.

① SQLite es una base de datos relacional ligera, con velocidad de cálculo rápida y bajo consumo de recursos, muy adecuada para dispositivos móviles. No solo admite la sintaxis SQL estándar, sino que también sigue el principio ACID (transacciones de base de datos). No requiere cuenta y es muy cómoda de usar.

② Anteriormente aprendimos a usar archivos y SharedPreference para guardar datos, pero en muchos casos los archivos no son necesariamente efectivos, como cuando hay acceso concurrente de múltiples hilos; la aplicación debe manejar estructuras de datos complejas que pueden cambiar, etc. Por ejemplo, ¡depositar y retirar dinero en un banco! Usar los dos primeros resultaría muy limitado o tedioso. La aparición de las bases de datos puede resolver este problema, y Android nos proporciona un SQLite tan ligero, ¿por qué no usarlo?

③ SQLite admitecinco tipos de datos: NULL, INTEGER, REAL (números de punto flotante), TEXT (texto de cadena) y BLOB (objeto binario). Aunque solo hay cinco, otros tipos de datos como varchar, char, etc. también se pueden guardar; porque SQLite tiene la característica más importante:Puedes guardar datos de cualquier tipo en cualquier campo sin preocuparte por el tipo de dato declarado para el campo.cuál sea; por ejemplo, puedes guardar una cadena en un campo de tipo Integer. Por supuesto,excepto que los campos declarados como clave primaria INTEGER PRIMARY KEY solo pueden almacenar enteros de 64 bits.! Además, al analizar la sentencia CREATE TABLE, SQLite ignora la información de tipo que sigue al nombre del campo en la sentencia CREATE TABLE; por ejemplo, la siguiente sentencia ignorará la información de tipo del campo name:CREATE TABLE person (personid integer primary key autoincrement, name varchar(20))

Resumiendo las características:

SQLite mediantearchivose guarda la base de datos; un archivo es unabase de datos, la base de datos contiene múltiplestablas, las tablas tienen múltiplesregistros, cada registro está compuesto por múltiplescamposy cada campo tiene unValorvalor correspondiente, a cada valor podemos asignarle untipo, o no asignarle tipo (excepto la clave primaria)

PS: Ah, por cierto, el SQLite integrado en Android es de la versión SQLite 3~

2) Algunas clases relacionadas:

Jeje, al aprender algo nuevo, lo que menos nos gusta es encontrarnos con términos nuevos, ¿verdad? Primero hablemos de las tres clases que usamos al trabajar con bases de datos:

  • SQLiteOpenHelper: Es una clase abstracta. Heredamos de esta clase y luego sobrescribimos los métodos de creación y actualización de la base de datos. También podemos obtener una instancia de la base de datos a través del objeto de esta clase, o cerrar la base de datos.
  • SQLiteDatabase: Clase de acceso a la base de datos. Podemos usar objetos de esta clase para realizar operaciones de inserción, eliminación, modificación y consulta en la base de datos.
  • Cursor: Un cursor, algo similar al ResultSet de JDBC, ¡el conjunto de resultados! Se puede entender simplemente como un puntero que apunta a un registro concreto de la base de datos.

2. Uso de la clase SQLiteOpenHelper para crear la base de datos y la gestión de versiones

Para las aplicaciones que involucran bases de datos, no podemos crear manualmente el archivo de base de datos, por lo que debemos crear la tabla de la base de datos al iniciar la aplicación por primera vez. Y cuando nuestra aplicación se actualiza y necesita modificar la estructura de las tablas de la base de datos, entonces es necesario actualizar las tablas. Para estas dos operaciones, Android nos proporcionaSQLiteOpenHelperlos dos métodos,onCreate( )y onUpgrade() para implementar.

Análisis de los métodos:

  • onCreate(database): Genera la tabla de la base de datos cuando el software se usa por primera vez.
  • onUpgrade(database,oldVersion,newVersion): Se llama cuando cambia la versión de la base de datos. Generalmente, solo es necesario cambiar el número de versión al actualizar el software, y la versión de la base de datos está controlada por el programador. Supongamos que la versión actual de la base de datos es 1; debido a cambios en el negocio, se modifica la estructura de la tabla de la base de datos. En este momento, es necesario actualizar el software. Al actualizar el software, se espera actualizar la estructura de la tabla de la base de datos en el teléfono del usuario. Para lograr este objetivo, se puede cambiar la versión original de la base de datos a 2 o a cualquier otro número distinto de la versión anterior.

Ejemplo de código:

public class MyDBOpenHelper extends SQLiteOpenHelper {
    public MyDBOpenHelper(Context context, String name, CursorFactory factory,
            int version) {super(context, "my.db", null, 1); }
    @Override
    //数据库第一次创建时被调用
    public void onCreate(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE person(personid INTEGER PRIMARY KEY AUTOINCREMENT,name VARCHAR(20))");
        
    }
    //软件版本号发生改变时调用
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("ALTER TABLE person ADD phone VARCHAR(12) NULL");
    }
}

Análisis del código:

En el código anterior, al iniciar la aplicación por primera vez, crearemos el archivo my.db y se ejecutará el método en onCreate(), creando una tabla Person, que tiene dos campos: la clave primaria personId y el campo name. Luego, si modificamos el número de versión de la base de datos, en el próximo inicio se llamará al método en onUpgrade(), que inserta un campo más en la tabla. Además, aquí se inserta un campo, por lo que los datos no se perderán. Si se reconstruye la tabla, todos los datos de la tabla se perderán. En la próxima sección enseñaremos cómo resolver este problema.

Resumen del proceso:

  • Step 1: Definir una clase personalizada que herede de la clase SQLiteOpenHelper.
  • Step 2: En el super del método constructor de esta clase, establecer el nombre de la base de datos a crear y el número de versión.
  • Step 3: Sobrescribir el método onCreate() para crear la estructura de la tabla.
  • Step 4: Sobrescribir el método onUpgrade() para definir las operaciones que se ejecutan cuando cambia el número de versión.

3. Cómo ver el archivo .db que generamos

Cuando llamamos a getWritableDatabase() del objeto MyDBOpenhelper mencionado anteriormente, se creará nuestro archivo de base de datos .db en el siguiente directorio:

Descubrimos que hay dos archivos de base de datos: el primero es la base de datos que creamos, y el segundo es un archivo de registro temporal generado para que la base de datos admita transacciones. Generalmente, su tamaño es de 0 bytes. Y enFile Explorerno podemos abrir el archivo; ni siquiera un .txt, y mucho menos un .db. Así que a continuación hay dos caminos para elegir:

  • 1. Exportarlo primero y luego usar la herramienta gráfica de SQLite para verlo.
  • 2. Configurar las variables de entorno de adb y luego usar adb shell para verlo (línea de comandos, ¡herramienta para impresionar!).

Bien, a continuación les mostraré los dos métodos anteriores. Elijan el que más les guste~~


Método 1: Usar la herramienta gráfica de SQLite para ver el archivo .db

Hay muchos programas de este tipo. El autor usa SQLite Expert Professional, por supuesto también puedes usar otras herramientas. Si alguien lo necesita, puede descargarlo:SQLiteExpert.zip

Exporta nuestro archivo .db al escritorio de la computadora, abre SQLiteExpert; la interfaz es la siguiente:

No me preguntes cómo usarlo. Después de importar el .db, ve jugando con él poco a poco. El uso es muy sencillo; si no lo entiendes, busca en Baidu~


En cuanto al método 2, originalmente quería probarlo, pero luego descubrí que el comando sqlite no se encontraba; después de intentarlo varias veces, lo dejé. Más adelante, cuando lo use, lo estudiaré en detalle. Si te interesa, puedes buscar el libro de Guo Lin "Primera línea de código: Android" y seguir el diagrama de flujo para probarlo. Aquí solo muestro una parte inicial; la parte de comandos la lees por tu cuenta.

Método 2: La línea de comandos adb shell, para lucirte y volar

1. Configurar las variables de entorno del SDK:

Haz clic derecho en "Mi PC" ——> Configuración avanzada del sistema -> Variables de entorno -> Nueva variable del sistema-> Copia la ruta de platform-tools del SDK. Por ejemplo, la del autor:C:\Software\Coding\android-sdks-as\platform-tools

Aceptar, luego busca la variable de entorno Path, edítala y al final agrega:%SDK_HOME%;

Luego abre la línea de comandos, escribe adb y, si aparecen un montón de cosas, significa que la configuración fue exitosa.

—————— Punto clave ——————: Antes de ejecutar los siguientes comandos de línea de comandos, puede haber varios casos para tu máquina de prueba: 1.Emulador nativoBueno, salta esta parte y continúa hacia abajo.Emulador GenymotionNo hay manera, Genymotion Shell no puede ejecutar los siguientes comandos.Dispositivo real (con root)Entonces abreFile ExplorerMira si hay algo en el directorio data/data/. ¿No hay nada?Administrador de archivos RE, luego otorga a REpermisos de Root, luego ve al directorio raíz:

Luego espera a que modifique los permisos lentamente. Cuando termine, abrimos nuevamente elFile Explorer, podemos ver:

¡Bien, ahora podemos ver lo que hay en data/data!——————————————————————

2. Entra en adb shell, luego escribe el siguiente comando para ir al directorio databases de nuestra app:

Luego ingresa los siguientes comandos en orden:

  • sqlite3my.db: abre el archivo de la base de datos
  • .tableVer qué tablas hay en la base de datos
  • .schema: ver la sentencia de creación de la tabla
  • .quit: salir de la edición de la base de datos
  • .exit: salir de la consola del dispositivo

...porque system/bin/sh sqlite3: not found, con este problema, los comandos Sqlite posteriores no funcionarán. Si quieres ver el resultado, consulta el libro del Maestro Guo~ A continuación, primero exportamos el archivo db y luego usamos una herramienta gráfica de base de datos para verlo.


4. Uso de la API proporcionada por Android para operar SQLite

Si no has aprendido la sintaxis relacionada con bases de datos, o eres perezoso y no quieres escribir sintaxis SQL, puedes usar algunos de los métodos API que Android nos proporciona para operar bases de datos. A continuación, escribimos un ejemplo sencillo para demostrar el uso de estas API.

Ejemplo de código:

Captura del efecto en ejecución:

Código de implementación:

El diseño es demasiado simple, solo cuatro Botones, así que no lo publicaré. Publicaré directamenteMainActivity.javael código de:

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Context mContext;
    private Button btn_insert;
    private Button btn_query;
    private Button btn_update;
    private Button btn_delete;
    private SQLiteDatabase db;
    private MyDBOpenHelper myDBHelper;
    private StringBuilder sb;
    private int i = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mContext = MainActivity.this;
        myDBHelper = new MyDBOpenHelper(mContext, "my.db", null, 1);
        bindViews();
    }

    private void bindViews() {
        btn_insert = (Button) findViewById(R.id.btn_insert);
        btn_query = (Button) findViewById(R.id.btn_query);
        btn_update = (Button) findViewById(R.id.btn_update);
        btn_delete = (Button) findViewById(R.id.btn_delete);

        btn_query.setOnClickListener(this);
        btn_insert.setOnClickListener(this);
        btn_update.setOnClickListener(this);
        btn_delete.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        db = myDBHelper.getWritableDatabase();
        switch (v.getId()) {
            case R.id.btn_insert:
                ContentValues values1 = new ContentValues();
                values1.put("name", "呵呵~" + i);
                i++;
                //参数依次是:表名,强行插入null值得数据列的列名,一行记录的数据
                db.insert("person", null, values1);
                Toast.makeText(mContext, "插入完毕~", Toast.LENGTH_SHORT).show();
                break;
            case R.id.btn_query:
                sb = new StringBuilder();
                //参数依次是:表名,列名,where约束条件,where中占位符提供具体的值,指定group by的列,进一步约束
                //指定查询结果的排序方式
                Cursor cursor = db.query("person", null, null, null, null, null, null);
                if (cursor.moveToFirst()) {
                    do {
                        int pid = cursor.getInt(cursor.getColumnIndex("personid"));
                        String name = cursor.getString(cursor.getColumnIndex("name"));
                        sb.append("id:" + pid + ":" + name + "\n");
                    } while (cursor.moveToNext());
                }
                cursor.close();
                Toast.makeText(mContext, sb.toString(), Toast.LENGTH_SHORT).show();
                break;
            case R.id.btn_update:
                ContentValues values2 = new ContentValues();
                values2.put("name", "嘻嘻~");
                //参数依次是表名,修改后的值,where条件,以及约束,如果不指定三四两个参数,会更改所有行
                db.update("person", values2, "name = ?", new String[]{"呵呵~2"});
                break;
            case R.id.btn_delete:
                //参数依次是表名,以及where条件与约束
                db.delete("person", "personid = ?", new String[]{"3"});
                break;
        }
    }
}

5. Uso de sentencias SQL para operar la base de datos

Por supuesto, es posible que ya hayas aprendido SQL y sepas escribir sentencias SQL, y no quieras usar estas API proporcionadas por Android. Puedes usar directamente los métodos relacionados que SQLiteDatabase nos proporciona:

  • execSQL(SQL,Object[]): usar sentencias SQL con marcadores de posición, esto se usa para ejecutar sentencias SQL que modifican el contenido de la base de datos.
  • rawQuery(SQL,Object[]): usar operaciones de consulta SQL con marcadores de posición.CursorEl objeto es algo similar al ResultSet en JDBC, ¡un conjunto de resultados! El uso es similar. Proporciona métodos para mover el puntero de registros de los resultados de la consulta:
  • move(offset): especifica el número de filas para moverse hacia arriba o hacia abajo; los enteros positivos indican moverse hacia abajo; los negativos indican moverse hacia arriba.
  • moveToFirst(): mueve el puntero a la primera fila; devuelve true si tiene éxito, lo que también indica que hay datos.
  • moveToLast(): mueve el puntero a la última fila; devuelve true si tiene éxito.
  • moveToNext(): mueve el puntero a la siguiente fila; devuelve true si tiene éxito, lo que indica que aún hay elementos.
  • moveToPrevious(): se mueve al registro anterior.
  • getCount(): obtiene el número total de registros de datos.
  • isFirst(): si es el primer registro.
  • isLast(): si es el último elemento.
  • moveToPosition(int): se mueve a la fila especificada.

Ejemplo de código de uso:

1. Insertar datos:

public void save(Person p)
{
    SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
    db.execSQL("INSERT INTO person(name,phone) values(?,?)",
                new String[]{p.getName(),p.getPhone()});
}

2. Eliminar datos:

public void delete(Integer id)
{
    SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
    db.execSQL("DELETE FROM person WHERE personid = ?",
                new String[]{id});
}

3. Modificar datos:

public void update(Person p)
{
    SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
    db.execSQL("UPDATE person SET name = ?,phone = ? WHERE personid = ?",
        new String[]{p.getName(),p.getPhone(),p.getId()});
}

4. Consultar datos:

public Person find(Integer id)
{
    SQLiteDatabase db = dbOpenHelper.getReadableDatabase();
    Cursor cursor =  db.rawQuery("SELECT * FROM person WHERE personid = ?",
            new String[]{id.toString()});
    //存在数据才返回true
    if(cursor.moveToFirst())
    {
        int personid = cursor.getInt(cursor.getColumnIndex("personid"));
        String name = cursor.getString(cursor.getColumnIndex("name"));
        String phone = cursor.getString(cursor.getColumnIndex("phone"));
        return new Person(personid,name,phone);
    }
    cursor.close();
    return null;
}

5. Paginación de datos:

public List<Person> getScrollData(int offset,int maxResult)
{
    List<Person> person = new ArrayList<Person>();
    SQLiteDatabase db = dbOpenHelper.getReadableDatabase();
    Cursor cursor =  db.rawQuery("SELECT * FROM person ORDER BY personid ASC LIMIT= ?,?",
        new String[]{String.valueOf(offset),String.valueOf(maxResult)});
    while(cursor.moveToNext())
    {
        int personid = cursor.getInt(cursor.getColumnIndex("personid"));
        String name = cursor.getString(cursor.getColumnIndex("name"));
        String phone = cursor.getString(cursor.getColumnIndex("phone"));
        person.add(new Person(personid,name,phone)) ;
    }
    cursor.close();
    return person;
}

6. Consultar el número de registros:

public long getCount()
{
    SQLiteDatabase db = dbOpenHelper.getReadableDatabase();
    Cursor cursor =  db.rawQuery("SELECT COUNT (*) FROM person",null);
    cursor.moveToFirst();
    long result = cursor.getLong(0);
    cursor.close();
    return result;      
}   

PS: Además del método anterior para obtener el número de registros, también puedes usar el método cursor.getCount() para obtener la cantidad de datos, ¡pero la sentencia SQL debe cambiarse! Por ejemploSELECT * FROM person;


Resumen de esta sección:

Esta sección ha presentado el uso básico de SQLite integrado en Android. Es bastante simple. En la próxima sección estudiaremos algo un poco más avanzado: transacciones SQLite, cómo manejar la actualización de datos en la base de datos cuando la aplicación se actualiza, y los métodos para almacenar archivos binarios grandes en la base de datos. ¡Bien, eso es todo por esta sección~