Introduction à cette section :

Dans cette section, nous continuons à découvrir la troisième méthode de stockage et d'accès aux données Android : la base de données SQLite. Contrairement à d'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. Le système Android a déjà intégré cette base de données, donc nous n'avons pas à nous embêter à installer et configurer d'autres logiciels de base de données (Oracle, MSSQL, MySQL, etc.), ni à changer de ports ! Voilà pour l'introduction. Maintenant, découvrons cette chose~


1. Concepts de base

1) Qu'est-ce que SQLite ? Pourquoi utiliser SQLite ? Quelles sont les caractéristiques de SQLite ?

Réponse : Je vais l'expliquer en détail ci-dessous :

①SQLite est une base de données relationnelle légère, rapide en exécution et à faible consommation de ressources, très adaptée aux appareils mobiles. Elle prend non seulement en charge la syntaxe SQL standard, mais respecte aussi les principes ACID (transaction de base de données). Elle ne nécessite aucun compte et est très pratique à utiliser !

②Précédemment, nous avons appris à utiliser des fichiers et SharedPreferences pour enregistrer des données, mais dans de nombreux cas, les fichiers ne sont pas forcément efficaces, par exemple lorsqu'il y a des accès concurrents multithread ; les applications doivent gérer des structures de données complexes susceptibles de changer, etc. ! Par exemple, déposer et retirer de l'argent dans une banque ! Utiliser les deux premières méthodes semblerait inefficace ou fastidieux. L'arrivée des bases de données peut résoudre ce problème, et Android nous fournit une SQLite si légère, alors pourquoi ne pas l'utiliser ?

③SQLite prend en chargecinq types de données: NULL, INTEGER, REAL (nombre à virgule flottante), TEXT (texte de chaîne), et BLOB (objet binaire). Bien qu'il n'y en ait que cinq, elle peut quand même stocker d'autres types de données tels que varchar, char, etc. C'est parce que SQLite possède une caractéristique majeure :Vous pouvez enregistrer des données de n'importe quel type dans n'importe quel champ sans vous soucier du type de données déclaré pour le champ.Par exemple, vous pouvez stocker une chaîne dans un champ Integer. Bien sûrsauf pour les champs déclarés comme PRIMARY KEY INTEGER PRIMARY KEY, qui ne peuvent stocker que des entiers 64 bits.! De plus, lorsque SQLite analyse les instructions CREATE TABLE, il ignore les informations de type de données qui suivent le nom du champ dans l'instruction CREATE TABLE. Par exemple, l'instruction suivante ignore les informations de type du champ name :CREATE TABLE person (personid integer primary key autoincrement, name varchar(20))

Résumé des fonctionnalités :

SQLite utilisedes fichierspour enregistrer la base de données. Un fichier est unebase de données, et une base de données contient plusieurstables, et une table a plusieursenregistrements, chaque enregistrement est constitué de plusieurschamps, chaque champ a unevaleur correspondante, et pour chaque valeur nous pouvons spécifierun type, ou choisir de ne pas spécifier de type (sauf pour les clés primaires).

PS: Au fait, le SQLite intégré à Android est la version SQLite 3~

2) Plusieurs classes associées :

Héhé, lorsqu'on apprend quelque chose de nouveau, ce que nous détestons le plus, c'est de rencontrer de nouveaux termes, n'est-ce pas ? Parlons d'abord des trois classes que nous utilisons lorsque nous travaillons avec la base de données :

  • SQLiteOpenHelper: Classe abstraite. En héritant de cette classe, nous redéfinissons les méthodes de création et de mise à jour de la base de données. Nous pouvons é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 des objets de cette classe pour effectuer des opérations telles que l'insertion, la suppression, la mise à jour et l'interrogation sur la base de données.
  • Cursor: Curseur, un peu similaire à ResultSet dans JDBC, un jeu de résultats ! On peut simplement le comprendre comme un pointeur pointant vers un enregistrement particulier de la base de données.

2. Utilisation de la classe SQLiteOpenHelper pour créer des bases de données et gérer les versions

Pour les applications impliquant une base de données, nous ne pouvons pas créer manuellement le fichier de base de données pour elles, donc nous devons créer la table de base de données lors du premier lancement de l'application. Et lorsque notre application est mise à niveau et que la structure de la table de base de données doit être modifiée, la table de base de données doit être mise à jour. Pour ces deux opérations, Android nous fournitSQLiteOpenHelperdeux méthodes,onCreate( )et onUpgrade() à implémenter.

