@DatabaseField(dataType=DataType.ENUM_STRING,columnName=TIPO_FIELD_NAME)
private TipoP
public enum TipoPedido {
REGISTARNOTIFICACAORESPOSTA("Registar Notifica??o Resposta",SIGLA_TIPO_REGISTARNOTIFICATIORESPOSTA);
private String tipoN
private String tipoV
TipoPedido(String tipoName,String tipoValue){
this.tipoName=tipoN
this.tipoValue=tipoV
public String getTipoName(){
return tipoN
public String getTipoValue(){
return tipoV
Is it possible to use the tipoValue enum property as the value for the column instead of the ordinal?
Edit:here's what i did:
Created the MyEnumPersister class:
public class MyEnumPersister extends EnumStringType{
private static final MyEnumPersister singleTon = new MyEnumPersister();
* @param sqlType
* @param classes
protected MyEnumPersister() {
super(SqlType.STRING, new Class&?&[] { Enum.class });
public static MyEnumPersister getSingleton() {
return singleT
public Object javaToSqlArg(FieldType fieldType, Object obj) {
return ((EstadoPedido)obj).getEstadoValue();
public Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos)
throws SQLException {
return PedidoDTO.siglaEstadoPedidoComparator((String)sqlArg);
In javatoSqlArg i return directly the string corresponding to the estadoValue by using the getter inside the Enum.
I assume to get it back to a Enum from the DataBase i will need to implement the sqlArgToJava method too, but i'm yet to build it.
edit2: Seems that when i do a query on the table that holds the data, the method javaToSqlArg gets called before the sqlArgToJava, why??? here's the query:
public List&PedidoDTO& getPendingRequests(){
List&PedidoDTO& pendingReq=
QueryBuilder&PedidoDTO, Integer& queryBuild=
queryBuild=getHelper().getPedidosDao().queryBuilder();
pendingReq=queryBuild.where().eq(PedidoDTO.ESTADO_FIELD_NAME, PedidoDTO.SIGLA_ESTADO_PENDENTE).query();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return pendingR
The obj value appears as "P" which was what i convert to sql when i inserted it in the Database. Doesnt make too much sense....
解决方案 By default ORMLite stores the string name of the enumerated type -- in your case it would store REGISTARNOTIFICACAORESPOSTA.
You can override this behavior and store the ordinal value by using the ENUM_INTEGER data-type:
@DatabaseField(dataType=DataType.ENUM_INTEGER)
private TipoP
This will store the integer ordinal value in the database instead of the string.
To quote the docs:
The string name is the default (and recommended over ENUM_INTEGER) because it allows you to add additional enums anywhere in the list without worrying about having to convert data later.
However, it seems like you want to store the tipoValue string from the enum instead.
To do this you are doing to have to register a custom persister instead.
See the docs about this:
This allows you to define specifically how you want to translate the Java field into the database representation, and vice versa.
The two important methods are:
which converts from the Java into the database format and
which converts from the database back into Java.
You can extend
and build the converter from the ground up or you can extend
and just override the above important methods.
本文地址： &
@DatabaseField（dataType的= DataType.ENUM_STRING，COLUMNNAME = TIPO_FIELD_NAME）私人TipoPedido TIPO;公共枚举TipoPedido {
REGISTARNOTIFICACAORESPOSTA（“RegistarNotifica??oResposta”，SIGLA_TIPO_REGISTARNOTIFICATIORESPOSTA）;
私人字符串tipoN
私人字符串tipoV
TipoPedido（字符串tipoName，字符串tipoValue）{
this.tipoName = tipoN
this.tipoValue = tipoV
公共字符串getTipoName（）{
公共字符串getTipoValue（）{
}} 是否有可能使用tipoValue枚举属性作为值的列代替序号编辑：这里就是我所做的：创建了MyEnumPersister类： 公共类MyEnumPersister扩展EnumStringType {私有静态最终MyEnumPersister单身=新MyEnumPersister（）;/ ** * @参数则sqlType * @参数类 * /保护MyEnumPersister（）{
超（SqlType.STRING，新的Class＆LT;＆GT; [] {Enum.class}）;}公共静态MyEnumPersister getSingleton（）{
返回辛格尔顿;}@覆盖公共对象javaToSqlArg（的FieldType字段类型，obj对象）{
返回（（EstadoPedido）OBJ）.getEstadoValue（）;}@覆盖公共对象sqlArgToJava（的FieldType字段类型，对象sqlArg，INT columnPos）
抛出的SQLException {
返回PedidoDTO.siglaEstadoPedidoComparator（（字符串）sqlArg）;} } 在javatoSqlArg我直接返回通过使用枚举内的吸气剂对应于estadoValue字符串。我想从数据库中，我将需要实现sqlArgToJava方法太拿回来一个枚举，但我还没有建立它。 EDIT2：看来，当我做保存数据，方法javaToSqlArg得到的sqlArgToJava之前调用表的查询，为什么？这里的查询： 公开名单＆LT; PedidoDTO＆GT; getPendingRequests（）{
清单＆LT; PedidoDTO＆GT; pendingReq = NULL;
QueryBuilder的＆LT; PedidoDTO，整数GT; queryBuild = NULL;
queryBuild = getHelper（）方法getPedidosDao（）QueryBuilder的（）。;
pendingReq = queryBuild.where（）EQ（PedidoDTO.ESTADO_FIELD_NAME，PedidoDTO.SIGLA_ESTADO_PENDENTE）.query（）。
}赶上（的SQLException E）{
// TODO自动生成catch块
e.printStackTrace（）;
返回pendingR}
obj的值显示为这是我转换成SQL时我在数据库中插入为“P”。犯规什么太大的意义...... 解决方案 默认情况下ORMLite存储枚举类型的字符串名称 - 在你的情况下，将存储 REGISTARNOTIFICACAORESPOSTA
。您可以覆盖此行为，并通过 ENUM_INTEGER 数据类型存储序号值：
@DatabaseField（dataType的= DataType.ENUM_INTEGER）私人TipoPedido TIPO; 这将存储整数数据库而不是字符串序号值。引用文档：
字符串名称是默认（和建议在 ENUM_INTEGER ），因为它可以让你在列表中的任意位置添加额外的枚举，而不必担心数据后进行转换。不过，好像你要存储从枚举的 tipoValue 字符串而不是。要做到这一点，你正在做的有，而不是注册自定义持留。查看有关此文档：
这让你想如何在Java领域转化为数据库重新presentation您具体界定，反之亦然。这两种重要的方法是： 它从Java转换成数据库格式和 从数据库转换回Java的。您可以延长并建立从地面转换器或可以扩展的或的，只是覆盖上面的重要方法。
本文地址： &
扫一扫关注IT屋
微信公众号搜索 “ IT屋 ” ，选择关注
与百万开发者在一起
(window.slotbydup = window.slotbydup || []).push({
id: '5828425',
container: s,
size: '300,250',
display: 'inlay-fix'
同步:探寻宇宙核心的搏动,解密自然对秩序的向往
数据之美:一本书学会可视化设计ORMLite完全解析（三）官方文档第三章、自定义查询构造器 Custom Query Builder
接着上一篇，下面是第三章的翻译整理，理解错误的地方还请批评指正。
尊重原创，转载请说明出处，谢谢！
第三章、 自定义查询构造器
查询构造器基础
下面是使用查询构造器创建自定义查询语句的基本步骤。首先，以java常量的形式为属性设置列名，便于使用它
们进行查询。
@DatabaseTable(tableName = "accounts")
public class Account {
public static final String PASSWORD_FIELD_NAME = "password";
@DatabaseField(canBeNull = false, columnName = PASSWORD_FIELD_NAME)
这样就允许我们使用password属性构建查询，而不需要在后面的查询中重命名属性，及时属性名，和列名一样也
应该这样做。
// get our query builder from the DAO
QueryBuilder&Account, String& queryBuilder = accountDao.queryBuilder();
// the 'password' field must be equal to "qwerty"
queryBuilder.where().eq(Account.PASSWORD_FIELD_NAME, "qwerty");
// prepare our sql statement
PreparedQuery&Account& preparedQuery = queryBuilder.prepare();
// query for all accounts that have "qwerty" as a password
List&Account& accountList = accountDao.query(preparedQuery);
如上面的代码，你可以通过Dao.queryBuilder()方法获得一个QueryBuilder对象，然后调用这个对象的方法，调
用queryBuilder.prepare()函数获得一个PrepareQuery对象，然后，将这个PrepareQuery方法传递到DAO的查询或者
遍历方法中。
简化操作，可以在Where对象中调用prepare()方法，如下所示：
// query for all accounts that have that password
List&Account& accountList = accountDao.query(
accountDao.queryBuilder().where()
.eq(Account.PASSWORD_FIELD_NAME, "qwerty")
.prepare());
也可以使用另外一种简化方法，通过QueryBuilder或者Where对象调用query()方法或者iterator()方法。如下：
// query for all accounts that have that password
List&Account& accountList =
accountDao.queryBuilder().where()
.eq(Account.PASSWORD_FIELD_NAME, "qwerty")
3.2 构建查询语句
下面是一些不相同的构建查询语句的方式。QueryBuilder类已经针对特殊使用和强大的用户进行了内部封装。
QueryBuilder&Account, String& queryBuilder =
accountDao.queryBuilder();
// get the WHERE object to build our query
Where&Account, String& where = queryBuilder.where();
// the name field must be equal to "foo"
where.eq(Account.NAME_FIELD_NAME, "foo");
where.and();
// the password field must be equal to "_secret"
where.eq(Account.PASSWORD_FIELD_NAME, "_secret");
PreparedQuery&Account& preparedQuery = queryBuilder.prepare();
上面的语句会生成下面这样的sql语句
SELECT * FROM account WHERE (name = 'foo' AND password = '_secret')
如果你喜欢使用方法链进行操作，则上面的语句也可以这样写：
queryBuilder.where()
.eq(Account.NAME_FIELD_NAME, "foo")
.eq(Account.PASSWORD_FIELD_NAME, "_secret");
如果你喜欢使用括号将比较语句组合在一起，也可以这样用：
Where&Account, String& where = queryBuilder.where();
where.and(where.eq(Account.NAME_FIELD_NAME, "foo"),
where.eq(Account.PASSWORD_FIELD_NAME, "_secret"));
上面的三种调用方式会生成相同的sql语句。对于混合mixANDs和ORs的复杂查询而言，最后一种格式必须正确组装
，如下面这个查询：
Where&Account, String& where = queryBuilder.where();
where.and(
where.eq(Account.NAME_FIELD_NAME, "foo"),
where.eq(Account.PASSWORD_FIELD_NAME, "_secret")
where.and(
where.eq(Account.NAME_FIELD_NAME, "bar"),
where.eq(Account.PASSWORD_FIELD_NAME, "qwerty")
这个语句会长生下面这样的sql语句：
SELECT * FROM account
WHERE ((name = 'foo' AND password = '_secret')
OR (name = 'bar' AND password = 'qwerty'))
查询语句也允许指定需要查询返回的列，指定ORDER BY和GROUP BY属性，以及各种各样的sql特点，比如（LIKE,IN,&,&=,&, &=,&&, IS NULL, DISTINCT,...），具体细节查看Where Capabilities这节。也可以查看good SQL reference site中关于QueryBuilder和Where语句的java文档介绍。
构建更新和删除语句
DAO对象也可以用于构建自定义的UPDATE和DELETE语句，UPDATE语句用于改变满足Where条件的数据行中特定的属
性的值，或者，如果没有指定where的话，用于更改所有数据行的属性值。delete语句用于删除满足条件的数据行，
如果没有条件限制，则用于删除所有数据。
例如，如果你想要更新全部Account中passwords为null的值为“none”，可以使用下面的语句。
UpdateBuilder&Account, String& updateBuilder =
accountDao.updateBuilder();
// update the password to be "none"
updateBuilder.updateColumnValue("password", "none");
// only update the rows where password is null
updateBuilder.where().isNull(Account.PASSWORD_FIELD_NAME);
updateBuilder.update();
通过update语句，也可以指定表达式更新
// update hasDog boolean to true if dogC & 0
updateBuilder.updateColumnExpression("hasDog", "dogC & 0");
为了便于构造你的表达式，可以使用UpdateBuilder的escape方法escapeColumnName和escapeValue值，这个两个
方法可以携带一个String或者StringBuffer,这样可以避免列名和关键字冲突。
如果你想删除Account表中password为null的一行,可以使用下面的语句完成。
DeleteBuilder&Account, String& deleteBuilder = accountDao.deleteBuilder();
// only delete the rows where password is null
deleteBuilder.where().isNull(Account.PASSWORD_FIELD_NAME);
deleteBuilder.delete();
下面是关于QueryBuilder各种查询调用的详情。可以查看QueryBuilder类的最新JavaDoc文档获取更多信息。大
多数的方法都是返回QueryBuilder对象，以便使用方法链。
具体细节参考 tutorial of SQL commands.中的详情。
主要方法包括：
distinct()
groupBy(String columnName)
groupByRaw(String sql)
having(String sql)
join(QueryBuilder joinedQueryBuilder)
leftJoin(QueryBuilder joinedQueryBuilder)
limit(Integer maxRows)
offset(Integer startRow)
orderBy(String columnName, boolean ascending)
orderByRaw(String sql)
selectColumns(String... columns)
selectColumns(Iterable&String& columns)
selectRaw(String... columns)
queryForFirst()
queryRawFirst()
iterator()
下面是关于查询功能的详解，更多细节参考tutorial of SQL commands.
主要方法包括：
and(Where&T, ID& first, Where&T, ID& second, Where&T, ID&... others)
and(int numClauses)
between(String columnName, Object low, Object high)
eq(String columnName, Object value)
exists(QueryBuilder&?, ?& subQueryBuilder)
ge(String columnName, Object value)
gt(String columnName, Object value)
idEq(ID id)
idEq(Dao&OD, ?& dataDao, OD data)
in(String columnName, Iterable&?& objects)
in(String columnName, Object... objects)
in(String columnName, QueryBuilder&?, ?& subQueryBuilder)
isNull(String columnName)
isNotNull(String columnName)
le(String columnName, Object value)
lt(String columnName, Object value)
like(String columnName, Object value)
ne(String columnName, Object value)
not(Where&T, ID& comparison)
notIn(String columnName, Iterable&?& objects)
in(String columnName, Object... objects)
notIn(String columnName, QueryBuilder&?, ?& subQueryBuilder)
or(Where&T, ID& first, Where&T, ID& second, Where&T, ID&... others)
or(int numClauses)
raw(String rawStatement)
queryRaw()
queryForFirst()
queryRawFirst()
iterator()
使用select参数
select参数是一种使用在Where操作中的参数，这种参数可以直接指定为参数值（如上例子所示），或者作为一
个select参数对象。select参数可以用于后续设置参数值，他们会产生SQL ‘？’,类似于jdbc的占位符。
QueryBuilder&Account, String& queryBuilder = accountDao.queryBuilder();
Where&Account, String& where = queryBuilder.where();
SelectArg selectArg = new SelectArg();
// define our query as 'name = ?'
where.eq(Account.NAME_FIELD_NAME, selectArg);
// prepare it so it is ready for later query or iterator calls
PreparedQuery&Account& preparedQuery = queryBuilder.prepare();
// later we can set the select argument and issue the query
selectArg.setValue("foo");
List&Account& accounts = accountDao.query(preparedQuery);
// then we can set the select argument to another
// value and re-run the query
selectArg.setValue("bar");
accounts = accountDao.query(preparedQuery);
人们通常会试着创建一些具有参数的查询语句，并包含一些特定的符号，这些符号能自动生成sql语句，并导致
语法错误。在这种情况下可以使用SelectArg。此外，如果你的参数使用户输入的，那么使用SelectArgs可以保护你
的程序避免sql注入问题。其次，特定的数据类型可以使用一种内部的SelectArg对象，因为对象的String值对于数据
库而言是不可靠的。例如java.util.Date。
注意：SelectArg对象不能再一个对象的多列中使用，如果你想要在另外一列中使用SelectArg，你必须重新实例
化一个新的对象。
使用列参数
假如你使用QueryBuilder让一个值和列数据进行比较。那么可以使用ColumnArg：
QueryBuilder&Account, String& queryBuilder = accountDao.queryBuilder();
// list all of the accounts that have the same
// name and password field
queryBuilder.where().eq(Account.NAME_FIELD_NAME, new ColumnArg(Account.PASSWORD_FIELD_NAME));
List&Account& results = queryBuilder.query();
ColumnArg也可以携带一个表名，这种方式在JION查询中用于比较一个表中的列和另一个表中的列的数据时比较
有用。详情查看Building Join Queries一节。
构建连接查询
ORMLite支持基本的JION SQL查询，更多内容可查看JOIN documentation.
通过两个QueryBuilder对象创建一个join查询，其中一个在DAO中，用于返回你的对象，另一个DAO与第一个DAO
相关联。其中一个必须是另一个的外部属性，否则，jion方法会抛出异常。
例如：假设你想要获得一个account集合，并且这些account有一个订单的amount值大于100刀。则可以这样写：
QueryBuilder&Order, Integer& orderQb = orderDao.queryBuilder();
orderQb.where().ge("amount", 100.0F);
QueryBuilder&Account, Integer& accountQb = accountDao.queryBuilder();
// join with the order query
List&Account& results = accountQb.join(orderQb).query();
这里返回了所有的Account记录，并且，这些对象有一个对应的订单，这个订单有一个属性值大于100.
ORMLite也支持LEFTJOIN的概念，意思是，在上面的例子中，在上面的语句中，没有订单的account也会被返回。
但是，ORMLite不支持RIGHT JOIN 和 FULL JOIN的概念。
注意，其他的ORM库使用JOIN语句从多张表中获取数据填充外部对象属性和外部对象集合。ORMLite不支持这种特
性。你只能使用它从一张表中获得数据。
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！【Android - 框架】之ORMLite的使用 - ITGungnir - 博客园
随笔 - 136, 文章 - 0, 评论 - 3, 引用 - 0
　　Android中有很多操作SQLite数据库的框架，现在最常见、最常用的是ORMLite和GreenDAO。ORMLite相比与GreenDAO来说是一个轻量级的框架，而且学习成本相对较低。所以这个帖子中先介绍ORMLite，下个帖子再介绍GreenDAO。
　　要使用ORMLite，首先需要导入ORMLite的依赖：在build.gradle中加入以下代码：
compile 'com.j256.ormlite:ormlite-android:5.0'
compile 'com.j256.ormlite:ormlite-core:5.0'
　　ORMLite需要我们自己实现一个类似原生操作SQLite数据库的DatabaseHelper，但必须继承自ORMLite为我们提供的OrmLiteSqliteOpenHelper。以下是一个功能比较齐全，性能相对也比较好的实例，这个实例不仅仅起到了创建数据库和更新数据库的操作，还对自身对象进行了单例、对DAO进行了统一的管理。代码如下：
import android.content.C
import android.database.sqlite.SQLiteD
import com.example.itgungnir.testormlite.entity.ArticleB
import com.example.itgungnir.testormlite.entity.UserB
import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenH
import com.j256.ormlite.dao.D
import com.j256.ormlite.support.ConnectionS
import com.j256.ormlite.table.TableU
import java.sql.SQLE
import java.util.HashM
import java.util.M
* 数据库操作管理工具类
* 我们需要自定义一个类继承自ORMlite给我们提供的OrmLiteSqliteOpenHelper，创建一个构造方法，重写两个方法onCreate()和onUpgrade()
* 在onCreate()方法中使用TableUtils类中的createTable()方法初始化数据表
* 在onUpgrade()方法中我们可以先删除所有表，然后调用onCreate()方法中的代码重新创建表
* 我们需要对这个类进行单例，保证整个APP中只有一个SQLite Connection对象
* 这个类通过一个Map集合来管理APP中所有的DAO，只有当第一次调用这个DAO类时才会创建这个对象（并存入Map集合中）
* 其他时候都是直接根据实体类的路径从Map集合中取出DAO对象直接调用
public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
// 数据库名称
public static final String DATABASE_NAME = "mydb.db";
// 本类的单例实例
private static DatabaseH
// 存储APP中所有的DAO对象的Map集合
private Map&String, Dao& daos = new HashMap&&();
// 获取本类单例对象的方法
public static synchronized DatabaseHelper getInstance(Context context) {
if (instance == null) {
synchronized (DatabaseHelper.class) {
if (instance == null) {
instance = new DatabaseHelper(context);
// 私有的构造方法
private DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, 1);
// 根据传入的DAO的路径获取到这个DAO的单例对象（要么从daos这个Map中获取，要么新创建一个并存入daos）
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);
@Override // 创建数据库时调用的方法
public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
TableUtils.createTable(connectionSource, UserBean.class);
TableUtils.createTable(connectionSource, ArticleBean.class);
} catch (SQLException e) {
e.printStackTrace();
@Override // 数据库版本更新时调用的方法
public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
TableUtils.dropTable(connectionSource, UserBean.class, true);
TableUtils.dropTable(connectionSource, ArticleBean.class, true);
onCreate(database, connectionSource);
} catch (SQLException e) {
e.printStackTrace();
// 释放资源
public void close() {
super.close();
for (String key : daos.keySet()) {
Dao dao = daos.get(key);
dao = null;
　　在这个帖子中，我们通过这样一个例子来了解ORMLite：数据库中有两个表，一个是user表，其中存储用户的信息；另一个是article表，存储文章信息，一个用户可以关良多篇文章，一篇文章只能关联一个用户。
　　有了上面的需求，下面我们来写两个实体类：
　　UserBean类中的代码如下：
import com.j256.ormlite.dao.ForeignC
import com.j256.ormlite.field.DatabaseF
import com.j256.ormlite.field.ForeignCollectionF
import com.j256.ormlite.table.DatabaseT
import java.util.D
* UserBean实体类，存储数据库中user表中的数据
* DatabaseTable：通过其中的tableName属性指定数据库名称
* DatabaseField：代表数据表中的一个字段
* ForeignCollectionField：一对多关联，表示一个UserBean关联着多个ArticleBean（必须使用ForeignCollection集合）
* id：当前字段是不是id字段（一个实体类中只能设置一个id字段）
* columnName：表示当前属性在表中代表哪个字段
* generatedId：设置属性值在数据表中的数据是否自增
* useGetSet：是否使用Getter/Setter方法来访问这个字段
* canBeNull：字段是否可以为空，默认值是true
* unique：是否唯一
* defaultValue：设置这个字段的默认值
@DatabaseTable(tableName = "user") // 指定数据表的名称
public class UserBean {
// 定义字段在数据库中的字段名
public static final String COLUMNNAME_ID = "id";
public static final String COLUMNNAME_NAME = "name";
public static final String COLUMNNAME_SEX = "sex";
public static final String COLUMNNAME_BIRTHDAY = "birthday";
public static final String COLUMNNAME_ADDRESS = "address";
@DatabaseField(generatedId = true, columnName = COLUMNNAME_ID, useGetSet = true)
private int
@DatabaseField(columnName = COLUMNNAME_NAME, useGetSet = true, canBeNull = false, unique = true)
@DatabaseField(columnName = COLUMNNAME_SEX, useGetSet = true, defaultValue = "1")
private char
@DatabaseField(columnName = COLUMNNAME_BIRTHDAY, useGetSet = true)
@DatabaseField(columnName = COLUMNNAME_ADDRESS, useGetSet = true)
@ForeignCollectionField(eager = true)
private ForeignCollection&ArticleBean&
public UserBean() {
public UserBean(String name, char sex, Date birthday, String address) {
this.name =
this.sex =
this.birthday =
this.address =
public int getId() {
public void setId(int id) {
public String getName() {
public void setName(String name) {
this.name =
public char getSex() {
public void setSex(char sex) {
this.sex =
public Date getBirthday() {
public void setBirthday(Date birthday) {
this.birthday =
public String getAddress() {
public void setAddress(String address) {
this.address =
public ForeignCollection&ArticleBean& getArticles() {
public void setArticles(ForeignCollection&ArticleBean& articles) {
this.articles =
public String toString() {
return "UserBean{" +
"id=" + id +
", name='" + name + '\'' +
", sex=" + sex +
", birthday=" + birthday +
", address='" + address + '\'' +
", articles=" + articles +
　　ArticleBean类中的代码如下：
import com.j256.ormlite.field.DatabaseF
import com.j256.ormlite.table.DatabaseT
* ArticleBean实体类，存储article数据表中的数据
* 数据库中的article表和user表是关联的，因此我们需要在article表中配置外键
* foreignColumnName：外键约束指向的类中的属性名
* foreign：当前字段是否是外键
* foreignAutoRefresh：如果这个属性设置为true，在关联查询的时候就不需要再调用refresh()方法了
@DatabaseTable(tableName = "article")
public class ArticleBean {
// article表中各个字段的名称
public static final String COLUMNNAME_ID = "id";
public static final String COLUMNNAME_TITLE = "title";
public static final String COLUMNNAME_CONTENT = "content";
public static final String COLUMNNAME_USER = "user_id";
@DatabaseField(generatedId = true, columnName = COLUMNNAME_ID, useGetSet = true)
private int
@DatabaseField(columnName = COLUMNNAME_TITLE, useGetSet = true, canBeNull = false, unique = true)
@DatabaseField(columnName = COLUMNNAME_CONTENT, useGetSet = true)
@DatabaseField(columnName = COLUMNNAME_USER, foreign = true, foreignAutoRefresh = true, foreignAutoCreate = true,
foreignColumnName = UserBean.COLUMNNAME_ID)
private UserBean user_
public ArticleBean() {
public ArticleBean(String title, String content, UserBean user) {
this.title =
this.content =
this.user_id =
public int getId() {
public void setId(int id) {
public String getTitle() {
public void setTitle(String title) {
this.title =
public String getContent() {
public void setContent(String content) {
this.content =
public UserBean getUser() {
return user_
public void setUser(UserBean user) {
this.user_id =
public String toString() {
return "ArticleBean{" +
"id=" + id +
", title='" + title + '\'' +
", content='" + content + '\'' +
", user=" + user_id +
　　从两个实体类中的代码来看，ORMLite和JavaWeb框架中的Hibernate相似，都是使用注解的方式来标注数据库中的表、字段、关联关系的，这也是ORMLite的工作原理：ORMLite是基于反射机制工作的，然而这也成为了ORMLite的一个非常致命的缺点，性能不好。因此，如果是对想能要求不高的项目，我们可以考虑使用ORMLite，而如果项目对性能要求较高，我们可以考虑使用GreenDAO。
　　至于各个标签、各个属性的用途，将在本贴的最后贴出。
　　现在让我们再来看ORMLite中的另一个比较重要的东西——DAO。DAO是用来将操作某张表的方法（增、删、改、查）封装起来的工具类。下面来看代码：
　　UserDao类中的代码：
import android.content.C
import com.example.itgungnir.testormlite.db.DatabaseH
import com.example.itgungnir.testormlite.entity.UserB
import com.j256.ormlite.dao.D
import java.sql.SQLE
import java.util.L
* 操作User数据表的Dao类，封装这操作User表的所有操作
* 通过DatabaseHelper类中的方法获取ORMLite内置的DAO类进行数据库中数据的操作
* 调用dao的create()方法向表中添加数据
* 调用dao的delete()方法删除表中的数据
* 调用dao的update()方法修改表中的数据
* 调用dao的queryForAll()方法查询表中的所有数据
public class UserDao {
// ORMLite提供的DAO类对象，第一个泛型是要操作的数据表映射成的实体类；第二个泛型是这个实体类中ID的数据类型
private Dao&UserBean, Integer&
public UserDao(Context context) {
this.context =
this.dao = DatabaseHelper.getInstance(context).getDao(UserBean.class);
} catch (SQLException e) {
e.printStackTrace();
// 向user表中添加一条数据
public void insert(UserBean data) {
dao.create(data);
} catch (SQLException e) {
e.printStackTrace();
// 删除user表中的一条数据
public void delete(UserBean data) {
dao.delete(data);
} catch (SQLException e) {
e.printStackTrace();
// 修改user表中的一条数据
public void update(UserBean data) {
dao.update(data);
} catch (SQLException e) {
e.printStackTrace();
// 查询user表中的所有数据
public List&UserBean& selectAll() {
List&UserBean& users = null;
users = dao.queryForAll();
} catch (SQLException e) {
e.printStackTrace();
// 根据ID取出用户信息
public UserBean queryById(int id) {
UserBean user = null;
user = dao.queryForId(id);
} catch (SQLException e) {
e.printStackTrace();
　　ArticleDao类中的代码：
import android.content.C
import com.example.itgungnir.testormlite.db.DatabaseH
import com.example.itgungnir.testormlite.entity.ArticleB
import com.j256.ormlite.dao.D
import java.sql.SQLE
import java.util.L
* 操作article表的DAO类
public class ArticleDao {
// ORMLite提供的DAO类对象，第一个泛型是要操作的数据表映射成的实体类；第二个泛型是这个实体类中ID的数据类型
private Dao&ArticleBean, Integer&
public ArticleDao(Context context) {
this.context =
this.dao = DatabaseHelper.getInstance(context).getDao(ArticleBean.class);
} catch (SQLException e) {
e.printStackTrace();
// 添加数据
public void insert(ArticleBean data) {
dao.create(data);
} catch (SQLException e) {
e.printStackTrace();
// 删除数据
public void delete(ArticleBean data) {
dao.delete(data);
} catch (SQLException e) {
e.printStackTrace();
// 修改数据
public void update(ArticleBean data) {
dao.update(data);
} catch (SQLException e) {
e.printStackTrace();
// 通过ID查询一条数据
public ArticleBean queryById(int id) {
ArticleBean article = null;
article = dao.queryForId(id);
} catch (SQLException e) {
e.printStackTrace();
// 通过条件查询文章集合（通过用户ID查找）
public List&ArticleBean& queryByUserId(int user_id) {
return dao.queryBuilder().where().eq(ArticleBean.COLUMNNAME_USER, user_id).query();
} catch (SQLException e) {
e.printStackTrace();
return null;
　　最后就是测试代码了。我们直接在MainActivity中写代码，然后运行看结果。在MainActivity中，我们首先创建两张表并向表中添加数据，然后从数据表中分别取出数据，展示到TextView中。代码如下：
import android.support.v7.app.AppCompatA
import android.os.B
import android.widget.TextV
import com.example.itgungnir.testormlite.dao.ArticleD
import com.example.itgungnir.testormlite.dao.UserD
import com.example.itgungnir.testormlite.entity.ArticleB
import com.example.itgungnir.testormlite.entity.UserB
import com.j256.ormlite.dao.ForeignC
import java.util.D
import java.util.I
public class MainActivity extends AppCompatActivity {
private TextV
private StringBuffer contentB
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv = (TextView) findViewById(R.id.tv);
contentBuffer = new StringBuffer();
initData();
initView();
// 初始化数据
private void initData() {
// 添加用户数据
UserBean userData = new UserBean("张三", '1', new Date(), "北京");
new UserDao(MainActivity.this).insert(userData);
// 添加文章数据
ArticleBean articleData = new ArticleBean("标题", "内容内容内容内容内容内容", userData);
new ArticleDao(MainActivity.this).insert(articleData);
// 初始化视图
private void initView() {
// 从数据库中根据ID取出文章信息
ArticleBean articleBean = new ArticleDao(MainActivity.this).queryById(1);
contentBuffer.append(articleBean.toString());
// 根据取出的用户id查询用户信息
UserBean userBean = new UserDao(MainActivity.this).queryById(articleBean.getUser().getId());
contentBuffer.append("\n\n" + userBean.toString());
// 从用户信息中取出关联的文章列表信息
ForeignCollection&ArticleBean& articles = userBean.getArticles();
Iterator&ArticleBean& iterator = articles.iterator();
contentBuffer.append("\n\n");
while (iterator.hasNext()) {
ArticleBean article = iterator.next();
contentBuffer.append(article.toString() + "\n");
// 设置TextView的文本
tv.setText(contentBuffer.toString());
　　运行结果如下图所示：
　　最后，贴出ORMLite中常用标签和各个属性代表的意义：
　　常见标签：
DatabaseTable：通过其中的tableName属性指定数据库名称
DatabaseField：代表数据表中的一个字段
ForeignCollectionField：一对多关联，表示一个UserBean关联着多个ArticleBean（必须使用ForeignCollection集合）
　　常见属性：
id：当前字段是不是id字段（一个实体类中只能设置一个id字段）
columnName：表示当前属性在表中代表哪个字段
generatedId：设置属性值在数据表中的数据是否自增
useGetSet：是否使用Getter/Setter方法来访问这个字段
canBeNull：字段是否可以为空，默认值是true
unique：是否唯一
defaultValue：设置这个字段的默认值
foreignColumnName：外键约束指向的类中的属性名
foreign：当前字段是否是外键
foreignAutoRefresh：如果这个属性设置为true，在关联查询的时候就不需要再调用refresh()方法了
　　以上就是对ORMLite框架的基本使用了，希望对大家有帮助~~~~}