🤞🏽 🚶🏿 🧒🏼 Utilisation de la base de données de valeurs-clés de Snappy dans Android 🧘🏼 👐 👨🏾‍💼

SnappyDB - Base de données de valeurs-clés NoSQL pour Android. Il est assez facile à utiliser et constitue une bonne option si vous souhaitez utiliser la version NoSQL de la base de données dans votre projet (plus de détails ici ).
Selon les développeurs, Snappy est plus rapide en écriture et en lecture que SQLite:

Commençons donc. Vous devez d'abord ajouter des dépendances à build.gradle: Maintenant, commençons directement à travailler avec la base de données elle-même. Tout d'abord, découvrons comment utiliser SnappyDB pour travailler avec des types et des tableaux primitifs, les enregistrer et les récupérer. Pour plus de clarté, créez un petit balisage:

implementation 'com.snappydb:snappydb-lib:0.5.2'
implementation 'com.esotericsoftware.kryo:kryo:2.24.0'

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/filmNameTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="25sp"
        android:layout_centerInParent="true"
        android:layout_margin="8dp"
        />

    <TextView
        android:id="@+id/filmBudgetTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:textSize="25sp"
        android:layout_below="@+id/filmNameTextView"
        android:layout_margin="8dp"
        />

    <TextView
        android:id="@+id/genreTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:textSize="25sp"
        android:layout_below="@id/filmBudgetTextView"
        android:layout_margin="8dp"
        />

    <TextView
        android:id="@+id/isAdult"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/genreTextView"
        android:textSize="25sp"
        android:layout_centerInParent="true"
        />
</RelativeLayout>

Disons que nous allons stocker les données de film dans notre base de données

Dans MainActivity, nous allons créer la méthode PutValues:

private void putValues(String name, int budget, boolean isAdult, String[] genres) throws SnappydbException {
        DB snappyDB = DBFactory.open(this,"Film");
        //     Film (      open)

        snappyDB.put("Name", name);
        snappyDB.putInt("budget", budget);
        snappyDB.putBoolean("isAdult", isAdult);
        snappyDB.put("genres", genres);
        //       
}

Notez que la méthode dans laquelle nous travaillons avec SnappyDB doit lever une SnappydbException.

Maintenant, nous écrivons la méthode setValues pour obtenir les données de la base de données et les afficher:

private void setValues(DB snappyDB) throws SnappydbException {
        TextView filmNameTextView = findViewById(R.id.filmNameTextView),
                 filmBudgetTextView = findViewById(R.id.filmBudgetTextView),
                 genresTextView = findViewById(R.id.genreTextView),
                 isAdultTextView = findViewById(R.id.isAdult); //    

        String name = snappyDB.get("Name");
        int budget = snappyDB.getInt("budget");
        boolean isAdult = snappyDB.getBoolean("isAdult");
        String[] genres = snappyDB.getObjectArray("genres", String.class);//2  =  
        //  get...     

        filmNameTextView.setText(name);
        filmBudgetTextView.setText(String.valueOf(budget));
        isAdultTextView.setText(String.valueOf(isAdult));

        for(int i = 0;i < genres.length;i++) {
            genresTextView.setText(genresTextView.getText() + " " + genres[i]);
        }
}

Appelez les méthodes créées dans onCreate (assurez-vous de les entourer d'un bloc try / catch):

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        try {
            putValues("Forrest Gump", 677000000,false, new String[] {"Drama","Melodrama"});
        } catch (SnappydbException e) {
            e.printStackTrace();
        }
        
        try {
            DB snappyDB = DBFactory.open(this, "Film");
            setValues(snappyDB);
        } catch (SnappydbException e) {
            e.printStackTrace();
        }
}

Nous commençons et voyons que tout fonctionne correctement:

Voyons maintenant comment travailler avec nos propres classes et d'autres types complexes.
Créez un cours de cinéma avec 3 champs:

public class Film {
    private String name;
    private int budget;
    private String[] genres;

    public Film() {}

