tuto android et les bases de données.


Bonjour à tous,
Nous allons aborder aujourd’hui la conception d’une application reposant sur les bases de données.
Les bases de données sont un moyen de stocker une donnée dans un format que vous aurez choisi, le stockage est de façon permanent.
Vous pouvez aussi stocker les données au format Xml, texte, json etc…
Ce tutoriel portera uniquement sur le stockage avec le langage SQL voir la Définition SQL.
Android propose utilise le moteur SQL nommé SQLite voir sa Définition.
Le moteur SQLite accepte les types suivants de données
Type Définition
NULL Valeur vide
INTEGER Entier signé
REAL Nombre réel
TEXT Champ texte
BLOB Champ binaire
Le type boolean n’est qu’un entier ayant pour valeur 0 et 1
Pour les dates il y a plusieurs manières de procéder
  • Dans un champ TEXT : Format YYYY-MM-DD HH:MM:SS.SSS
  • Dans un champ REAL : Nombre de jour depuis Greenwich le 24 Novembre 4714 avant J.C
  • Dans un champ INTEGER : Nombre de seconde depuis le 01/01/1970 soit la date au format UNIX
Ne vous inquiétez pas SQLite possède des fonctions pour manipuler les dates.

Définition du projet

Nous allons créer une application pour faire nos courses, ça nous permettra d’avoir un contexte de compréhension.
Tout d’abord, il faut penser au format des données.
Dans notre cas une course sera :
  • Un produit
  • Une quantité
  • Un flag acheté (pour suivre notre avancement dans le magasin)
Nous devrons pouvoir Ajouter / Supprimer / Modifier un produit, ainsi que lister les produits.
Nous avons désormais notre contexte pour travailler, il faut maintenant coder tout cela.
Commençons par créer notre objet Course
1public class Course {
2
3    private int id;
4    private String produit;
5    private int quantite;
6    private boolean achete;
7
8    public Course(String produit, int quantite) {
9        this.produit = produit;
10        this.quantite = quantite;
11        this.achete = false;
12    }
13
14    public int getId() {
15        return id;
16    }
17    public void setId(int id) {
18        this.id = id;
19    }
20    public String getProduit() {
21        return produit;
22    }
23    public void setProduit(String produit) {
24        this.produit = produit;
25    }
26    public int getQuantite() {
27        return quantite;
28    }
29    public void setQuantite(int quantite) {
30        this.quantite = quantite;
31    }
32    public boolean isAchete() {
33        return achete;
34    }
35    public void setAchete(boolean achete) {
36        this.achete = achete;
37    }
38
39}
Abordons maintenant l’utilisation des bases de données.

SQLiteOpenHelper

Le but de cette classe est de permettre la création et l’utilisation des bases de données au sein de l’écosystème Android.
Commençons tout d’abord par créer une classe nommée CourseOpenHelper héritant de la classe SQLiteOpenHelper.
Puis nous allons rajouter des attributs statiques à notre classe
1// Version de la base de données
2private static final int DATABASE_VERSION = 1;
3
4// Nom de la base
5private static final String COURSE_BASE_NAME = "course.db";
6
7// Nom de la table
8public static final String COURSE_TABLE_NAME = "Course";
9
10// Description des colonnes
11public static final String COLUMN_ID = "ID";
12public static final int NUM_COLUMN_ID = 0;
13public static final String COLUMN_PRODUIT = "PRODUIT";
14public static final int NUM_COLUMN_PRODUIT = 1;
15public static final String COLUMN_QUANTITE = "QUANTITE";
16public static final int NUM_COLUMN_QUANTITE = 2;
17public static final String COLUMN_ACHETE = "ACHETE";
18public static final int NUM_COLUMN_ACHETE = 3;
19
20// Requête SQL pour la création da la base
21private static final String REQUETE_CREATION_BDD = "CREATE TABLE "
22        + COURSE_TABLE_NAME + " (" + COLUMN_ID
23        + " INTEGER PRIMARY KEY AUTOINCREMENT, " + COLUMN_PRODUIT
24        + " TEXT NOT NULL, " + COLUMN_QUANTITE + " INTEGER NOT NULL, "
25        + COLUMN_ACHETE + " INTEGER NOT NULL);";
Nous avons donc :
  • Version de la base de données (pour les mises à jour)
  • Nom de la base (nom du fichier)
  • Nom de la table (Course pour nous)
  • Description des colonnes, ainsi que leur position (0..n)
  • La requête de création de la base
