Android : Base de données SQLite

05 décembre 2012 rdorigny 0 commentaires

SQLite est un système de base de donnée natif sous Android, donc pas nécessaire de l'installer. Il est possible de l'utiliser comme une base de données relationnelle dans vos applications. L'avantage par rapport aux PreferedShared est que la base de donnée est faite pour traiter des données structurées.

Attention cependant, les mobiles disposent de ressources limitées, il faudra un système simple et SQLite est parfaitement adaptée. A noter que SQLite ne fonctionne pas comme un serveur, donc pas comme la plupart des SGBDD. Un seul processus sera en mesure de travailler avec la base qui sera dédiée à l'application (les autre applications ou processus ne pourront pas accéder à cette BDD).

1)Création d'une base de données SQLite pour votre application Android

Nous allons réaliser une application qui permet d'enregistrer des commentaires et de les afficher. Pour cela, il faut initier la base de données, ce que nous allons faire.

Pour créer la base de données, il faut créer une classe qui hérite de la classe SQLiteOpenHelper puis surchager la méthodes onCreate() pour créer la base et la méthode onUpgrade() si on veut modifier le modèle de données. La méthode execSQL permet d'éxecuter une requête SQL pour la création de la base par exemple.

La classe MybddOpenHelper
package fr.doritique.testsqlite; import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteDatabase.CursorFactory; import android.database.sqlite.SQLiteOpenHelper; public class MybddOpenHelper extends SQLiteOpenHelper{ private static final String SQL="create table comments (_id integer primary key autoincrement, comment text not null);"; public MybddOpenHelper(Context context,String nom, CursorFactory cursorfactory, int version) { super(context, nom, cursorfactory, version); // TODO Auto-generated constructor stub } @Override public void onCreate(SQLiteDatabase db) { // TODO Auto-generated method stub db.execSQL(SQL); } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // TODO Auto-generated method stub db.execSQL("drop table comments;"); onCreate(db); } }

Le fichier MainActivity.java:
package fr.doritique.testsqlite; import android.os.Bundle; import android.app.Activity; import android.content.Context; import android.database.sqlite.SQLiteDatabase; public class MainActivity extends Activity { private static final String BDD_NAME="mabase"; private static final int BDD_VERSION=1; private Context context; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); context = getBaseContext(); MybddOpenHelper myhelper=new MybddOpenHelper(context, BDD_NAME, null, BDD_VERSION); SQLiteDatabase db=myhelper.getReadableDatabase(); } }


Si vous l'utilisez vous trouverez votre base sous /DATA/data/nom_app/databases/file .

2)Traitements avec la base de données

2.1)Généralités

Les bons usages veulent que l'on créé une classe intermédiaire appelée adapteur, elle permet de définir des méthodes simplifiées en transmettant ou recevant les données ce qui permet de faire abstraction des méthodes complexes de traitement des BDD d'Android.

