Android ORMLite ForeignCollection关联外部集合

《Android ORMLite ForeignCollection关联外部集合》
  
Android ORMLite ForeignCollection关联外部集合的功能，适合层级比较深，数据模型互相渗透、交叉的数据结构或集合。尤其方便解决复杂数据模型。简单期间，我们暂时以 班级 <-> 学生 这样的数据模型为例加以说明。一个班级里面有若干学生(一对多，1<-n)，反过来说，若干个学生集合到一个班级中（n->1）。 在Android ORMLite中，这样的结构模型可以用@ForeignCollectionField，ForeignCollection建模。我们定义一个班级类AClass（之所以在 ''Class''前加一个‘A’，是因为Java语言中，''Class''是保留字，却刚好是我们想用的班级英文单词，真不巧，所以前面加个''A''规避），AClass包含id（主键，方便查询和更新），name以及指向一个外部Student的集合（ForeignCollection<Student>）。同样，我们定义学生类Student，Student中埋入一个字段aclass指向外部的AClass。
  
 备注：
 Android ORMLite简介文章：http://blog.csdn.net/zhangphil/article/details/46878075
 
 示例代码总共有4个文件：MainActivity.java，主Activity，用于测试。ORMLiteDatabaseHelper.java , AClass.java , Student.java 是数据库相关的代码文件，用于建模。

结构层次如图：

测试用的MainActivity.java :

package zhangphil.ormlitetest;

import java.sql.SQLException;

import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.dao.ForeignCollection;

import zhangphil.ormlitetest.database.AClass;
import zhangphil.ormlitetest.database.ORMLiteDatabaseHelper;
import zhangphil.ormlitetest.database.Student;
import android.support.v7.app.ActionBarActivity;
import android.widget.Toast;
import android.os.Bundle;

public class MainActivity extends ActionBarActivity {

	private Dao<AClass, Integer> mClassDao;
	private Dao<Student, Integer> mStudentDao;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		ORMLiteDatabaseHelper mDatabaseHelper = ORMLiteDatabaseHelper
				.getInstance(this);

		mClassDao = mDatabaseHelper.getClassDao();
		mStudentDao = mDatabaseHelper.getStudentDao();