Et pour finir nos méthodes
1public CourseOpenHelper(Context context, CursorFactory factory) {
2    super(context, COURSE_BASE_NAME, factory, DATABASE_VERSION);
3}
4
5/**
6 * Création de la base
7 */
8@Override
9public void onCreate(SQLiteDatabase db) {
10    db.execSQL(REQUETE_CREATION_BDD);
11}
12
13/**
14 * Mise à jour de la base
15 */
16@Override
17public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
18    // Lorsque l'on change le numéro de version de la base on supprime la
19    // table puis on la recrée
20    if (newVersion > DATABASE_VERSION) {
21        db.execSQL("DROP TABLE " + COURSE_TABLE_NAME + ";");
22        onCreate(db);
23    }
24}
Notre méthode onCreate sera appelée si la base n’existe pas, la méthode onUpgrade sera appelée si une mise à jour est à faire.
J’espère que vous suivez toujours   :smile:

Repository

Vous en avez peut être déjà entendu parler, en français c’est un dépôt. Il sert à faire la jonction avec notre base de données.
Comme ça en cas d’évolution on n’impacte pas la vue (layout) si ce n’est qu’un correctif ou une modification de la façon d’allez chercher nos données, c’est tout de même plus propre et je vous le conseil fortement.
Créons pour commencer une interface nommée IRepository qui sera générique (gné ?) voir ce tutoriel 
1public interface IRepository {
2
3    public List GetAll();
4    public T GetById(int id);
5
6    public void Save(T entite);
7    public void Update(T entite);
8    public void Delete(int id);
9
10    public List ConvertCursorToListObject(Cursor c);
11    public T ConvertCursorToObject(Cursor c);
12    public T ConvertCursorToOneObject(Cursor c);
13}
Alors nos méthodes :
  • GetAll : Retourne la liste des données
  • GetById : Retourne un objet unique
  • Save : Enregistre un objet
  • Update : Met à jour un objet
  • Delete : Supprime un objet
  • ConvertCursorToListObject : Converti un curseur en une liste d’objet
  • ConvertCursorToObject : Converti un curseur en un objet
  • ConvertCursorToOneObject : Converti un curseur en un seul objet
En suite il va nous falloir la base de notre Repository
Toujours une classe générique mais abstraite
1public abstract class Repository implements IRepository {
2    // Base de données
3    protected SQLiteDatabase maBDD;
4
5    protected SQLiteOpenHelper sqLiteOpenHelper;
6
7    /**
8     * Constructeur par défaut
9     */
10    public Repository() {
11
12    }
13
14    /**
15     * Ouverture de la connection
16     */
17    public void Open() {
18        maBDD = sqLiteOpenHelper.getWritableDatabase();
19    }
20
21    /**
22     * Fermeture de la connection
23     */
24    public void Close() {
25        maBDD.close();
26    }
27}
Cette classe comprend deux méthodes et deux attributs.
Attributs :
  • maBDD : Relation avec la base de données SQLite
  • sqLiteOpenHelper : Notre helper pour traiter avec la base
Méthodes :
  • Constructeur
  • Open : Permet d’ouvrir la liaison avec la base
  • Close : Ferme la liaison