La classe adapteur définit un constructeur pour créer le SQLiteOpenHelper, ensuite il suffit d'ouvrir la base de données avec la méthode:
  • getReadable: ouvre une instance SQLiteDatabase en lecture seule,
  • getWritable: ouvre une instance SQLiteDatabase en lecture/écriture.

    • Avec l'ouverture d'une instance de notre classe SQLiteOpenHelper, Android appellera la méthode de création de la base. Ensuite, il suffira de créer les geters et seters, les méthodes d'insertion, de mise à jour, de sélection, de suppression dans la base de données, ... Et l'idée sera d’appeler ces méthodes simplifiés dans nos applications.

    2.2)Effectuer une sélection

    Pour faire une sélection, on utilise la méthode query (le nom est trompeur...) de la classe SQLiteDatabase tel que :
    db.query(distinct, table, colums, selection, SelectionArgs, groupby, having, orderby, limit);
    avec:
  • distinct: donne que les éléments uniques, ce champ n'est pas obligatoire,
  • table: le nom de la table à requêter,
  • colums: précise les champs qui devront être retournés,
  • SelectionArgs: des arguments associés aux champs attendus,
  • groupBy: filtre des regroupements de ligne,
  • having: filtre selon des conditions à préciser,
  • orderBy: tri selon des critères à préciser,
  • limit: limite la taille du retour.

    • La méthode retourne un curseur de la classe Cursor, qui est en fait la liste des résultats. L'objet Cursor dispose des méthodes dans la listes des réponses:
  • moveToFirst: positionne le curseur sur la première ligne du tableau des réponses,
  • moveToLast: positionne le curseur sur la dernière ligne du tableau des réponses,
  • moveToNext: positionne le curseur sur la ligne suivante du tableau des réponses,
  • moveToPrevious: positionne le curseur sur la ligne précédente du tableau des réponses,
  • moveToPosition(int): positionne le curseur sur la ligne passée en paramètre.
  • getCount: retourne le nombre de ligne du tableau,
  • getColumName(int): retourne le nom de colonne de la variable,
  • getColumnNames: retourne un tableau des noms des colonnes retournées,
  • getColumnCount: retourne le nombre de colonnes,
  • getString(colonne): retourne une chaîne de caractère,
  • getInt(colonne): retourne un entier 32 bits,
  • getLong(colonne): retourne un entier long 64 bits,
  • getInt(colonne): retourne un entier,
  • getBlob(colonne): retourne un tableau de bytes,
  • getFloat(colonne): retourne un nombre flottant 32 bits,
  • getDouble(colonne): retourne un nombre double 64 bits,
  • getShort(colonne): retourne un entier court sur 16 bits,
  • close: ferme Curseur et libère la mémoire.

    • 2.3) Insérer les données

    Pour insérer un enregistrement dans la base de données, il existe la méthode insert. Il faudra passer par un objet ContentValues qui est une collection des champs à enregistrer pour former l'enregistrement.
    public long savecomment(String comment){ ContentValues val=new ContentValues(); val.put(KEY_COMMENT, comment); return db.insert(DATABASE_TABLE, null, val); }

    2.4)Mettre à jour les données

    De la même façon, la classe SQLiteDatabase propose la méthode update. A noter, que cette méthode propose en sus un champ correspondant where de la requête SQL.
    public long majcomment(int id, String comment){ ContentValues val=new ContentValues(); val.put(KEY_COMMENT, comment); return db.insert(DATABASE_TABLE, val,"_id=id",null); }

    2.5)Supprimer des données

    Pour finir, la classe SQLiteDatabase propose la méthode update. A noter, que cette méthode propose en sus un champ correspondant where de la requête SQL.
    public long deletecomment(int id, String comment){ return db.delete(DATABASE_TABLE,"_id=id",null); }

    3)Exemple d'utilisation d'une base de données SQLite

    Le mieux pour illustrer la mise en oeuvre de SQLite, c'est de créer une petite application comme exemple. Nous allons donc créer une application dans laquelle l'usager rédigera un commentaire et l'enregistrera en validant le formulaire.

    Pour ce faire, nous allons tout d'abord créer une classe qui gérera la création de la base de données, puis une classe adapter et pour finir le programme principale Android.

    Le fichier MybddOpenHelper.java qui gère la création de la BDD ou de la mise à jour du modèle de données:
    package fr.doritique.testsqlite; import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteDatabase.CursorFactory; import android.database.sqlite.SQLiteOpenHelper; public class MybddOpenHelper extends SQLiteOpenHelper{ private static final String SQL="create table comments (_id integer primary key autoincrement, comment text not null);"; private static final String BDD_NAME="mabase"; private static final int BDD_VERSION=1; public MybddOpenHelper(Context context,String nom, CursorFactory cursorfactory, int version) { super(context, BDD_NAME, null, BDD_VERSION); // TODO Auto-generated constructor stub } @Override public void onCreate(SQLiteDatabase db) { // TODO Auto-generated method stub db.execSQL(SQL); } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // TODO Auto-generated method stub //db.execSQL("drop table comments;"); //onCreate(db); } }

    Le fichier adapter CommentAdapter.java pour simplifier l'usage de la BDD:
    package fr.doritique.testsqlite; import android.content.ContentValues; import android.content.Context; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; public class CommentAdapter { public static final String KEY_ROWID="_id"; public static final String KEY_COMMENT="comment"; public static final String DATABASE_TABLE="comments"; private static final String BDD_NAME="mabase"; private static final int BDD_VERSION=1; private SQLiteDatabase db; private MybddOpenHelper dbhelper; private Context context; public CommentAdapter(Context context){ //dbhelper=new MybddOpenHelper(context, BDD_NAME, null, BDD_VERSION); this.context=context; } public CommentAdapter open(){ dbhelper=new MybddOpenHelper(context, BDD_NAME, null, BDD_VERSION); db=dbhelper.getWritableDatabase(); return this; } public void close() { dbhelper.close(); } public long savecomment(String comment){ ContentValues val=new ContentValues(); val.put(KEY_COMMENT, comment); return db.insert(DATABASE_TABLE, null, val); } public Cursor fetchAllComments(){ return db.query(DATABASE_TABLE,new String[] {KEY_ROWID,KEY_COMMENT},null,null,null,null,null); } }

    La vue principale activity_main.xml:
    <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <LinearLayout android:layout_width="fill_parent" android:layout_height="wrap_content" android:orientation="vertical"> <EditText android:id="@+id/edt_ajouter" android:hint="Ajouter un commentaire..." android:layout_width="fill_parent" android:layout_height="wrap_content"/> <Button android:id="@+id/bt_ajouter" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Ajouter"/> </LinearLayout> <ListView android:id="@android:id/list" android:layout_width="fill_parent" android:layout_height="wrap_content"/> </LinearLayout>

    Le fichier MainActivity.java:
    package fr.doritique.testsqlite; import android.os.Bundle; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.EditText; import android.widget.SimpleCursorAdapter; import android.app.ListActivity; import android.database.Cursor; public class MainActivity extends ListActivity { private CommentAdapter db; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); fetchAllComment(); Button bt_ajouter=(Button) findViewById(R.id.bt_ajouter); bt_ajouter.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { EditText edt_ajouter=(EditText) findViewById(R.id.edt_ajouter); saveComment(edt_ajouter.getText().toString()); } }); } private void saveComment(String comment){ db=new CommentAdapter(this); db.open(); if (comment.trim().length()>0) db.savecomment(comment); fetchAllComment(); } private void fetchAllComment(){ String[] from=new String[] {CommentAdapter.KEY_COMMENT}; int[] to=new int[] {android.R.id.text1}; db=new CommentAdapter(this); db.open(); Cursor c=db.fetchAllComments(); SimpleCursorAdapter adapter =new SimpleCursorAdapter(this,android.R.layout.simple_list_item_1,c,from,to); setListAdapter(adapter); } @Override public void onBackPressed() { db.close(); super.onBackPressed(); } @Override protected void onPause() { db.close(); super.onPause(); } }

    Ce qui donne notre application, il suffit de taper votre commentaire et de cliquer sur bouton Ajouter pour l’enregistrer.


    Conclusion

    Dans ce chapitre, nous avons vu comment intégrer la base de données SQLite dans une application mobile Android. Evidemment, l'usage des bases de données est pensé pour stocker des informations structurées, et souvent complexes. Google a voulu un système simple à mettre en oeuvre et robuste, autre aspect important le SGBD doit être peu gourmand en ressources systèmes.

    Bref, utilisez SQLite dans vos applications, nous l'avons vu, l'utilisation est relativement simple, native et surtout adaptée à Android!





    Pseudonyme (obligatoire) :
    Adresse mail (obligatoire) :
    Site web :




    © 2024 www.doritique.fr par Robert DORIGNY