zied-virus

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

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.

GetAll / GetById : Query (String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy)
Save : Insert (String table, String nullColumnHack, ContentValues values)
Update : Update (String table, ContentValues values, String whereClause, String[] whereArgs)
Delete : Delete (String table, String whereClause, String[] whereArgs)

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