Pour terminer implémentons notre CourseRepository
1public class CourseRepository extends Repository {
2
3    public CourseRepository(Context context) {
4        sqLiteOpenHelper = new CourseOpenHelper(context, null);
5    }
6
7    /**
8     * Suppression d'un produit
9     *
10     * @param id
11     */
12    public void DeleteProduit(int id) {
13        maBDD.delete(CourseOpenHelper.COURSE_TABLE_NAME,
14                CourseOpenHelper.COLUMN_ID + "=?",
15                new String[] { String.valueOf(id) });
16    }
17
18    /**
19     * Récupération de la liste de tous les produits
20     */
21    @Override
22    public List GetAll() {
23        // Récupération de la liste des courses
24        Cursor cursor = maBDD.query(CourseOpenHelper.COURSE_TABLE_NAME,
25                new String[] { CourseOpenHelper.COLUMN_ID,
26                        CourseOpenHelper.COLUMN_PRODUIT,
27                        CourseOpenHelper.COLUMN_QUANTITE,
28                        CourseOpenHelper.COLUMN_ACHETE }, null, null, null,
29                null, null);
30
31        return ConvertCursorToListObject(cursor);
32    }
33
34    /**
35     * Retourne un seul produit
36     */
37    @Override
38    public Course GetById(int id) {
39        Cursor cursor = maBDD.query(CourseOpenHelper.COURSE_TABLE_NAME,
40                new String[] { CourseOpenHelper.COLUMN_ID,
41                        CourseOpenHelper.COLUMN_PRODUIT,
42                        CourseOpenHelper.COLUMN_QUANTITE,
43                        CourseOpenHelper.COLUMN_ACHETE },
44                CourseOpenHelper.COLUMN_ID + "=?",
45                new String[] { String.valueOf(id) }, null, null, null);
46
47        return ConvertCursorToObject(cursor);
48    }
49
50    /**
51     * Enregistre en produit dans la base
52     */
53    @Override
54    public void Save(Course entite) {
55        ContentValues contentValues = new ContentValues();
56        contentValues.put(CourseOpenHelper.COLUMN_PRODUIT, entite.getProduit());
57        contentValues.put(CourseOpenHelper.COLUMN_QUANTITE,
58                entite.getQuantite());
59        contentValues.put(CourseOpenHelper.COLUMN_ACHETE, entite.isAchete());
60
61        maBDD.insert(CourseOpenHelper.COURSE_TABLE_NAME, null, contentValues);
62    }
63
64    /**
65     * Met à jour un produit
66     */
67    @Override
68    public void Update(Course entite) {
69        ContentValues contentValues = new ContentValues();
70        contentValues.put(CourseOpenHelper.COLUMN_PRODUIT, entite.getProduit());
71        contentValues.put(CourseOpenHelper.COLUMN_QUANTITE,
72                entite.getQuantite());
73        contentValues.put(CourseOpenHelper.COLUMN_ACHETE, entite.isAchete());
74
75        maBDD.update(CourseOpenHelper.COURSE_TABLE_NAME, contentValues,
76                CourseOpenHelper.COLUMN_ID + "=?",
77                new String[] { String.valueOf(entite.getId()) });
78    }
79
80    /**
81     * Supprime un produit
82     */
83    @Override
84    public void Delete(int id) {
85        maBDD.delete(CourseOpenHelper.COURSE_TABLE_NAME,
86                CourseOpenHelper.COLUMN_ID + "=?",
87                new String[] { String.valueOf(id) });
88    }
89
90    /**
91     * Converti un curseur en une liste de produits
92     */
93    @Override
94    public List ConvertCursorToListObject(Cursor c) {
95        List liste = new ArrayList();
96
97        // Si la liste est vide
98        if (c.getCount() == 0)
99            return liste;
100
101        // position sur le premeir item
102        c.moveToFirst();
103
104        // Pour chaque item
105        do {
106
107            Course course = ConvertCursorToObject(c);
108
109            liste.add(course);
110        } while (c.moveToNext());
111
112        // Fermeture du curseur
113        c.close();
114
115        return liste;
116    }
117
118    /**
119     * Méthode utilisée par ConvertCursorToObject et ConvertCursorToListObject
120     */
121    @Override
122    public Course ConvertCursorToObject(Cursor c) {
123
124        Course course = new Course(
125                c.getString(CourseOpenHelper.NUM_COLUMN_PRODUIT),
126                c.getInt(CourseOpenHelper.NUM_COLUMN_QUANTITE));
127        course.setId(c.getInt(CourseOpenHelper.NUM_COLUMN_ID));
128        course.setAchete((c.getInt(CourseOpenHelper.NUM_COLUMN_ACHETE) != 0));
129
130        return course;
131    }
132
133    /**
134     * Converti un curseur en un produit
135     */
136    @Override
137    public Course ConvertCursorToOneObject(Cursor c) {
138        c.moveToFirst();
139
140        Course course = ConvertCursorToObject(c);
141
142        c.close();
143        return course;
144    }
145}
Oulala c’est du lourd !
Pour mieux comprendre, toutes actions effectuées de type Get en base (retour d’un ou plusieurs objets) retourne un curseur.
Ce curseur comprend l’intégralité de ce que vous avez demandé, il faut juste passer sur chaque ligne retournée pour l’affectée à un objet, dans notre cas un objet Course.
Pour faire un Save, Delete, Update, GetAll ou encore GetById on utilise simplement une commande fournie par Android.
Dans le cas d’un Save,Delete,Update nous utiliserons un objet ContentValues qui transportera nos données.
Enfin de compte il n’y a rien de plus simple !
N’oubliez pas de refermer vos curseurs après utilisations (c’est comme les BIC , sinon ça sèche).
De plus n’oubliez pas d’ouvrir votre connexion avec la base avant un traitement et de la refermée ensuite.
Exemple :
1public void DeleteItem(int id) {
2    courseRepository.Open();
3    courseRepository.Delete(id);
4    courseRepository.Close();
5}
Je n’expliquerais pas le programme au complet, car la suite ce n’est qu’une Listview, un menu et des boutons (déjà vu dans les autres chapitres).
Mais voici ce que vous devriez avoir à la fin  :happy:
   

Share this article :
 

Enregistrer un commentaire