Android Exemple Android OrmLite sur SQLite


Exemple

ORMLite est un package de mappage relationnel objet qui fournit des fonctionnalités simples et légères pour la persistance des objets Java dans les bases de données SQL, tout en évitant la complexité et la surcharge de packages ORM plus standard.

Parlant pour Android, OrmLite est implémenté sur la base de données prise en charge prête à l'emploi, SQLite. Il appelle directement l'API pour accéder à SQLite.

Installation de Gradle

Pour commencer, vous devez inclure le package dans la version de construction.

 // https://mvnrepository.com/artifact/com.j256.ormlite/ormlite-android
compile group: 'com.j256.ormlite', name: 'ormlite-android', version: '5.0'
POJO configuration

Ensuite, vous devez configurer un POJO à conserver dans la base de données. Ici, il faut faire attention aux annotations:

  • Ajoutez l'annotation @DatabaseTable au début de chaque classe. Vous pouvez également utiliser @Entity.
  • Ajoutez l'annotation @DatabaseField juste avant chaque champ à conserver. Vous pouvez également utiliser @Column et autres.
  • Ajoutez un constructeur sans argument à chaque classe avec au moins la visibilité du package.
 @DatabaseTable(tableName = "form_model")
 public class FormModel implements Serializable {

    @DatabaseField(generatedId = true)
    private Long id;
    @DatabaseField(dataType = DataType.SERIALIZABLE)
    ArrayList<ReviewItem> reviewItems;

    @DatabaseField(index = true)
    private String username;

    @DatabaseField
    private String createdAt;

    public FormModel() {
    }

    public FormModel(ArrayList<ReviewItem> reviewItems, String username, String createdAt) {
        this.reviewItems = reviewItems;
        this.username = username;
        this.createdAt = createdAt;
    }
}

Dans l'exemple ci-dessus, il y a une table (form_model) avec 4 champs.

Le champ id est un index généré automatiquement.

nom d'utilisateur est un index de la base de données.

Vous trouverez plus d'informations sur l'annotation sur la documentation officielle .

Assistant de base de données

Pour continuer avec, vous devrez créer une classe d'assistance de base de données qui devrait étendre la classe OrmLiteSqliteOpenHelper.

Cette classe crée et met à niveau la base de données lorsque votre application est installée et peut également fournir les classes DAO utilisées par vos autres classes.

DAO signifie Data Access Object et fournit toutes les fonctionnalités de scrum et se spécialise dans la gestion d'une seule classe persistante.

La classe d'assistance doit implémenter les deux méthodes suivantes:

  • onCreate (SQLiteDatabase sqliteDatabase, ConnectionSource connectionSource);

    onCreate crée la base de données lors de la première installation de votre application

  • onUpgrade (base de données SQLiteDatabase, ConnectionSource connectionSource, int oldVersion, int newVersion);

    onUpgrade gère la mise à niveau des tables de base de données lorsque vous mettez à niveau votre application vers une nouvelle version

Exemple de classe d'assistance de base de données:

  public class OrmLite extends OrmLiteSqliteOpenHelper {
    
        //Database name
        private static final String DATABASE_NAME = "gaia";
        //Version of the database. Changing the version will call {@Link OrmLite.onUpgrade}
        private static final int DATABASE_VERSION = 2;
    
        /**
         * The data access object used to interact with the Sqlite database to do C.R.U.D operations.
         */
        private Dao<FormModel, Long> todoDao;
    
    
    
        public OrmLite(Context context) {
            super(context, DATABASE_NAME, null, DATABASE_VERSION,
                    /**
                     * R.raw.ormlite_config is a reference to the ormlite_config2.txt file in the
                     * /res/raw/ directory of this project
                     * */
                    R.raw.ormlite_config2);
        }
    
        @Override
        public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
            try {
    
                /**
                 * creates the database table
                 */
                TableUtils.createTable(connectionSource, FormModel.class);
    
            } catch (SQLException e) {
                e.printStackTrace();
            } catch (java.sql.SQLException e) {
                e.printStackTrace();
            }
        }
        /*
            It is called when you construct a SQLiteOpenHelper with version newer than the version of the opened database.
         */
        @Override
        public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource,
                              int oldVersion, int newVersion) {
            try {
                /**
                 * Recreates the database when onUpgrade is called by the framework
                 */
                TableUtils.dropTable(connectionSource, FormModel.class, false);
                onCreate(database, connectionSource);
    
            } catch (SQLException | java.sql.SQLException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * Returns an instance of the data access object
         * @return
         * @throws SQLException
         */
        public Dao<FormModel, Long> getDao() throws SQLException {
            if(todoDao == null) {
                try {
                    todoDao = getDao(FormModel.class);
                } catch (java.sql.SQLException e) {
                    e.printStackTrace();
                }
            }
            return todoDao;
        }
    }

Objet persistant à SQLite

Enfin, la classe qui conserve l'objet dans la base de données.

     public class ReviewPresenter {
    Dao<FormModel, Long> simpleDao;


    public ReviewPresenter(Application application) {
        this.application = (GaiaApplication) application;
        simpleDao = this.application.getHelper().getDao();
    }

    public void storeFormToSqLite(FormModel form) {

        try {
            simpleDao.create(form);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        List<FormModel> list = null;
        try {
// query for all of the data objects in the database
            list = simpleDao.queryForAll();
        } catch (SQLException e) {
            e.printStackTrace();
        }
// our string builder for building the content-view
        StringBuilder sb = new StringBuilder();
        int simpleC = 1;
        for (FormModel simple : list) {
            sb.append('#').append(simpleC).append(": ").append(simple.getUsername()).append('\n');
            simpleC++;
        }
        System.out.println(sb.toString());
    }
    
    //Query to database to get all forms by username
    public List<FormModel> getAllFormsByUsername(String username) {
        List<FormModel> results = null;
        try {
            results = simpleDao.queryBuilder().where().eq("username", PreferencesManager.getInstance().getString(Constants.USERNAME)).query();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return results;
    }
}

L'accesseur du DOA du constructeur de la classe ci-dessus est défini comme suit:

 private OrmLite dbHelper = null;

/*
Provides the SQLite Helper Object among the application
 */
public OrmLite getHelper() {
    if (dbHelper == null) {
        dbHelper = OpenHelperManager.getHelper(this, OrmLite.class);
    }
    return dbHelper;
}