Analyse des méthodes:

  • onCreate(database): Génère la table de base de données lors de la première utilisation du logiciel.
  • onUpgrade(database,oldVersion,newVersion): Il est appelé lorsque la version de la base de données change. En général, le numéro de version ne doit être modifié que lors d'une mise à niveau du logiciel. La version de la base de données est contrôlée par le programmeur. Supposons que la version actuelle de la base de données soit 1. En raison de changements métier, la structure de la table de base de données est modifiée. À ce moment-là, le logiciel doit être mis à niveau. Lors de la mise à niveau du logiciel, vous souhaitez mettre à jour la structure de la table de base de données sur le téléphone de l'utilisateur. Pour atteindre cet objectif, vous pouvez définir la version d'origine de la base de données 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 : lorsque l'application est démarrée pour la première fois, nous créons le fichier my.db et exécutons la méthode dans onCreate(), créant une table Person. Elle a deux champs : la clé primaire personId et le champ name. Ensuite, si nous modifions le numéro de version de la base de données, au prochain démarrage la méthode dans onUpgrade() sera appelée, insérant un autre champ dans la table ! De plus, comme un champ est inséré ici, les données ne seront pas perdues. Si la table était reconstruite, toutes les données de la table seraient perdues. Dans la section suivante, nous vous apprendrons comment résoudre ce problème !

Résumé du processus:

  • Étape 1: Définissez une classe personnalisée qui hérite de SQLiteOpenHelper.
  • Étape 2: Dans le super() du constructeur de cette classe, définissez le nom de la base de données et le numéro de version à créer.
  • Étape 3: Redéfinir la méthode onCreate() pour créer la structure de la table.
  • Étape 4: Redéfinir la méthode onUpgrade() pour définir les opérations à effectuer lorsque le numéro de version change.

3. Comment visualiser le fichier db que nous avons généré

Lorsque nous appelons getWritableDatabase() sur l'objet MyDBOpenhelper ci-dessus, notre fichier de base de données db sera créé dans le répertoire suivant :

Nous constatons qu'il y a deux bases de données. La première est la base de données que nous avons créée, tandis que la seconde est un fichier journal temporaire généré pour permettre à la base de données de prendre en charge les transactions ! Sa taille est généralement de 0 bytes ! Mais dansl'Explorateur de fichiers, là-dedans, nous ne pouvons vraiment pas ouvrir de fichiers ; même un txt ne peut pas être ouvert, encore moins un .db ! Voici donc deux chemins parmi lesquels choisir :

  • 1. Exportez-le d'abord, puis visualisez-le avec un outil graphique SQLite.
  • 2. Après avoir configuré les variables d'environnement adb, visualisez-le via adb shell (ligne de commande, un outil pour frimer) !

Bon, ensuite je vais démontrer les deux méthodes ci-dessus. Choisissez simplement celle que vous aimez~~


Méthode 1 : Utiliser un outil graphique SQLite pour visualiser le fichier db

Il existe de nombreux logiciels de ce type. L'auteur utilise SQLite Expert Professional. Bien sûr, vous pouvez aussi utiliser d'autres outils. Si besoin, vous pouvez télécharger :SQLiteExpert.zip

Exportez notre fichier db vers le bureau de l'ordinateur, ouvrez SQLiteExpert, et l'interface est la suivante :

Ne me demandez pas comment l'utiliser. Après avoir importé le db, manipulez-le vous-même. Il est facile à utiliser ; si vous ne comprenez pas, cherchez simplement sur Baidu~


Quant à la méthode 2, je voulais initialement l'essayer, mais j'ai ensuite découvert que la commande sqlite était introuvable. Après quelques tentatives, j'ai abandonné. J'y regarderai de plus près plus tard quand ce sera nécessaire. Si cela vous intéresse, vous pouvez trouver « Première ligne de code — Android » de Guo Lin et essayer de suivre l'organigramme ! Ici, je ne publie que la première partie ; la partie sur les commandes est à lire dans le livre !

Méthode 2 : la ligne de commande adb shell vous permet de frimer et de prendre de la hauteur

1. Configurer les variables d'environnement du SDK :

Faites un clic droit sur Ordinateur ——> Paramètres système avancés -> Variables d'environnement -> Nouvelle variable système-> Copiez le chemin platform-tools du SDK : Par exemple, celui de l'auteur :C:\Software\Coding\android-sdks-as\platform-tools

Confirmez, puis trouvez la variable d'environnement Path, modifiez-la et ajoutez à la fin :%SDK_HOME%;

Ouvrez ensuite la ligne de commande, saisissez adb, et tout un tas de choses vont défiler, ce qui signifie que la configuration a réussi !