		// 创建5个班级用以演示。
		for (int i = 1; i < 6; i++) {
			AClass aclass = new AClass();
			aclass.id = i;
			aclass.name = i + "班";
			try {
				mClassDao.createIfNotExists(aclass);
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}

		// 找到id=1的1班。
		AClass class1 = null;
		try {
			class1 = mClassDao.queryForId(1);
		} catch (SQLException e) {
			e.printStackTrace();
		}

		// 创建19个学生，这19个学生都归属到1班。
		for (int i = 1; i < 20; i++) {
			Student s = new Student();
			s.id = i;
			s.name = "学生" + i;

			// 将新创建的这些学生所在班级指针指向1班。
			// 数据模型：id=1的1班和这19个学生是1对多的学生，换句话说，这19个学生是1班的学生。
			s.aclass = class1;

			try {
				mStudentDao.createIfNotExists(s);
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	@Override
	public void onStart() {
		super.onStart();

		/**
		 * 下面我们演示更新一个Student的信息， 然后向上，依据外键，从Student - > Class更新班级信息。
		 * 
		 * */

		// 假设我们更新其中id=1的这个学生所在的这个班级的name变成“一班”。
		Student s1 = null;
		try {
			s1 = mStudentDao.queryForId(1);

			s1.aclass.name = "一班";

			// 更新1班的名字从“1班”变成“一班”
			mClassDao.update(s1.aclass);
		} catch (SQLException e) {
			e.printStackTrace();
		}

		// 显示我们更新后的结果。
		AClass class1 = null;
		try {
			class1 = mClassDao.queryForId(1);
		} catch (SQLException e1) {
			e1.printStackTrace();
		}

		ForeignCollection<Student> students = class1.students;
		for (Student s : students) {
			Toast.makeText(this, s.toString(), Toast.LENGTH_SHORT).show();
		}
	}
}

以下是数据库相关的建模：

AClass.java :

package zhangphil.ormlitetest.database;

import com.j256.ormlite.dao.ForeignCollection;
import com.j256.ormlite.field.DataType;
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.field.ForeignCollectionField;
import com.j256.ormlite.table.DatabaseTable;

@DatabaseTable(tableName = "classes")
public class AClass {

	@DatabaseField(canBeNull = false, dataType = DataType.LONG, id = true)
	public long id;

	@DatabaseField(canBeNull = false, defaultValue = "a class", dataType = DataType.STRING)
	public String name;

	@ForeignCollectionField(eager = false)
	public ForeignCollection<Student> students = null;

	public AClass() {

	}
}

Student.java :

package zhangphil.ormlitetest.database;

import com.j256.ormlite.field.DataType;
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;

@DatabaseTable(tableName = "students")
public class Student {

	public Student(String name, int student_id) {
		this.name = name;
		this.id = student_id;
	}

	@DatabaseField(canBeNull = false, dataType = DataType.INTEGER, id = true)
	public int id;

	@DatabaseField(canBeNull = false, dataType = DataType.STRING)
	public String name;

	@DatabaseField(canBeNull = false, foreign = true, foreignAutoRefresh = true)
	public AClass aclass;

	public Student() {

	}

	@Override
	public String toString() {
		return "id:" + id + " 姓名:" + name + " 所在班级:" + aclass.name;
	}
}

ORMLiteDatabaseHelper.java :

package zhangphil.ormlitetest.database;

import java.sql.SQLException;

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

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

public class ORMLiteDatabaseHelper extends OrmLiteSqliteOpenHelper {

	private static ORMLiteDatabaseHelper mDatabaseHelper = null;

	private Dao<AClass, Integer> mClassDao = null;
	private Dao<Student, Integer> mStudentDao = null;

	private final static String DataBase_NAME = "school.db";
	private final static int DataBase_VERSION = 1;

	public ORMLiteDatabaseHelper(Context context, String databaseName,
			CursorFactory factory, int databaseVersion) {
		super(context, DataBase_NAME, factory, DataBase_VERSION);
	}

	public static ORMLiteDatabaseHelper getInstance(Context context) {
		if (mDatabaseHelper == null) {
			mDatabaseHelper = new ORMLiteDatabaseHelper(context, DataBase_NAME,
					null, DataBase_VERSION);
		}

		return mDatabaseHelper;
	}

	@Override
	public void onCreate(SQLiteDatabase arg0, ConnectionSource connectionSource) {

		Log.d(this.getClass().getName(), "ORMLite数据库 -> onCreate");

		try {
			TableUtils.createTableIfNotExists(connectionSource, AClass.class);
			TableUtils.createTableIfNotExists(connectionSource, Student.class);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Override
	public void onUpgrade(SQLiteDatabase database,
			ConnectionSource connectionSource, int oldVersion, int newVersion) {

		Log.i(this.getClass().getName(), "数据库 -> onUpgrade");

		try {
			// 删除旧的数据库表。
			TableUtils.dropTable(connectionSource, AClass.class, true);
			TableUtils.dropTable(connectionSource, Student.class, true);

			// 重新创建新版的数据库。
			onCreate(database, connectionSource);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	public Dao<Student, Integer> getStudentDao() {
		if (mStudentDao == null) {
			try {
				mStudentDao = getDao(Student.class);
			} catch (java.sql.SQLException e) {
				e.printStackTrace();
			}
		}

		return mStudentDao;
	}

	public Dao<AClass, Integer> getClassDao() {
		if (mClassDao == null) {
			try {
				mClassDao = getDao(AClass.class);
			} catch (java.sql.SQLException e) {
				e.printStackTrace();
			}
		}

		return mClassDao;
	}

	@Override
	public void close() {
		super.close();
		mClassDao = null;
		mStudentDao = null;
	}
}

android – Robolectric：使用ormlite进行测试

我正在尝试使用robolectric测试Ormlite DAO,但数据库行为与从我的Android应用程序中使用它时的行为不同.我的DAO在Android应用程序上运行得非常好.

阅读robolectric阴影和调试代码,我遇到了ShadowSQLiteOpenHelper(代码here).

有谁知道这个暗影是否足以测试ormlite daos？或者我必须创建自己的影子才能实现这一目标？这里有任何线索/提示/建议/示例吗？

提前致谢.

额外信息：

测试方法：

@Test
public void basictest() throws sqlException {
    assertNotNull(randomStringResource); // Injection of an android resource: OK
    assertthat(randomStringResource, equalTo("Event")); // With correct value: OK
    assertNotNull(eventDao); // Dao injection: OK
    assertthat(eventDao.countOf(), equalTo(0L)); // Table empty: OK

    Event e1 = new Event("e1", new Date());
    eventDao.create(e1);

    assertNotNull(e1.getId()); // ID generated by Ormlite: OK
    assertthat(eventDao.countOf(), equalTo(1L)); // Table not empty: OK
    assertthat("e1", equalTo(eventDao.queryForId(e1.getId()).getName())); // Query for inserted event: Throws exception
}

运行此测试时遇到的一些问题：

>使用“camelCased”属性名查询实体的错误：在最后一行测试时抛出错误(related problem).从来没有像运行Android应用程序这样的问题.
>当我更改其中一个属性名称(例如,isEnabled为启用)以避免camelCase问题时,之前的错误仍然存​​在…似乎内存数据库未应用我在实体上所做的更改.

使用的版本：

> Robolectric 1.1
> Ormlite 4.41

解决方法:

很抱歉复活你的主题,但我遇到了同样的问题.

我正在使用Ormlite 4.45和Robolectric 2.1.

在ShadowSQLiteCursor.java中,cacheColumnNames方法在每个列名称上调用toLowerCase.所以我决定使用我自己的(不调用toLowerCase)来扩展ShadowsqliteCursor：

/**
* Simulates an Android Cursor object, by wrapping a JDBC ResultSet.
*/
@Implements(value = sqliteCursor.class, inheritImplementationMethods = true)
public class ShadowCaseSensitivesqliteCursor extends ShadowsqliteCursor {

private ResultSet resultSet;

public void __constructor__(sqliteCursorDriver driver, String editTable, sqliteQuery query) {}

/**
 * Stores the column names so they are retrievable after the resultSet has closed
 */
private void cacheColumnNames(ResultSet rs) {
    try {
        ResultSetMetaData MetaData = rs.getMetaData();
        int columnCount = MetaData.getColumnCount();
        columnNameArray = new String[columnCount];
        for(int columnIndex = 1; columnIndex <= columnCount; columnIndex++) {
            String cName = MetaData.getColumnName(columnIndex);
            this.columnNames.put(cName, columnIndex - 1);
            this.columnNameArray[columnIndex - 1] = cName;
        }
    } catch(sqlException e) {
        throw new RuntimeException("sql exception in cacheColumnNames", e);
    }
}
}

我的答案显然来得太晚,但可能会帮助别人！

我们今天的关于在Android中使用ORMLite持久保存Collection类和android持久化存储方式的分享就到这里，谢谢您的阅读，如果想了解更多关于Android AndEngine：正确处理Collission Detection、Android Collection Widget 的基本示例、Android ORMLite ForeignCollection关联外部集合、android – Robolectric：使用ormlite进行测试的相关信息，可以在本站进行搜索。