    public Film(String name, int budget, String[] genres) {
        this.name = name;
        this.budget = budget;
        this.genres = genres;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getBudget() {
        return budget;
    }

    public void setBudget(int budget) {
        this.budget = budget;
    }

    public String[] getGenres() {
        return genres;
    }

    public void setGenres(String[] genres) {
        this.genres = genres;
    }
}

Supprimez les appels de méthode setValues et putValues dans onCreate. Créez-y un nouvel objet de la classe Film et ajoutez-le à la base de données:

Film film = new Film("Shawshank redemption",28000000, new String[] {"Drama"});
try {
       DB snappyDB = DBFactory.open(this, "NewFilmDB");
       snappyDB.put("FilmObj",film);
} catch (SnappydbException e) {
       e.printStackTrace();
}

Nous retravaillons la méthode setValues:

private void setValues(DB snappyDB) throws SnappydbException {
        TextView filmNameTextView = findViewById(R.id.filmNameTextView),
                 filmBudgetTextView = findViewById(R.id.filmBudgetTextView),
                 genresTextView = findViewById(R.id.genreTextView);

        Film film = snappyDB.getObject("FilmObj", Film.class);
        
        String name = film.getName();
        int budget = film.getBudget();
        String[] genres = film.getGenres();

        filmNameTextView.setText(name);
        filmBudgetTextView.setText(String.valueOf(budget));

        for(int i = 0;i < genres.length;i++) {
            genresTextView.setText(genresTextView.getText() + " " + genres[i]);
        }
}

Appelez à nouveau setValues dans onCreate:

try {
        DB snappyDB = DBFactory.open(this, "NewFilmDB");
        setValues(snappyDB);
} catch (SnappydbException e) {
        e.printStackTrace();
}

Nous commençons et voyons que tout fonctionne:

Voyons maintenant quelques fonctions SnappyDB plus intéressantes:
1) La possibilité de rechercher des clés par préfixe:

Film film1 = new Film("Green mile",60000000,new String[] {"Drama", "Fantasy"}),
  film2 = new Film("Gentlemen",22000000,new String[] {"Comedy", "Crime"}),
  film3 = new Film("In Bruges",15000000,new String[] {"Comedy", "Crime", "Thriller"});

        try {
            DB snappyDB = DBFactory.open(this, "NewFilmDB");
            snappyDB.put("FilmObj: Green Mile",film1);
            snappyDB.put("FilmObj: Gentlemen",film2);
            snappyDB.put("FilmObj: In Bruges",film3);
            String[] filmKeys = snappyDB.findKeys("FilmObj:");
            //   filmKeys    "FilmObj:"
            //      ,   
            for(int i = 0;i < filmKeys.length;i++) {
                Log.d("film_key: ",  filmKeys[i] + "\n");
            }

            Log.d("film_name: ",  snappyDB.getObject(filmKeys[2],Film.class).getName() + "\n");
            // -  ,    filmKeys

        } catch (SnappydbException e) {
            e.printStackTrace();
 }

Sortie du journal

2) Itération DB:

try {

            DB snappyDB = DBFactory.open(this, "NewFilmDB");

            for (String[] batch : snappyDB.allKeysIterator().byBatch(1)) {
                //    (batch),     
                for (String key : batch) {
                    Log.d("film",snappyDB.getObject(key,Film.class).getName());
                }
            }
        } catch (SnappydbException e) {
            e.printStackTrace();
}

Sans utiliser byBatch, vous n'aurez qu'un KeyIterator qui n'implémente pas Iterator ou Iterable, vous ne pouvez donc pas l'utiliser en boucle.
byBatch (n) crée un BatchIterable, qui est Iterable et Iterator. Essentiellement, il appelle simplement next (n) pour KeyIterator lorsque vous appelez next () pour lui.
Mais byBatch ne doit être utilisé qu'avec une grande quantité de données. Sinon, cela vaut la peine d'utiliser findKeys / findKeysBetween.

3) Suppression d'un élément par clé:

snappyDB.del("FilmObj: Gentlemen");

Élément supprimé
4) Fermeture et suppression de la base de données:

snappyDB.close();
snappyDB.destroy();

5) Vérifiez si une clé existe dans la base de données:

snappyDB.put("FilmObj: Gentlemen",new Film());
boolean isExist = snappyDB.exists("FilmObj: Gentlemen");// true
snappyDB.del("FilmObj: Gentlemen");
isExist = snappyDB.exists("FilmObj: Gentlemen");//false

Voilà donc tout. Vous décidez si vous souhaitez utiliser cette base de données dans vos projets. Il est assez rapide et facile à utiliser, mais vous avez le choix. Ce n'est pas la seule base de données pour Android. Peut-être qu'une autre base de données est meilleure pour votre projet (Room, SQLite, Realm, etc.). Beaucoup d'options.

PS: SnappyDB sur GitHub (documentation officielle là-bas).
Différences entre SQL et NoSQL: 1 , 2
SQL vs DB de valeurs-clés

Utilisation de la base de données de valeurs-clés de Snappy dans Android

More articles: