/*----------------------------------------
*-描述--ORMLite框架使用总结.
*-描述--S1.相关理论描述
* >>ORMlite通过Java注解的方式来建立起与数据库的映射关系,在Android面向数据库开发中，是一个比较
* 流行的开源框架，方便操作而且功能强大
* >>ORMLite的优缺点
* 优点：轻量级、使用简单、封装完善、文档全面
* 缺点：基于反射，效率较低，缺少中文翻译文档
* >>
*-描述--S2.添加到项目
* >>添加库文件到项目libs下，添加为库
* ormlite-android-5.0.jar、ormlite-android-5.0-sources.jar
* ormlite-core-5.0、ormlite-core-5.0-sources.jar
* >>继承OrmLiteSqliteOpenHelper类定义数据库帮助类(XXXHelper)
* 可以在程序被安装时创建或者升级数据库
* onCreate(SQLiteDatabase sqliteDatabase, ConnectionSource connectionSource)
* onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion)
* >>定义实体类Bean，代表一张表(XXXModel)
* @DatabaseTable：表示定义了一个数据表，如果不指定名字，在Android中会以类名作为表名，
* 如packageInfo就是SQLite数据库中的表名，我们也可以指定表名，@DatabaseTable(tableName =
* "tb_package")
* @DatabaseField：表示定义了数据中的一个字段，id表示数据中的一个主键，如果指定为generatedId，
* 表示自动增长id，我们不需要给它赋值。其他字段，可以使用columnName来指定字段名，canBeNull表
* 示是否为空，这些赋值可以按照以下来指定-（id = true, canBeNull = false）(columnName = "name")
* @DatabaseField 常用注解：
* columnName 指定字段名,不指定则变量名作为字段名
* canBeNull 字段是否能被分配null值。默认是true。如果你设置成false，那么你每次在数据库中
* 插入数据是都必须为这个字段提供值。
* dataType 指定字段的类型
* defaultValue 当我们在表中创建新的记录时的一个字段的默认值。默认情况下是没有这个值的
* width 字段的宽度，主要用于字符串字段。默认是0
* id 这个字段是否是id，默认是false。在一个class中只有一个成变量可以有这个值。id字段是一条
* 记录的唯一标识而且是必需的，只能在generatedId和 generatedIdSequence其中选一个。
* generatedId 字段是否自动增加。默认为false。类中的一个成员变量设置了这个值，它告诉数据库
* 每添加一条新记录都自动增加id。当一个有generatedid的对象被创建时使用Dao.create()方法
* ，数据库将为记录生成一个id，它会被返回并且被create方法设置进对象。
* generatedIdSequence 序列编号的名字，这个值在生成的时候会被使用。和generatedId相似，但是
* 你能够指定使用的序列名称。默认是没有的。
* foreign 指定这个字段的对象是一个外键,外键值是这个对象的id
* persisted 指定是否持久化此变量,默认true
* foreignAutoCreate 外键不存在时是否自动添加到外间表中
* foreignColumnName 外键字段指定的外键表中的哪个字段
* @ForeignCollectionField常用注解
* eager 表示该集合是在初始化这个对象的时候,是否讲对象取出还是在遍历的时候才取出,默认false
* 遍历的时候才取出,size()方法也会引起遍历
* columnName
* orderColumnName
* foreignFieldName
* >>数据库的增删查改(XXXDao)
* 插入操作
* create:插入一条数据
* createIfNotExists:如果不存在则插入
* createOrUpdate:如果存在则更新
* 查询操作
* 首先调用xxxDao.queryBuilder();获得该Dao下的QueryBuilder对象
* 接下来设置QueryBuilder的查询条件
* 最后通过QueryBuilder的query方法获得List对象
* 删除和更改操作
* 与查询操作类似，ORMLite同样为我们提供了一系列的方法，同时也提供了复杂删除，复杂更
* 改的DeleteBuilder和UpdateBuilder，其用法与QueryBuilder相似
* 主要方法
* create 插入一条数据
* createIfNotExists 如果不存在则插入
* createOrUpdate 如果指定id则更新
* queryForId 更具id查找
* update 查找出数据
* delete 删除数据
* queryBuilder() 创建一个查询生成器:进行复杂查询
* deleteBuilder() 创建一个删除生成器,进程复杂条件删除
* updateBuilder() 创建修条件生成器,进行复杂条件修改
* 参考：https://www.zybuluo.com/flyouting/note/6996
*-描述--深入部分
* ORMLite外键引用
* 关联一个集合
* 参考：
* http://blog.csdn.net/lmj623565791/article/details/39122981
* http://www.jianshu.com/p/05782b598cf0
* https://bng86.gitbooks.io/android-third-party-/content/ormlite.html
*-描述--B1.None.
* 官方网站：
* http://ormlite.com/
* http://ormlite.com/releases/
* https://github.com/j256/ormlite-android
* 参考文档：
* http://blog.csdn.net/lmj623565791/article/details/39121377
* http://blog.csdn.net/lmj623565791/article/details/39122981
* http://www.jianshu.com/p/05782b598cf0
* https://bng86.gitbooks.io/android-third-party-/content/ormlite.html
*---------------------------------------------------------------------------*/
/**
* Created by envy15 on 2016/8/2.
* 创建数据库表项
* 对于类中的每个需要存储的成员变量，都需要添加@DatabaseField注解
*/
//tableName表示创建该表的表名，不带该配置表示使用类名作为表名
@DatabaseTable(tableName = "model_table")
public class TestModel implements Serializable {
//private final String TEST_MODEL_ID = "id";
private final String TEST_MODEL_TITLE = "modelTitle";
private final String TEST_MODEL_URL = "modelUrl";
private final String TEST_MODEL_DETAIL = "modelDetail";
private final String TEST_MODEL_COUNT = "modelCount";
private final String TEST_MODEL_STATE = "modelStatus";
private final String TEST_MODEL_ITEM = "modelItem";
//id = true 配置为主键,generatedId = true 主键自动增长
@DatabaseField(generatedId = true)
public int id;
//存储的成员变量添加@DatabaseField注解
@DatabaseField(columnName = TEST_MODEL_TITLE)
public String modelTitle;
@DatabaseField(columnName = TEST_MODEL_URL)
public String modelUrl;
@DatabaseField(columnName = TEST_MODEL_DETAIL)
public String modelDetail;
@DatabaseField(columnName = TEST_MODEL_COUNT)
public int modelCount;
@DatabaseField(columnName = TEST_MODEL_STATE,defaultValue = "0")
public int modelStatus;
//canBeNull -表示不能为null；foreign=true表示是一个外键;columnName 列名
// @DatabaseField(canBeNull = true, foreign = true, columnName = TEST_MODEL_ITEM)
private TestItem testItem;
//以下注释未调试
// //@ForeignCollectionField 表示这个表中的数据在其他表中是外键
// //成员变量items的类型必须要么是ForeignCollection<T>要么是Collection<T>
// @ForeignCollectionField(eager = false)
// public ForeignCollection<TestItem> items;
// // 外部对象字段
// @DatabaseField(foreign = true, foreignAutoRefresh = true)
// public PackageInfo mPackage;
//
// @DatabaseField(foreign = true, foreignAutoRefresh = true)
// public Photographer photographer;
// /**
// * 这里需要注意的是：属性类型只能是ForeignCollection<T>或者Collection<T>
// * 如果需要懒加载（延迟加载）可以在@ForeignCollectionField加上参数eager=false
// * 这个属性也就说明一个部门对应着多个用户
// */
// @ForeignCollectionField(eager = true)
// public ForeignCollection<Img> imgs;
public TestModel() {
}
public TestModel(String modelTitle, String modelDetail) {
this.modelTitle = modelTitle;
this.modelDetail = modelDetail;
}
public TestModel(String modelTitle, String modelDetail, int modelStatus) {
this.modelTitle = modelTitle;
this.modelDetail = modelDetail;
this.modelStatus = modelStatus;
}
public int getModelId() {
return id;
}
public void setModelId(int modelId) {
this.id = modelId;
}
public String getModelTitle() {
return modelTitle;
}
public void setModelTitle(String modelTitle) {
this.modelTitle = modelTitle;
}
public String getModelUrl() {
return modelUrl;
}
public void setModelUrl(String modelUrl) {
this.modelUrl = modelUrl;
}
public String getModelDetail() {
return modelDetail;
}
public void setModelDetail(String modelDetail) {
this.modelDetail = modelDetail;
}
public int getModelCount() {
return modelCount;
}
public void setModelCount(int modelCount) {
this.modelCount = modelCount;
}
public int getModelStatus() {
return modelStatus;
}
public void setModelStatus(int modelStatus) {
this.modelStatus = modelStatus;
}
public TestItem getTestItem() {
return testItem;
}
public void setTestItem(TestItem testItem) {
this.testItem = testItem;
}
@Override
public String toString() {
return "TestModel{" +
"id=" + id +
", modelTitle='" + modelTitle + '\'' +
", modelUrl='" + modelUrl + '\'' +
", modelDetail='" + modelDetail + '\'' +
", modelCount=" + modelCount +
", modelStatus=" + modelStatus +
'}';
}
}
/**
* Created by envy15 on 2016/8/2.
* 定义数据访问对象，对指定的表进行增删改查操作
*
*/
public class ModelDao {
private Dao<TestModel, Integer> modelDao;
private DBHelper dbHelper;
/**
* 构造方法
* 获得数据库帮助类实例，通过传入Class对象得到相应的Dao
* @param context
*/
public ModelDao(Context context) {
try {
dbHelper = DBHelper.getHelper(context);
modelDao = dbHelper.getDao(TestModel.class);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 添加一条记录
* @param model
*/
public void add(TestModel model) {
try {
//LogUtil.infoE(this,"model:"+(model==null)+" modelDao:"+(modelDao==null));
modelDao.create(model);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 删除一条记录
* @param model
*/
public void delete(TestModel model) {
try {
modelDao.delete(model);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 更新一条记录
* @param model
*/
public void update(TestModel model) {
try {
modelDao.update(model);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 查询一条记录
* @param id
* @return
*/
public TestModel queryForId(int id) {
TestModel model = null;
try {
model = modelDao.queryForId(id);
} catch (SQLException e) {
e.printStackTrace();
}
return model;
}
/**
* 根据模型查询匹配的记录
* @param model
* @return
*/
public List<TestModel> queryForModel(TestModel model) {
List<TestModel> mModel = null;
try {
mModel = modelDao.queryForMatching(model);
//queryForMatching/queryForMatchingArgs查询结果一样
//mModel = modelDao.queryForMatchingArgs(model);
} catch (SQLException e) {
e.printStackTrace();
}
return mModel;
}
/**
* 根据模型Key-Value查询匹配的记录
* @param var1 key
* @param var2 value
* @return
*/
public List<TestModel> queryForKey(String var1, Object var2) {
List<TestModel> mModel = null;
try {
mModel = modelDao.queryForEq(var1,var2);
} catch (SQLException e) {
e.printStackTrace();
}
return mModel;
}
/**
* 其他查询测试
* @param model
* @return
* 参考：
* http://blog.csdn.net/quanjin24k/article/details/11620803
* http://www.cnblogs.com/vanezkw/archive/2012/08/15/2640290.html
* http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_2.html#Class-Setup
* http://www.ithao123.cn/content-8115868.html
*/
//public List<TestModel> queryForModel1(Map<String, Object> mMap) {
public List<TestModel> queryForModel1(TestModel model) {
List<TestModel> mModel = null;
try {
//根据Model查询
//mModel = modelDao.queryForMatching(model);
//通过Key-Value查询
//mModel = modelDao.queryForEq("modelTitle","setModelTitle");
//mModel = modelDao.queryForEq("modelStatus",3);
// //根据多个key-value参数查询(Map集合)
// Map<String, Object> mMap = new HashMap<String, Object>();
// mMap.put("modelStatus",3);
// mMap.put("modelTitle","setModelTitle");
// mModel = modelDao.queryForFieldValues(mMap);
// mModel = modelDao.queryForFieldValuesArgs(mMap);
//带排序的查询
mModel = modelDao.queryBuilder().orderBy("id",false).where().eq("modelStatus",3)
.and().eq("modelTitle","setModelTitle").query();
// //通过SQL语句排序查询结果
// mModel = modelDao.queryBuilder().orderByRaw("sql-statement").where().eq("modelStatus",3)
// .and().eq("modelTitle","setModelTitle").query();
//SQL语句查询
//modelDao.queryRaw("select * from data where id = 2");
} catch (SQLException e) {
e.printStackTrace();
}
return mModel;
}
/**
* 查询所有记录
* @return
*/
public List<TestModel> queryForAll() {
List<TestModel> models = new ArrayList<TestModel>();
try {
models = modelDao.queryForAll();
} catch (SQLException e) {
e.printStackTrace();
}
return models;
}
}
/**
* Created by envy15 on 2016/8/2.
* 可以在程序被安装时创建或者升级数据库
* 需要实现：一个用于生成数据库，一个用于升级数据库
* onCreate(SQLiteDatabase sqliteDatabase, ConnectionSource connectionSource)
* onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion)
*/
public class DBHelper extends OrmLiteSqliteOpenHelper {
/**
* 数据库名字
*/
private static final String DB_NAME = "testModel.db";
/**
* 数据库版本
*/
private static final int DB_VERSION = 1;
/**
* 用来存放Dao的地图
*/
private Map<String, Dao> daos = new HashMap<>();
private static DBHelper instance;
/**
* 构造方法
* @param context
*/
public DBHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
/**
* 这里创建表
*/
@Override
public void onCreate(SQLiteDatabase sqliteDatabase, ConnectionSource connectionSource) {
// 创建表
try {
TableUtils.createTable(connectionSource, TestModel.class);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 这里进行更新表操作
*/
@Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource,
int oldVersion, int newVersion) {
try
{
TableUtils.dropTable(connectionSource, TestModel.class, true);
onCreate(sqLiteDatabase, connectionSource);
} catch (SQLException e)
{
e.printStackTrace();
}
}
/**
* 获取单例
* @param context
* @return
*/
public static synchronized DBHelper getHelper(Context context) {
context = context.getApplicationContext();
if (instance == null) {
synchronized (DBHelper.class) {
if (instance == null) {
instance = new DBHelper(context);
}
}
}
return instance;
}
/**
* 获取单例-数据库存贮SD目录下
* @param context
* @return
*/
public static synchronized DBHelper getHelper(Context context,String path) {
context = new DatabaseContext(context, path);
if (instance == null) {
synchronized (DBHelper.class) {
if (instance == null) {
instance = new DBHelper(context);
}
}
}
return instance;
}
/**
* 通过类来获得指定的Dao
*/
public synchronized Dao getDao(Class clazz) throws SQLException
{
Dao dao = null;
String className = clazz.getSimpleName();
if (daos.containsKey(className)) {
dao = daos.get(className);
}
if (dao == null) {
dao = super.getDao(clazz);
daos.put(className, dao);
}
return dao;
}
/**
* 释放资源
*/
@Override
public void close() {
super.close();
for (String key : daos.keySet()) {
Dao dao = daos.get(key);
dao = null;
}
}
}
public void initDatas() { //测试程序
LogUtil.infoD(this, "initViews");
LogUtil.infoE(this, "OrmLiteStartTime:"+System.currentTimeMillis()+"");
TestModel testModel1 = new TestModel("setModelTitle","setModelDetail1",1);
TestModel testModel2 = new TestModel("setModelTitle","setModelDetail2",2);
TestModel testModel3 = new TestModel("setModelTitle","setModelDetail3",3);
TestModel testModel4 = new TestModel("setModelTitle","setModelDetail4",4);
TestModel testModel5 = new TestModel("setModelTitle","setModelDetail5",5);
ModelDao modelDao = new ModelDao(this);
//LogUtil.infoE(this,"testModel:"+(testModel==null)+" modelDao:"+(modelDao==null));
//数据库的插入操作测试
modelDao.add(testModel1);
modelDao.add(testModel2);
modelDao.add(testModel3);
modelDao.add(testModel4);
modelDao.add(testModel5);
//先查询一条记录(根据ID)，更改后存贮到数据库
testModel = modelDao.queryForId(5);
testModel.setModelStatus(8);
modelDao.update(testModel);
//删除操作，删除是通过testModel ID删除
testModel.setModelId(6);
modelDao.delete(testModel);
//数据库的查询操作测试
List<TestModel> testModelList = modelDao.queryForAll();
for(int i=0;i<testModelList.size();i++) {
LogUtil.infoE(this, testModelList.get(i).toString());
}
//条件查询，根据TestModel参数匹配，TestModel设置几个参数匹配几个参数
TestModel testModel6 = new TestModel();
testModel6.setModelTitle("setModelTitle");
List<TestModel> testModelList1 = modelDao.queryForModel1(testModel6);
for(int i=0;i<testModelList1.size();i++) {
LogUtil.infoE(this, "条件查询"+testModelList1.get(i).toString());
}
LogUtil.infoE(this, "OrmLiteStartEnd:"+System.currentTimeMillis()+"");
}
