Nous avons déjà parlé de la façon de stocker des données dans des fichiers, donc en dehors de cette méthode, il est courant de stocker des données dans des bases de données que tout le monde connaît.
Avantages du stockage des données dans une base de données :
1) Les données stockées dans la base de données sont plus pratiques à utiliser, telles que l'ajout, la suppression, la modification, la vérification, etc.
2) La restauration des transactions peut être réalisée, comme les virements bancaires, etc.
3) Entretien facile et haute lisibilité
4) Faible utilisation des ressources et hautes performances
5）……
Les bases de données SQLite manquent partout dans notre vie quotidienne, comme nos téléphones mobiles ~ les téléphones mobiles sur le marché utilisent désormais les bases de données SQLite comme stockage de données.
Et les maisons intelligentes que nous voyons souvent utilisent également des bases de données SQLite pour enregistrer des données. Et les programmes de bureau que nous utilisons souvent, tels que QQ, Thunder, etc.
1. Le concept et les avantages et inconvénients de la base de données SQLite
La base de données SQLite est un moteur de base de données embarqué open source, et chacune de ses bases de données existe sous la forme d'un fichier unique
Ces données sont stockées sur le disque sous la forme d'une structure de données B-Tree.
La base de données SQLite est un petit fichier qui peut être ouvert et exécuté directement, tandis que d'autres bases de données sont une application volumineuse.
Avantages d'utiliser SQLite :
1. SQLite prend en charge la plupart des instructions standard sql
Ajouter, supprimer, modifier, vérifier, effectuer une transaction, etc., donc je n'en parlerai pas en détail ici...
2. Léger
On peut dire qu'il est de poche, mais le petit SQLite peut prendre en charge des bases de données jusqu'à 2 To.
3. Vitesse de recherche rapide
4. Modèle de données dynamique (type faible)
Prise en charge de la base de données SQLite
NULL : valeur vide
INTEGER : type entier
REAL : virgule flottante
TEXTE : texte de la chaîne
BLOB : objet binaire
5 types de données de base.
La raison pour laquelle il est appelé "type faible" est que, quel que soit le type de données, il sera automatiquement converti lors de l'insertion des données.
Remarque : Lorsque la contrainte de INTEGER est PRIMARY KEY, elle doit être un entier et ne sera pas automatiquement convertie, sinon une erreur sera signalée !
5. La base de données SQLite n'a pas besoin d'être installée et configurée avant utilisation, ni d'activer le processus pour démarrer et fermer la base de données
6. Occupe moins de ressources système
7. Multiplateforme
Il peut être utilisé sous plusieurs systèmes d'exploitation sans qu'il soit nécessaire d'écrire du code indépendamment pour un certain système d'exploitation, c'est-à-dire que sa couche de données est la même dans chaque système d'exploitation ;
Dans le même temps, il est également déterminé par le mécanisme interne de la base de données SQLite.La base de données SQL s'exécute sur la machine virtuelle SQLite.
Sur la machine virtuelle, il sera directement traduit et compilé en modèles de données de différents systèmes d'exploitation.
Les inconvénients de SQLite sont :
1. Ne prend pas en charge les grands projets
2. Certaines instructions standard SQL ne sont pas prises en charge, mais ces instructions ne sont généralement pas utilisées...
3. Par rapport à d'autres grandes bases de données, la sécurité est médiocre
Par rapport à nos téléphones Android, tant que vous obtenez les autorisations root, cela prouve que vous pouvez faire ce que vous voulez...
Alors comment Android renforce-t-il sa sécurité ?
a. Améliorer la vérification de la sécurité du programme
b. Renforcer la rigueur du code
c. Gestion de l'autorité
En raison des avantages de la base de données SQLite, de nombreuses applications de bureau l'utilisent pour stocker les données de l'application ;
Bien sûr, nos chaînes de produits Android et iPhone utilisent presque toutes des bases de données SQLite.
2. Implémentation sous Android
1. Utiliser des méthodes natives pour effectuer des opérations simples sur la base de données
C'est-à-dire écrire du code SQL directement
a. Définissez une méthode et héritez de la classe SQLiteOpenHelper. Et implémentez les méthodes onCreate et onUpgrade, et remplacez les méthodes personnalisées.
Ignorer les méthodes personnalisées :
1) Il existe de nombreux paramètres, il suffit donc ici de n'avoir besoin que du paramètre de contexte.
2) super paramètres :
contexte : contexte
nom : nom de la base de données
factory : le but de la création d'objets curseur
version : version de la base de données, généralement à partir de 1
méthode onCreate :
1) Il est utilisé lorsque la base de données est créée pour la première fois, si c'est la deuxième, elle est ouverte
2) Convient pour l'initialisation de la structure de la table
méthode onUpgrade :
1) Utilisé lorsque la version de la base de données est mise à jour
2) Convient pour mettre à jour la structure de la table
execSQL：
L'instruction sql à exécuter convient pour l'ajout, la suppression et la modification
public class MyOpenHelper étend SQLiteOpenHelper {
/**
*
* @param contexte contexte
* nom nom de la base de données
* objectif de l'usine pour créer l'objet curseur
* version la version de la base de données commence à partir de 1
*/
public MyOpenHelper(Context context) {
super(context, "test_1. db ", null, 3);
}
/**
* Lorsque la base de données est créée pour la première fois
* Cette méthode est particulièrement adaptée pour initialiser la structure de la table. La création d'une table consiste à écrire une instruction sql
*/
@Override
public void onCreate (SQLiteDatabase db) {
db.execSQL("create table test_info(id integer primary key autoincrement,name varchar(20))"); } / **
*
Utilisé
lorsque la version de la base de données est mise à niveau
* Cette méthode convient pour mettre à jour la table structure
*/
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("alter table test_info add phone varchar(20)");
}
}
b. Il faut prêter attention au downgrade onDowngrade de la base de données, les points clés de conception du downgrade
1) Envisagez le cloud pour économiser les utilisateurs [données personnalisées, habitudes de comportement]. Profil de terme professionnel ->> améliorer la viscosité de l'utilisateur
2) Tenez compte des exigences de version minimales actuelles ->> réduisez les coûts de maintenance
3) Transfert de données local autant que possible (toutes les nouvelles versions ne suppriment pas les champs) -> transformer autant que possible les inconnues en connues
4) Le downgrade est susceptible d'échouer, donc on try-catch en général ; quand le downgrade réussit, c'est l'instruction du bloc try, et l'instruction du bloc catch est exécutée après l'échec
5) SQLiteDatabase (instruction d'exécution), oldVersion (ancien numéro de version), newVersion (nouveau numéro de version)
/* La simulation passera de 3.0 à 2.0 */
@Override
public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
//Normalement parlant, s'il est supérieur à 2.0, il devrait y avoir une table test_info, et les champs en 2.0 sont tous en 3.0 Yes
try {
//Tout d'abord, renommer d'abord la future table de test_info
String rename_sql = "alter table test_info rename to test_info_bak";
db.execSQL(rename_sql);
Log.i("down", "1. Renommé avec succès") ;
//Deuxièmement, créez une structure de table 2.0
String sql_message = "créer une table test_info (id int clé primaire, tou1 varchar(50), userName varchar(50),
lastMessage varchar(50), datetime varchar(50) )" ;
db.execSQL(sql_message);
Log.i("down", "2.Créer une structure de table 2.0 avec succès");
// Troisièmement, copiez les données de sauvegarde dans la table 2.0 nouvellement créée
String sql_copy = "insert into test_info select id,tou1,userName,lastMessage,datetime from test_info_bak" ;
db.execSQL(sql_copy);
Log.i(" down", "3.copy user data to 2.0 table" );
//Quatrièmement, supprimez la table de sauvegarde
String drop_sql = "supprimez la table si elle existe test_info_bak" ;
db.execSQL(drop_sql);
Log.i(" down", "4. Drop la table de sauvegarde");
} catch (Exception e) {
//Failure
Log.i("hi", "Échec de la rétrogradation, rétablissement");
String sql_drop_old_table = "supprimer la table si elle existe test_info " ;
String sql_message = "créer une table test_info (auto-incrémentation de la clé primaire entière id, nom varchar (20), téléphone varchar (20))" ;
String sql_init_1 = "insérer dans les valeurs test_info (1,'abc','130000')" ;
String sql_init_2 = "insérer dans les valeurs test_info (2,'abc','134444')" ;
db.execSQL(sql_drop_old_table);
db.execSQL(sql_message);
db.execSQL(sql_init_1);
db.execSQL(sql_init_2);
}
}
c. Créer un objet MyOpenHelper
myOpenHelper = new MyOpenHelper(getApplicationContext()); //Ouvrir ou créer une base de données si elle est créée pour la première fois, puis ouvrir //SQLiteDatabase sqliteDatabase = myOpenHelper.getWritableDatabase(); //Ouvrir ou créer une base de données si c'est la Créez la première fois, puis ouvrez et retournez en lecture seule si le disque est plein //SQLiteDatabase sqliteDatabase = myOpenHelper.getReadableDatabase();
d. Augmenter les données
//Obtenir l'objet de base de données
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
//Exécuter et ajouter une instruction sql
db.execSQL("insert into test_info(name,phone) values(?,?)",new Object[]{" zhangsan" ,"138888888"});
// ferme la base de données lorsqu'elle est épuisée
db.close();
e. Supprimer des données
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
db.execSQL("delete from test_info where name=",new Object[]{"zhangsan"});
db.close();
f. Modifier les données
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
db.execSQL("updata test_info set phone=? where name=?",new Object[]{"13777777777","zhangsan"});
db.close();
g. Interroger les données
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
Curseur curseur = db.rawQuery("select * from test_info", null);
if(cursor!=null&&cursor.getCount()>0){
while(cursor.moveToNext()){
//columnIndex代表列的索引
String name = cursor.getString(1);
Téléphone de chaîne = curseur.getString(2);
}
}
2. Utilisez l'API packagée par Google pour effectuer des opérations simples sur les données
Les ingénieurs de Google ont emballé certaines méthodes que nous pouvons appeler directement, mais en fait, au niveau inférieur, ces chaînes sont épissées dans des instructions SQL complètes.
a. Augmenter les données
Une collection de cartes encapsulée dans ContentValues, qui stocke les données sous la forme de <clé, valeur>.
insérer la description du paramètre
table : nom de la table
key : le nom de la colonne correspondante
valeur : la valeur correspondante
mettre la description du paramètre
clé : le nom de la colonne ajoutée
valeur : la valeur correspondante
//Obtenir l'objet de base de données
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
/**
* table table name
* ContentValues encapsule une carte à l'intérieur
* key : le nom de la colonne correspondante
* value : la valeur correspondante
*/
ContentValues values = new ContentValues();
values.put("name", "wangwu");
values.put("phone", "120");
//La valeur de retour représente l'id de la nouvelle ligne insérée
long insert = db.insert("test_info", null, values );//La couche inférieure fusionne les instructions SQL
//Ferme la base de données lorsqu'elle est épuisée
db.close();
if(insert>0){
Toast.makeText( getApplicationContext(), "Ajouté avec succès !", 3000).show() ;
}else{
Toast.makeText(getApplicationContext(), "Échec de l'ajout !", 3000).show();
}
b. Supprimer des données
supprimer la description du paramètre
table : nom de la table
whereClause : quelle colonne supprimer, en fonction de ce qu'il faut supprimer
whereArgs : ce qui est renvoyé ici est un objet tableau, en fonction de la valeur de la colonne supprimée
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
//Suppression selon l'API packagée de Google
int delete = db.delete("test_info", "name=?", new String[]{"wangwu"});
db.close( ) Toast.makeText
(getApplicationContext(), "Ligne "+delete+" supprimée", 2000).show();
c. Modifier les données
mettre à jour la description du paramètre
table : nom de la table
valeur : est la valeur dans ContentValues
whereClause : Quelle colonne modifier, selon quelle modification
whereArgs : Voici un objet tableau, selon la valeur de la colonne modifiée
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
//Modifier ContentValues selon l'API packagée de Google value = new ContentValues(); value.put("phone", "110"); //Représente le nombre de lignes mises à jour int updata = db .update("test_info", value, "name=?", new String[]{"wangwu"}); db.close(); Toast.makeText (getApplicationContext ( ), "updated"+updata+"line ", 2000).show();
d. Interroger les données
description du paramètre de requête
table : nom de la table
colonnes : les colonnes de la requête
sélection : selon quelle requête
selectionArgs : la valeur de la condition de requête
groupBy : regroupement
avoir : conditions de requête, ici nous devons distinguer la différence entre avoir et où !
orderBy : trier
moveToNext() : parcourir les données dans la table de données
curseur : l'objet pointeur encapsulé par les ingénieurs de Google, utilisé pour parcourir l'indice de la collection
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
/**
* Requête basée sur l'API packagée de Google
* les colonnes représentent les colonnes que vous souhaitez interroger
* sélection Interroger le téléphone en fonction de quoi
*/
Curseur curseur = db.query("test_info", nouvelle chaîne [ ]{"phone"}, "name=?", new String[]{"wangwu"}, null, null, null); if(cursor!=null &&cursor.getCount()>0){ while(
cursor
. moveToNext( )){
String phone = curseur.getString(0);
System.out.println("phone:" + phone);
}
}
3. Avantages et inconvénients de l'utilisation de méthodes natives et de méthodes API packagées
a. Avantages des méthodes natives
1) Vous pouvez utiliser les instructions SQL de manière plus flexible
2) La quantité de code peut être réduite et l'efficacité est plus élevée
b. Inconvénients des méthodes natives
1) Il est facile d'écrire un mauvais code sql
2) Pas facile à entretenir
C. Avantages d'un bon emballage
1) Il n'est pas nécessaire d'écrire directement des instructions sql, ce qui réduit la probabilité d'erreurs
2) Entretien facile
d. Inconvénients d'un bon emballage
1) Rendre le programme plus lourd et moins efficace
2) Il n'est pas pratique d'exploiter des données et ne peut pas utiliser de manière flexible les instructions d'opération de données
Quelle que soit la méthode utilisée, elle a ses avantages et ses inconvénients, donc dans le développement réel, cela dépend de la situation réelle, et toute méthode que vous souhaitez utiliser est également réalisable.
Suggestion : pour les petits programmes, il est recommandé d'utiliser des API packagées, qui sont relativement simples et peuvent améliorer l'efficacité du développement.
Il est recommandé d'utiliser des méthodes natives pour les programmes relativement volumineux, qui sont plus flexibles et peuvent également améliorer l'efficacité du programme
3. Résumé
1. Avantages et inconvénients de l'utilisation de SQLite
2. Mise à niveau et rétrogradation de la base de données (*****)
3. Utilisez des méthodes natives pour effectuer des opérations simples sur la base de données
4. Utilisez l'API packagée par Google pour effectuer des opérations simples sur la base de données
5. Avantages et inconvénients de chacun
6. La couche de données des chaînes de produits Android et iPhone est la même
ps : Les étudiants intéressés peuvent penser à WeChat :
Comment SQLite est-il implémenté côté client ?
Qu'est-ce qui est utilisé pour y parvenir dans le serveur d'arrière-plan et comment y parvient-il ?
Qu'en est-il de l'interaction de ces données ?
Comment l'optimiser ?