Hablamos de cómo almacenar datos en archivos antes, por lo que, aparte de este método, es común almacenar datos en bases de datos que todos conocen.
Ventajas de almacenar datos en una base de datos:
1) Los datos almacenados en la base de datos son más convenientes para operar, como agregar, eliminar, modificar, verificar, etc.
2) Se puede realizar el rollback de transacciones, como transferencias bancarias, etc.
3) Fácil mantenimiento y alta legibilidad.
4) Bajo uso de recursos y alto rendimiento
5）……
Las bases de datos SQLite faltan en todas partes en nuestra vida diaria, como nuestros teléfonos móviles ~ los teléfonos móviles en el mercado ahora usan bases de datos SQLite como almacenamiento de datos.
Y las casas inteligentes que vemos a menudo también usan bases de datos SQLite para registrar datos. Y los programas de escritorio que usamos a menudo, como QQ, Thunder, etc.
1. El concepto y las ventajas y desventajas de la base de datos SQLite
La base de datos SQLite es un motor de base de datos incrustado de código abierto, y cada una de sus bases de datos existe en forma de un solo archivo
Estos datos se almacenan en el disco en forma de estructura de datos B-Tree.
La base de datos SQLite es un archivo pequeño que se puede abrir y ejecutar directamente, mientras que otras bases de datos son una aplicación grande.
Ventajas de usar SQLite:
1. SQLite admite la mayoría de las declaraciones estándar de sql
Agregar, eliminar, modificar, verificar, transaccionar, etc., por lo que no hablaré de esto en detalle aquí...
2. Ligero
Se puede decir que es de bolsillo, pero el pequeño SQLite puede admitir bases de datos de hasta 2 TB de tamaño.
3. Velocidad de búsqueda rápida
4. Modelo de datos dinámicos (tipo débil)
Soporte de base de datos SQLite
NULL: valor vacío
ENTERO: tipo entero
REAL: punto flotante
TEXTO: cadena de texto
BLOB: objeto binario
5 tipos básicos de datos.
La razón por la que se llama "tipo débil" es que no importa qué tipo de datos sea, se convertirá automáticamente al insertar datos.
Nota: Cuando la restricción de INTEGER es PRIMARY KEY, debe ser un número entero y no se convertirá automáticamente; de lo contrario, ¡se informará un error!
5. No es necesario instalar y configurar la base de datos SQLite antes de su uso, ni habilitar un proceso para iniciar y cerrar la base de datos.
6. Ocupa menos recursos del sistema
7. Multiplataforma
Puede ser utilizado bajo múltiples sistemas operativos sin necesidad de escribir código de forma independiente para un determinado sistema operativo, es decir, su capa de datos es la misma en cada sistema operativo;
Al mismo tiempo, también está determinado por el mecanismo interno de la base de datos SQLite.La base de datos SQL se ejecuta en la máquina virtual SQLite.
En la máquina virtual, se traducirá y compilará directamente en modelos de datos de diferentes sistemas operativos.
Las desventajas de SQLite son:
1. No apoya grandes proyectos
2. Algunas declaraciones estándar de SQL no son compatibles, pero estas declaraciones generalmente no se usan...
3. En comparación con otras bases de datos grandes, la seguridad es deficiente
En comparación con nuestros teléfonos Android, siempre que obtenga permisos de root, demuestra que puede hacer lo que quiera...
Entonces, ¿cómo fortalece Android su seguridad?
a. Mejorar la verificación de la seguridad del programa
b. Fortalecer el rigor del código
c. Gestión de autoridades
Debido a las ventajas de la base de datos SQLite, muchas aplicaciones de escritorio la utilizan para almacenar los datos de la aplicación;
Por supuesto, casi todas nuestras cadenas de productos de Android y iPhone utilizan bases de datos SQLite.
2. Implementación en Android
1. Use métodos nativos para realizar operaciones simples en la base de datos
Es decir, escribir código SQL directamente
a. Defina un método y herede la clase SQLiteOpenHelper. E implemente los métodos onCreate y onUpgrade, y anule los métodos personalizados.
Anular métodos personalizados:
1) Hay muchos parámetros, por lo que aquí simplemente solo necesita el parámetro de contexto.
2) súper parámetros:
contexto: contexto
nombre: nombre de la base de datos
fábrica: el propósito de crear objetos de cursor
versión: versión de la base de datos, generalmente a partir de 1
método onCreate:
1) Se utiliza cuando se crea la base de datos por primera vez, si es la segunda se abre
2) Adecuado para la inicialización de la estructura de la tabla
onUpgrade método:
1) Se utiliza cuando se actualiza la versión de la base de datos
2) Adecuado para actualizar la estructura de la tabla.
execSQL:
La declaración sql que se ejecutará es adecuada para agregar, eliminar y modificar
public class MyOpenHelper extiende SQLiteOpenHelper {
/**
*
* @param context context
* nombre nombre de la base de datos
* propósito de la fábrica para crear el objeto del cursor
* versión la versión de la base de datos comienza desde 1
*/
public MyOpenHelper(Context context) {
super(context, "test_1. db ", null, 3);
}
/**
* Cuando la base de datos se crea por primera vez
* Este método es especialmente adecuado para inicializar la estructura de la tabla. Crear una tabla es escribir una declaración sql
*/
@Override
public void onCreate (SQLiteDatabase db) {
db. execSQL("create table test_info(id integer primary key autoincrement,name varchar(20))"); } / ** *
Se
usa
cuando se actualiza la versión de la base de datos
* Este método es adecuado para actualizar la tabla estructura
*/
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("alter table test_info add phone varchar(20)");
}
}
B. Se debe prestar atención a la degradación de la base de datos, los puntos clave de diseño de la degradación
1) Considerar la nube para salvar a los usuarios [datos personalizados, hábitos de comportamiento]. Perfil de término profesional–>> mejorar la viscosidad del usuario
2) Considere los requisitos mínimos de la versión actual ->> reduzca los costos de mantenimiento
3) Transferencia de datos locales tanto como sea posible (todas las nuevas versiones no eliminan campos) -> convertir lo desconocido en conocido tanto como sea posible
4) Es probable que la degradación falle, por lo que generalmente intentamos atrapar ; cuando la degradación es exitosa, es la declaración del bloque de prueba, y la declaración del bloque de captura se ejecuta después de la falla
5) SQLiteDatabase (declaración de ejecución), oldVersion (número de versión anterior), newVersion (número de versión nueva)
/* La simulación disminuirá de 3.0 a 2.0 */
@Override
public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
//Normalmente, si es mayor que 2.0, debería haber una tabla test_info y los campos en 2.0 están todos en 3.0 Sí
intente {
//Primero, primero cambie el nombre de la tabla futura de test_info
String rename_sql = "alter table test_info rename to test_info_bak";
db.execSQL(rename_sql);
Log.i("down", "1. Renombrado correctamente") );
//Segundo, cree una estructura de tabla 2.0
String sql_message = "create table test_info (id int primary key, tou1 varchar(50), userName varchar(50),
lastMessage varchar(50), datetime varchar(50) )";
db.execSQL(sql_message);
Log.i("down", "2.Crear estructura de tabla 2.0 con éxito");
//Tercero, copie los datos de la copia de seguridad en la tabla 2.0 recién creada
String sql_copy = "insertar en test_info select id,tou1,userName,lastMessage,datetime from test_info_bak";
db.execSQL(sql_copy);
Log.i(" down", "3.copiar datos de usuario a la tabla 2.0");
//Cuarto, suelte la tabla de copia de seguridad
String drop_sql = "suelte la tabla si existe test_info_bak";
db.execSQL(drop_sql);
Log.i(" down", "4. Suelte la tabla de copia de seguridad");
} catch (Excepción e) {
//Failure
Log.i("hola", "Downgrade falló, restablecer");
String sql_drop_old_table = "eliminar tabla si existe test_info";
String sql_message = "crear tabla test_info(id integer clave primaria autoincremento,name varchar(20),phone varchar(20))";
String sql_init_1 = "insertar en los valores de test_info (1, 'abc', '130000')";
String sql_init_2 = "insertar en los valores de test_info (2, 'abc', '134444')";
db.execSQL(sql_drop_old_table);
db.execSQL(mensaje_sql);
db.execSQL(sql_init_1);
db.execSQL(sql_init_2);
}
}
c. Crear un objeto MyOpenHelper
myOpenHelper = new MyOpenHelper(getApplicationContext()); //Abra o cree una base de datos si se crea por primera vez, luego abra //SQLiteDatabase sqliteDatabase = myOpenHelper.getWritableDatabase(); //Abra o cree una base de datos si es la la primera vez Crear, luego abrir y devolver solo lectura si el disco está lleno //SQLiteDatabase sqliteDatabase = myOpenHelper.getReadableDatabase();
D. Aumentar datos
//Obtenga el objeto de la base de datos
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
//Ejecute y agregue una instrucción sql
db.execSQL("insert into test_info(name,phone) values(?,?)",new Object[]{" zhangsan" ,"138888888"});
// cerrar la base de datos cuando se agote
db.close();
E. Eliminar datos
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
db.execSQL("eliminar de test_info where name=?",nuevo Objeto[]{"zhangsan"});
db.cerrar();
F. Modificar datos
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
db.execSQL("updata test_info set phone=? where name=?",new Object[]{"13777777777","zhangsan"});
db.cerrar();
g. Consulta de datos
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
Cursor cursor = db.rawQuery("select * from test_info", null);
if(cursor!=null&&cursor.getCount()>0){
while(cursor.moveToNext()){
//columnIndex代表列的索引
String nombre = cursor.getString(1);
Cadena teléfono = cursor.getString(2);
}
}
2. Use la API empaquetada por Google para realizar operaciones simples en los datos
Los ingenieros de Google han empaquetado algunos métodos para que llamemos directamente, pero, de hecho, en la capa inferior, estas cadenas se empalman en declaraciones SQL completas.
a. Aumentar los datos
Una colección de mapas encapsulada dentro de ContentValues, que almacena datos en forma de <clave, valor>.
insertar descripción del parámetro
tabla: nombre de la tabla
clave: el nombre de la columna correspondiente
valor: el valor correspondiente
poner descripción del parámetro
clave: el nombre de la columna agregada
valor: el valor correspondiente
//Obtenga el objeto de la base de datos
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
/**
* table table name
* ContentValues encapsula un mapa dentro
* key: el nombre de la columna correspondiente
* value: el valor correspondiente
*/
ContentValues valores = new ContentValues();
valores.put("nombre", "wangwu");
valores.put("teléfono", "120");
//El valor de retorno representa el id de la nueva fila insertada
inserción larga = db.insert("test_info", null, valores);//La capa inferior está empalmando instrucciones SQL
//Cierre la base de datos cuando se agote
db.close();
if(insert>0){
Toast.makeText( getApplicationContext(), "¡Se agregó correctamente!", 3000).show() ;
}else{
Toast.makeText(getApplicationContext(), "¡Error al agregar!", 3000).show();
}
B. Eliminar datos
eliminar la descripción del parámetro
tabla: nombre de la tabla
whereCláusula: qué columna eliminar, según qué eliminar
whereArgs: lo que se devuelve aquí es un objeto de matriz, según el valor de la columna eliminada
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
//Eliminar de acuerdo con la API empaquetada de Google
int delete = db.delete("test_info", "name=?", new String[]{"wangwu"});
db.close( ) Toast.makeText
(getApplicationContext(), "Línea "+eliminar+" eliminada", 2000).show();
c. Modificar datos
actualizar la descripción del parámetro
tabla: nombre de la tabla
valor: es el valor en ContentValues
whereClause: Qué columna modificar, según qué modificación
whereArgs: aquí hay un objeto de matriz, según el valor de la columna modificada
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
//Modificar ContentValues de acuerdo con el paquete api de Google value = new ContentValues(); value.put("phone", "110"); //Representa cuántas filas se han actualizado int updata = db .update("test_info", value, "name=?", new String[]{"wangwu"}); db.close(); Toast.makeText (getApplicationContext ( ), "updated"+updata+"line ", 2000).mostrar();
D. Datos de consulta
descripción del parámetro de consulta
tabla: nombre de la tabla
columnas: las columnas de la consulta
selección: según qué consulta
selectionArgs: el valor de la condición de consulta
groupBy: agrupación
tener: condiciones de consulta, aquí debemos distinguir la diferencia entre tener y ¡dónde!
ordenar por: ordenar
moveToNext(): recorrer los datos en la tabla de datos
cursor: el objeto puntero encapsulado por los ingenieros de Google, utilizado para recorrer el subíndice de la colección
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
/**
* Consulta basada en la API empaquetada de Google
* las columnas representan las columnas que desea consultar
* selección Teléfono de consulta basado en qué
*/
Cursor cursor = db.query("test_info", new String [ ]{"phone"}, "name=?", new String[]{"wangwu"}, null, null, null); if(cursor!=null &&cursor.getCount()>0){ while(
cursor
. moveToNext( )){
String teléfono = cursor. getString(0);
System. out. println("teléfono:" + teléfono);
}
}
3. Ventajas y desventajas de usar métodos nativos y métodos API empaquetados
A. Ventajas de los métodos nativos
1) Puede usar declaraciones sql de manera más flexible
2) La cantidad de código se puede reducir y la eficiencia es mayor
B. Desventajas de los métodos nativos
1) Es fácil escribir un código sql incorrecto
2) No es fácil de mantener
C. Ventajas de un buen embalaje
1) No hay necesidad de escribir declaraciones SQL directamente, lo que reduce la probabilidad de errores
2) Fácil mantenimiento
D. Desventajas de un buen embalaje
1) Hacer el programa más engorroso y menos eficiente
2) Es un inconveniente operar con datos y no puede usar declaraciones de operación de datos de manera flexible
Independientemente del método que se utilice, tiene sus ventajas y desventajas, por lo que en el desarrollo real depende de la situación real, y cualquier método que desee utilizar también es factible.
Sugerencia: para programas más pequeños, se recomienda usar API empaquetadas, que son relativamente simples y pueden mejorar la eficiencia del desarrollo.
Se recomienda utilizar métodos nativos para programas relativamente grandes, que son más flexibles y también pueden mejorar la eficiencia del programa.
3. Resumen
1. Ventajas y desventajas de usar SQLite
2. Actualización y degradación de la base de datos (*****)
3. Use métodos nativos para realizar operaciones simples en la base de datos
4. Use la API empaquetada por Google para realizar operaciones simples en la base de datos
5. Ventajas y desventajas de cada uno
6. La capa de datos de las cadenas de productos de Android y iPhone es la misma
PD: los estudiantes interesados pueden pensar en WeChat:
¿Cómo se implementa SQLite en el lado del cliente?
¿Qué se usa para lograrlo en el servidor de fondo y cómo se logra?
Entonces, ¿qué pasa con la interacción de estos datos?
¿Cómo optimizarlo?