Stockage et accès aux données - première rencontre avec la base de données SQLite
Introduction à cette section :
Dans cette section, nous continuons à apprendre la troisième méthode de stockage et d'accès aux données Android : la base de données SQLite, qui est différente des autres bases de données SQL. Nous n'avons pas besoin d'installer un autre logiciel de base de données sur le téléphone mobile. Le système Android a intégré cette base de données. Lorsque vous utilisez un autre logiciel de base de données (Oracle, MSSQL, MySql, etc.), vous devez l'installer, compléter la configuration appropriée et changer de port ! C'est tout pour l'introduction, apprenons la prochaine chose ~
1 Concepts de base
1) Qu'est-ce que SQLite ? Pourquoi utiliser SQLite ? Quelles sont les caractéristiques de SQLite ?
Réponse : Veuillez écouter l'explication de Xiaozhu ci-dessous :
①SQLite est une base de données relationnelle légère avec une vitesse de calcul rapide et une faible utilisation des ressources. appareil, Il prend non seulement en charge la syntaxe SQL standard, mais suit également les principes ACID (transaction de base de données). Aucun compte n'est requis et il est très pratique à utiliser !
② Plus tôt, nous avons appris à utiliser les fichiers et SharedPreference pour enregistrer des données, mais dans de nombreux cas, Le fichier n'est pas forcément valide, par exemple, un accès simultané par plusieurs threads est pertinent ; l'application doit gérer des structures de données complexes qui peuvent changer, etc. ! Comme déposer et retirer de l’argent à la banque ! L'utilisation des deux premiers semblera très impuissante ou fastidieuse. L'émergence de la base de données peut résoudre ce problème. Et Android nous fournit un SQLite si léger, pourquoi ne pas l'utiliser ?
③SQLite prend en charge cinq types de données : NULL, INTEGER, REAL (nombre à virgule flottante), TEXT (chaîne de texte) et BLOB (objet binaire) Bien qu'il n'y ait que cinq types, d'autres types de données tels que varchar et char peuvent être enregistrés ; car SQLite possède la plus grande fonctionnalité : Vous pouvez enregistrer des données de différents types de données dans n'importe quel champ sans vous soucier de la déclaration du champ. type de données , tel que le vôtre Les chaînes peuvent être stockées dans des champs de type Integer, bien sûr sauf pour les déclarer comme clés primaires INTEGER PRIMARY Le champ KEY ne peut stocker que des entiers de 64 bits ! De plus, lorsque SQLite analyse l'instruction CREATE TABLE, Les informations de type de données qui suivent le nom du champ dans l'instruction CREATE TABLE seront ignorées. Par exemple, l'instruction suivante ignorera les informations de type du champ de nom : CREATE TABLE person (auto-incrémentation de clé primaire entière d'ID de personne, nom varchar(20). ))
Résumé des fonctionnalités :
SQlite enregistre la base de données via des fichiers Un fichier est une base de données<. 🎜>, et la base de données contient plusieurs formulaires, et il y a Plusieurs enregistrements, chaque enregistrement se compose de plusieurs champs, chaque champ a une valeur correspondante, et pour chaque valeur nous pouvons spécifier le type , ou non spécifié Tapez (sauf clé primaire)
PS : Au fait, le SQLite intégré à Android est la version SQLite 3~
2) Plusieurs classes associées :Hé, quand vous apprenez quelque chose de nouveau, ce que vous n’aimez pas le plus, c’est de rencontrer de nouveaux termes, n’est-ce pas quelques-uns d’abord ? Trois classes que nous utilisons lors de l'utilisation de la base de données :
- SQLiteOpenHelper : classe abstraite, on hérite de cette classe puis on remplace les méthodes de création et de mise à jour de la base de données, On peut également obtenir une instance de base de données via un objet de cette classe, ou fermer la base de données !
- SQLiteDatabase : Classe d'accès à la base de données : Nous pouvons utiliser les objets de cette classe pour effectuer certaines opérations d'ajout, de suppression, de modification et de vérification de la base de données
- Curseur : Curseur , quelque peu similaire au jeu de résultats dans JDBC, jeu de résultats ! Cela peut être simplement compris comme pointant vers un certain point dans la base de données Un pointeur record!
2. Utiliser la classe SQLiteOpenHelper pour créer des bases de données et gérer les versions
Pour les applications impliquant des bases de données, il nous est impossible de créer manuellement un base de données pour leur fichier, vous devez donc activer l'application pour la première fois La table de base de données est créée lors de la mise à niveau de l'application ; lorsque notre application doit être mise à niveau et que la structure de la table de base de données doit être modifiée, cette fois. La table de la base de données a été mise à jour ; pour ces deux opérations, Android nous propose deux méthodes de SQLiteOpenHelper, onCreate( ) et onUpgrade( ) Implémentation de
analyse de méthode :
- onCreate(database) : Générer une table de base de données lors de la première utilisation du logiciel
- onUpgrade(database,oldVersion,newVersion) : Sera appelé lorsque la version de la base de données change. Généralement, le numéro de version ne doit être modifié que lors de la mise à niveau du logiciel et la version de la base de données est contrôlée par le programmeur. Supposons qu'il s'agisse de la version actuelle de la base de données. La version est 1. En raison de changements commerciaux, la structure des tables de base de données a été modifiée. Pour le moment, le logiciel doit être mis à niveau. Lors de la mise à niveau du logiciel, vous l'espérez. Mettez à jour la structure des tables de la base de données sur le téléphone mobile de l'utilisateur. Afin d'atteindre cet objectif, la version originale de la base de données peut être définie sur 2. Ou tout autre numéro différent de l’ancien numéro de version !
Exemple de code :
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");
}
}Analyse de code :
Le code ci-dessus est le premier Lorsque nous démarrerons l'application pour la première fois, nous créerons le fichier my.db et exécuterons la méthode dans onCreate(). Créez une table Person avec deux champs, la clé primaire personId et le champ name puis nous modifions la version de la base de données ; numéro, alors la méthode dans onUpgrade() sera appelée au prochain démarrage et un autre champ sera inséré dans la table ! De plus, voici l'insertion Un champ, donc les données ne seront pas perdues. Si la table est reconstruite, toutes les données de la table seront perdues. Dans la section suivante, nous le ferons. Apprenons à résoudre ce problème !
Résumé du processus :
- Étape 1 : Personnaliser une classe pour hériter de la classe SQLiteOpenHelper
- Étape 2 : Définissez-la dans le super du constructeur de la classe Le nom de la base de données et le numéro de version à créer
- Étape 3 : Réécrivez la méthode onCreate() pour créer la structure de la table
- Étape 4 : Réécriture La méthode onUpgrade() définit les opérations effectuées après le changement du numéro de version
3 Comment afficher le fichier db que nous avons généré
Quand nous. appelez MyDBOpenhelper ci-dessus Le getWritableDatabase() de l'objet créera notre base de données dans le répertoire suivant Fichier de base de données :
Nous avons constaté qu'il existe deux bases de données, la première est la base de données que nous avons créée et la seconde est générée pour permettre à la base de données de prendre en charge les transactions. Fichiers journaux temporaires ! La taille générale est de 0 octet ! Mais dans Explorateur de fichiers nous ne pouvons pas ouvrir de fichiers, pas même txt, encore moins .db ! Voici donc deux options pour vous :
- 1. Exportez-le d'abord, puis utilisez l'outil graphique de SQLite pour le visualiser
- 2. Après avoir configuré les variables d'environnement adb, utilisez adb Shell pour afficher (ligne de commande, installez le compilateur) !
Eh bien, laissez-moi vous montrer les deux méthodes ci-dessus, choisissez simplement celle que vous aimez ~~
Méthode 1 : utilisez les outils graphiques SQLite pour visualiser la base de données fichiers
Il existe de nombreux logiciels de ce type. L'auteur utilise SQLite Expert Professional. Bien sûr, vous pouvez également utiliser d'autres outils. Si vous en avez besoin, vous pouvez télécharger : SQLiteExpert.zip
Exportez notre fichier db sur le bureau de l'ordinateur, ouvrez SQLiteExpert, l'interface est la suivante :
Ne me demandez pas comment jouer, importez la base de données et jouez lentement tout seul, l'utilisation est très simple, je ne comprends pas Baidu~
Quant au deuxième méthode, je voulais au départ l'essayer, mais plus tard, j'ai découvert que la commande sqlite était introuvable. Allez, essayez-la plusieurs fois et oubliez-la. Il sera utilisé plus tard dans le bouton fin. Si vous êtes intéressé, vous pouvez trouver "La première ligne de code - Android" de Guo Lin et l'essayer selon l'organigramme ! Seule la première partie est publiée ici, lisez vous-même la partie commande !
Méthode 2 : La ligne de commande du shell adb vous amènera à faire semblant et à voler
1 Configurez les variables d'environnement du SDK :
Droit. -cliquez sur Ordinateur ——> Paramètres système avancés -> Variables d'environnement Nouvelles variables système -> -tools Copiez le chemin : Par exemple, l'auteur : C:SoftwareCodingandroid-sdks-asplatform-tools
Confirmez, puis recherchez la variable d'environnement du chemin, modifiez et ajoutez à la fin : %SDK_HOME%;
Puis ouvrez la ligne de commande, entrez adb, swish swish un tas de choses, ça veut dire que la configuration est réussie !
——————Points clés——————: Avant d'exécuter les instructions de ligne de commande suivantes, plusieurs machines peuvent être utilisées pour vos tests : 1.Simulateur natif : OK, passez ici et continuez. 2.Simulateur Genymotion : Pas de problème, Genymotion Shell ne peut pas exécuter les commandes suivantes 3.Vraie machine (rootée) : Ensuite, ouvrez l'Explorateur de fichiers et voyez s'il y a quelque chose dans le répertoire data/data/ ? Non? Voici une méthode qui consiste à installer d'abord un gestionnaire de fichiers RE, puis à accorder à RE des autorisations racine, puis à accéder au répertoire racine : Appuyez ensuite longuement sur le répertoire de données, et une boîte de dialogue comme celle-ci apparaîtra :
Attendez ensuite qu'il commence lentement modifiez les autorisations, et la modification est terminée. Enfin, on ouvre à nouveau l'Explorateur de fichiers de DDMS, et on peut voir :
D'accord, vous pouvez voyez les choses dans data/data ! ————————————————————————
2. Entrez le shell adb, puis tapez ce qui suit. commande pour accéder au répertoire des bases de données de notre application :
Saisissez ensuite les commandes suivantes dans l'ordre :
- sqlite3 my.db : ouvrez le fichier de base de données
- .table pour voir quelles tables se trouvent dans la base de données Ensuite, vous pouvez saisir directement l'instruction de la base de données, telle que requête : Select * from person
- .schema : Afficher l'instruction de création de table
- .quit : Quitte l'édition de la base de données
- .exit : Quitte la console de l'appareil
...car system/bin/sh sqlite3 : introuvable. Pour ce problème, les commandes SQLite suivantes ne peuvent pas être utilisées. Si vous voulez voir les rendus, consultez simplement le livre de Guo Daxia par vous-même ~ Mais ci-dessous, nous exportons toujours le fichier db d'abord, puis utilisons le graphique Outils de base de données à visualiser !
4. Utilisez l'API fournie par Android pour faire fonctionner SQLite
Si vous n'avez pas appris la syntaxe liée aux bases de données, ou si vous êtes paresseux et ne voulez pas écrire syntaxe de la base de données, vous pouvez utiliser Android, donnez-nous Fournit quelques méthodes API pour faire fonctionner la base de données. Écrivons un exemple simple pour couvrir l'utilisation de ces API !
Exemple de code :
Rendu des opérations :
Code d'implémentation :
La disposition est trop simple, seulement quatre Bouton, je ne le publierai plus, publiez simplement le code de MainActivity.java :
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 Utiliser les instructions SQL pour faire fonctionner la base de données
.Exemple de code : 1 Insérer des données :Bien sûr, vous avez peut-être appris SQL et pouvez écrire des instructions SQL associées, mais vous ne souhaitez pas utiliser les API fournies par Android. Vous pouvez directement utiliser les méthodes pertinentes fournies par SQLiteDatabase :
- execSQL(SQL,Object[]) : utilisez des instructions SQL avec des espaces réservés, il s'agit d'exécuter et de modifier la base de données. L'instruction SQL de contenu utilise
- rawQuery(SQL,Object[]) : utiliser l'opération de requête SQL avec un espace réservé De plus, j'ai oublié de présenter Curosr et les attributs associés plus tôt, je vais l'ajouter ici : ——L'objet Cursor est quelque peu similaire au ResultSet dans JDBC, l'ensemble de résultats ! L'utilisation est similaire. Voici une méthode pour déplacer le pointeur d'enregistrement du résultat de la requête :
- <. 🎜>move(offset) : Spécifiez le nombre de lignes à déplacer vers le haut ou vers le bas, un nombre entier signifie descendre ; un nombre négatif signifie monter !
- moveToFirst() : Le pointeur se déplace vers la première ligne et renvoie true avec succès, ce qui indique également qu'il y a des données
- moveToLast( ) : Le pointeur se déplace vers La dernière chose est qu'il renvoie true avec succès ;
- moveToNext() : Le pointeur se déplace vers la ligne suivante et renvoie true avec succès, indiquant qu'il y a encore des éléments. !
- moveToPrevious() : Passer à l'enregistrement précédent
- getCount( ) pour obtenir le nombre total de données
- isFirst() : S'il s'agit du premier enregistrement
- isLast() : S'il s'agit du dernier enregistrement
- moveToPosition (int) : Passer à la ligne spécifiée
public void save(Person p)
{
SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
db.execSQL("INSERT INTO person(name,phone) values(?,?)",
new String[]{p.getName(),p.getPhone()});
}
2. Supprimer des données : . public void delete(Integer id)
{
SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
db.execSQL("DELETE FROM person WHERE personid = ?",
new String[]{id});
}
3. Modifier les données : 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. Interroger les données : 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. Pagination des données : 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. >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
: En plus de la méthode ci-dessus pour obtenir le nombre d'éléments, vous pouvez également utiliser la méthode curseur.getCount() pour obtenir le nombre d'éléments de données. Mais l'instruction SQL doit être modifiée ! Par exemple, SELECT * FROM person;
Résumé de cette section :Cette section vous présente l'utilisation de base des fonctionnalités intégrées d'Android SQLite, qui est relativement simple Oui, nous étudierons un peu plus dans la section suivante. Des choses plus avancées, les transactions SQLite, comment traiter les données dans la base de données lorsque l'application les met à jour et comment stocker des fichiers binaires volumineux dans la base de données méthode! D'accord, c'est tout pour cette section ~