——————Point clé——————: Avant d'exécuter les instructions de ligne de commande suivantes, il peut y avoir plusieurs cas pour votre machine de test : 1.Émulateur natifTrès bien, passez cette partie et continuez ci-dessous.Émulateur GenymotionPas de chance, Genymotion Shell ne peut pas exécuter les commandes suivantes.Appareil réel (rooté)Ouvrez ensuiteExplorateur de fichiersVérifiez s'il y a quelque chose dans le répertoire data/data/ ? Rien ? Voici une méthode : installez d'abord unRE File Manager, puis accordez à REla permission Root, puis allez dans le répertoire racine : Ensuite, appuyez longuement sur le répertoire data, et une boîte de dialogue comme celle-ci apparaîtra :

Ensuite, attendez qu'il modifie lentement les permissions. Une fois la modification terminée, rouvrez l'Explorateur de fichiersde DDMS, nous pouvons voir :

Parfait, maintenant nous pouvons voir ce qu'il y a dans data/data !——————————————————————

2. Entrez dans adb shell, puis tapez la commande suivante pour aller dans le répertoire des bases de données de notre application :

Ensuite, saisissez les commandes suivantes dans l'ordre :

  • sqlite3my.db : ouvre le fichier de base de données
  • .tableAffiche les tables présentes dans la base de données. Vous pouvez ensuite saisir directement des instructions de base de données, comme une requête : Select * from person
  • .schema: Afficher l'instruction CREATE TABLE
  • .quit: Quitter l'édition de la base de données
  • .exit: Quitter la console de l'appareil

...À cause du problème "system/bin/sh sqlite3: not found", toutes les commandes SQLite suivantes ne fonctionneront pas. Pour les captures d'écran du résultat, consultez vous-même le livre de Guo Daxia~ Ci-dessous, commençons par exporter le fichier db, puis utilisons un outil de base de données graphique pour le consulter !


4. Utilisation des API Android pour manipuler 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 de syntaxe de base de données, vous pouvez utiliser certaines méthodes d'API fournies par Android pour manipuler les bases de données. Ci-dessous, nous allons écrire un exemple simple pour démontrer l'utilisation de ces API !

Exemple de code:

Capture d'écran de l'effet d'exécution:

Code d'implémentation:

La mise en page est trop simple, juste quatre Buttons, donc je ne la publierai pas, je publierai seulement le code deMainActivity.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. Utilisation d'instructions SQL pour manipuler la base de données

Bien sûr, vous avez peut-être appris SQL et savez écrire les instructions SQL correspondantes, et vous ne voulez pas utiliser les API fournies par Android. Vous pouvez utiliser directement les méthodes associées fournies par SQLiteDatabase :

  • execSQL(SQL,Object[]) : Utilisez des instructions SQL avec des espaces réservés ; ceci sert à exécuter des instructions SQL qui modifient le contenu de la base de données
  • rawQuery(SQL,Object[]) : Utilisez des opérations de requête SQL avec des espaces réservés De plus, j'ai oublié d'introduire l'objet Cursor et ses propriétés associées plus tôt. Voici un complément : ——CursorL'objet est quelque peu similaire à ResultSet dans JDBC, un jeu de résultats ! L'utilisation est similaire. Les méthodes suivantes déplacent le pointeur d'enregistrement du résultat de la requête :
  • move(offset) : Spécifie le nombre de lignes à déplacer vers le haut ou vers le bas ; un entier positif signifie un déplacement vers le bas ; un nombre négatif signifie un déplacement vers le haut !
  • moveToFirst() : Déplace le pointeur vers la première ligne ; renvoie true en cas de succès, ce qui indique aussi qu'il y a des données
  • moveToLast() : Déplace le pointeur vers la dernière ligne ; renvoie true en cas de succès ;
  • moveToNext() : Déplace le pointeur vers la ligne suivante ; renvoie true en cas de succès, ce qui indique qu'il reste encore des éléments !
  • moveToPrevious() : Déplace vers l'enregistrement précédent
  • getCount() : Obtient le nombre total d'enregistrements de données
  • isFirst() : Indique s'il s'agit du premier enregistrement
  • isLast() : Indique s'il s'agit du dernier élément
  • moveToPosition(int) : Déplace vers la ligne spécifiée

Exemple de code d'utilisation :

1. Insertion de données :

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

2. Suppression de données :

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

3. Modification de 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. Interrogation des 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. Interrogation du nombre d'enregistrements :

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, vous pouvez également utiliser la méthode cursor.getCount() pour obtenir le nombre d'enregistrements de données, mais l'instruction SQL doit être modifiée ! Par exempleSELECT * FROM person;


Résumé de cette section :

Cette section a présenté l'utilisation de base de SQLite intégré à Android. C'est encore relativement simple. Dans la section suivante, nous explorerons quelque chose d'un peu plus avancé : les transactions SQLite, comment gérer les données de la base de données lorsque l'application est mise à jour, et les méthodes pour stocker de gros fichiers binaires dans la base de données ! Bon, c'est tout pour cette section~