OrmLite Android DatabaseHelper 사용법

Question

OrmLite로 데이터를 유지하려고합니다. 이 예제에서는 다음 클래스가 있습니다.

package com.example.helloandroid; 

import java.sql.SQLException; 

import android.content.Context; 
import android.database.sqlite.SQLiteDatabase; 
import android.util.Log; 

import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper; 
import com.j256.ormlite.dao.Dao; 
import com.j256.ormlite.dao.RuntimeExceptionDao; 
import com.j256.ormlite.support.ConnectionSource; 
import com.j256.ormlite.table.TableUtils; 

/** 
* Database helper class used to manage the creation and upgrading of your database. This class also usually provides 
* the DAOs used by the other classes. 
*/ 
public class DatabaseHelper extends OrmLiteSqliteOpenHelper { 

    // name of the database file for your application -- change to something appropriate for your app 
    private static final String DATABASE_NAME = "helloAndroid.db"; 
    // any time you make changes to your database objects, you may have to increase the database version 
    private static final int DATABASE_VERSION = 1; 

    // the DAO object we use to access the SimpleData table 
    private Dao<SimpleData, Integer> simpleDao = null; 
    private RuntimeExceptionDao<SimpleData, Integer> simpleRuntimeDao = null; 

    public DatabaseHelper(Context context) { 
     super(context, DATABASE_NAME, null, DATABASE_VERSION, R.raw.ormlite_config); 
    } 

    /** 
    * This is called when the database is first created. Usually you should call createTable statements here to create 
    * the tables that will store your data. 
    */ 
    @Override 
    public void onCreate(SQLiteDatabase db, ConnectionSource connectionSource) { 
     try { 
      Log.i(DatabaseHelper.class.getName(), "onCreate"); 
      TableUtils.createTable(connectionSource, SimpleData.class); 
     } catch (SQLException e) { 
      Log.e(DatabaseHelper.class.getName(), "Can't create database", e); 
      throw new RuntimeException(e); 
     } 

     // here we try inserting data in the on-create as a test 
     RuntimeExceptionDao<SimpleData, Integer> dao = getSimpleDataDao(); 
     long millis = System.currentTimeMillis(); 
     // create some entries in the onCreate 
     SimpleData simple = new SimpleData(millis); 
     dao.create(simple); 
     simple = new SimpleData(millis + 1); 
     dao.create(simple); 
     Log.i(DatabaseHelper.class.getName(), "created new entries in onCreate: " + millis); 
    } 

    /** 
    * This is called when your application is upgraded and it has a higher version number. This allows you to adjust 
    * the various data to match the new version number. 
    */ 
    @Override 
    public void onUpgrade(SQLiteDatabase db, ConnectionSource connectionSource, int oldVersion, int newVersion) { 
     try { 
      Log.i(DatabaseHelper.class.getName(), "onUpgrade"); 
      TableUtils.dropTable(connectionSource, SimpleData.class, true); 
      // after we drop the old databases, we create the new ones 
      onCreate(db, connectionSource); 
     } catch (SQLException e) { 
      Log.e(DatabaseHelper.class.getName(), "Can't drop databases", e); 
      throw new RuntimeException(e); 
     } 
    } 

    /** 
    * Returns the Database Access Object (DAO) for our SimpleData class. It will create it or just give the cached 
    * value. 
    */ 
    public Dao<SimpleData, Integer> getDao() throws SQLException { 
     if (simpleDao == null) { 
      simpleDao = getDao(SimpleData.class); 
     } 
     return simpleDao; 
    } 

    /** 
    * Returns the RuntimeExceptionDao (Database Access Object) version of a Dao for our SimpleData class. It will 
    * create it or just give the cached value. RuntimeExceptionDao only through RuntimeExceptions. 
    */ 
    public RuntimeExceptionDao<SimpleData, Integer> getSimpleDataDao() { 
     if (simpleRuntimeDao == null) { 
      simpleRuntimeDao = getRuntimeExceptionDao(SimpleData.class); 
     } 
     return simpleRuntimeDao; 
    } 

    /** 
    * Close the database connections and clear any cached DAOs. 
    */ 
    @Override 
    public void close() { 
     super.close(); 
     simpleRuntimeDao = null; 
    } 
} 

SimpleData 클래스를 참조합니다. 다양한 클래스의 Object를 유지하려면 원하는 모든 클래스에 대해 DatabaseHelper 클래스를 만들어야합니까? 물론

Answer 1

하지, 당신은 계속 많은 클래스를 정의하고 수행 할 수 있습니다

(new DatabaseHelper(getApplicationContext())).getDao(TheClassYouWant.class) 

어떤 DAO를 얻을 수 있습니다. 에서 onCreate, onUpgrade 각 테이블을 정의하는 것을 잊지 마세요 :

TableUtils.createTable(connectionSource, SimpleData.class); 
TableUtils.createTable(connectionSource, OtherSimpleData.class); 

Answer 2

아니, 당신은 당신이 지속 할 객체 하나 개 DatabaseHelper 클래스 있지만, 각 당 하나의 DAO가 필요합니다.