说明：
GreenDao是一个数据表对象映射的框架，用于简化数据表的增删改查操作，将编写sql语句改为直接操作java对象，增删改查的过程操作的是对象，而不是sql语句。
一、添加依赖：
1.打开工程根目录，在build.gradle中添加classpath：
buildscript {
...
dependencies {
...
//greendao插件
classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'
}
}...
//应用greendao插件
apply plugin: 'org.greenrobot.greendao'
android {
...
greendao {
//设置数据库版本号
schemaVersion 1
//设置dao的包名，不设置默认为实体类的包名，build后会在此包下生成DaoMaster.java、DaoSession.java、实体类名Dao.java
daoPackage 'com.yyh.im.dao'
//设置数据库文件目录
targetGenDir 'src/main/java/'
}
}
dependencies {
...
//greendao依赖的jar包
compile 'org.greenrobot:greendao:+'
compile 'org.greenrobot:greendao-generator:+'
}
二、定义实体类(每一个实体类对应一张表，build后自动生成对应dao类)：
1.注解说明：
(1)类注解说明：
@Entity：表示此实体类为数据表（有一些属性放在@Entity()中，多个时以,分隔）：
nameInDb：指定表的名称，为空则用类名作表名
使用：@Entity(nameInDb="表名")
createInDb：默认为true，是否创建表
使用：@Entity(createInDb = true)
schema，默认为default，设置当前实体属于哪个schema
使用：@Entity(schema = "schema值")
active：默认为false，是否生成更新/删除/刷新方法，当实体类中有ToMany和ToOne的时，这个值无效，都会产生这3个方法
使用：@Entity(active = true)
(2)成员变量注解说明：
@Id：表示此变量为表主键，autoincrement表示主键自增
使用：
@Id(autoincrement = true)
private Long 变量名;
@NotNull：表示此变量值不能为null
使用：
@NotNull
private String 变量名;
@Unique：表示此变量值唯一
使用：
@Unique
private String 变量名;
@Index：表示索引
使用：
@Index(unique = true)
private long 变量名;
@OrderBy：表示此变量列表结果进行排序
使用：
@OrderBy(value = "ASC")
private String 变量名;
一对一，A表需要保存B表的id值时，只在A类中加入@ToOne：
public class A {
...
private long bId; //此id值用于链接B表的id值，命名随意
@ToOne(joinProperty = "bId") //bId为上面定义的值
private B b; //保存着B对象
}
类B：
public class B {
...
}
一对多，A表需要保存B表的id值时，在A类中加入@ToOne，并在B类加入ToMany：
public class A {
...
private long bId; //此id值用于链接B表的id值，命名随意
@ToOne(joinProperty = "bId") //bId为上面定义的值
private B b; //保存着B对象
}
类B：
public class B {
...
@ToMany(referencedJoinProperty = "bId") //引用A类中定义的bId
private List<A> as; //保存着A对象列表
}
多对多，A表需要保存B表的id值时，在A类中加入@ToOne，并在B类加入ToMany：
public class A {
...
@ToMany
@JoinEntity(
entity = AAndB.class,
sourceProperty = "aId", //aId为中间类中的aId
targetProperty = "bId" //bId为中间类中的bId
)
private List<B> b;
}
类B：
public class B {
...
@ToMany
@JoinEntity(
entity = AAndB.class,
sourceProperty = "bId", //bId为中间类中的aId
targetProperty = "aId" //aId为中间类中的bId
)
private List<A> a;
}
中间类AAndB：
public class B {
...
private Long aId; //aId为A表的id
private Long bId; //bId为B表的id
}
@Transient：忽略属性，不在表中创建此字段，使用：
@Transient
private String 变量名;
@Property：设置列名，不设时以变量名作为列名
使用：
@Property(nameInDb = "列名")
private String 变量名;
@generated：build时自动产生的2.定义实体类(展示各字段，以及示例一对一、一对多、多对多)：
Adress.java类定义(与User一对一)：
@Entity(nameInDb = "ADRESS")
public class Adress {
@NotNull
@Unique
@Id
private Long id;
private String name;
}
Department.java定义(与User一对多)：
@Entity(nameInDb = "DEPARTMENT")
public class Department {
@NotNull
@Unique
@Id
private Long id;
@NotNull
private String name;
/**
* departmentId为用户对象中的字段，实现一对多(部门为一，用户为多)
*/
@ToMany(referencedJoinProperty = "departmentId")
private List<User> users;
}Job.java类定义(与User多对多)：
@Entity(nameInDb = "JOB")
public class Job {
@NotNull
@Unique
@Id
private Long id;
@NotNull
@Property(nameInDb = "NAME")
private String name;
/**
* Job和User多对多
*/
@ToMany
@JoinEntity(
entity = UserAndJob.class,
sourceProperty = "jobId",
targetProperty = "userId"
)
private List<User> users;
}@Entity(nameInDb = "USER")
public class User {
@NotNull
@Unique
@Id
private Long id;
@NotNull
@Property(nameInDb = "NAME")
private String name;
private long adressId;
/**
* 一对一，用adressId关联Adress
*/
@ToOne(joinProperty = "adressId")
private Adress adress;
/**
* 部门id
*/
private long departmentId;
/**
* User和Department多对一
*/
@ToOne(joinProperty = "departmentId")
private Department department;
/**
* User和Job多对多
*/
@ToMany
@JoinEntity(
entity = UserAndJob.class,
sourceProperty = "userId",
targetProperty = "jobId"
)
private List<Job> sheep;
@Transient
private int temp;
}关联User和Job的中间类UserAndJob.java：
@Entity(nameInDb = "USER_JOB")
public class UserAndJob {
@NotNull
@Unique
@Id(autoincrement = true)
private Long id;
private Long userId;
private Long jobId;
}
三、增加改查操作：
1.Dao管理类：
/**
* Dao管理类
*/
public class DaoManager {
private static final String DB_NAME = "db";
private static DaoManager instance;
private DaoMaster.DevOpenHelper mDBOpenHelper;
public static DaoManager getInstance(Context context) {
if (instance == null) {
synchronized (DaoManager.class) {
if (instance == null) {
instance = new DaoManager(context);
}
}
}
return instance;
}
private DaoManager(Context context) {
//创建DatabaseOpenHelper实例
mDBOpenHelper = new DaoMaster.DevOpenHelper(context, DB_NAME, null);
}
/**
* 读数据时使用的DaoSession
*/
public DaoSession getReadableDatabase() {
return new DaoMaster(mDBOpenHelper.getReadableDatabase()).newSession();
}
/**
* 写数据时使用的DaoSession
*/
public DaoSession getWritableDatabase() {
return new DaoMaster(mDBOpenHelper.getWritableDatabase()).newSession();
}
/**
* 关闭SQLiteDatabase
*/
public void close() {
if (mDBOpenHelper != null) {
mDBOpenHelper.close();
mDBOpenHelper = null;
}
}
}/**
* 用户业务类
*/
public class UserBiz {
private DaoManager mDaoManager;
private static UserBiz instance;
private UserBiz(Context context) {
mDaoManager = DaoManager.getInstance(context);
}
public static UserBiz getInstance(Context context) {
if (instance == null) {
instance = new UserBiz(context);
}
return instance;
}
/**
* 批量更新/插入
*
* @param users 用户列表
*/
public void insertOrUpdate(List<User> users) {
mDaoManager.getReadableDatabase().getUserDao().insertOrReplaceInTx(users);
}
/**
* 更新/插入
*
* @param user 用户信息
*/
public void insertOrUpdate(User user) {
mDaoManager.getReadableDatabase().getUserDao().insertOrReplaceInTx(user);
}
/**
* 查询所有用户
*
* @return 用户列表
*/
public List<User> findAll() {
return mDaoManager.getReadableDatabase().getUserDao().loadAll();
}
/**
* 根据id查询用户
*
* @param id 用户id
*/
public User findById(String id) {
UserDao dao = mDaoManager.getReadableDatabase().getUserDao();
return dao.queryBuilder().where(UserDao.Properties.Id.eq(id)).unique();
}
/**
* 根据用户名模糊查找用户
*
* @param name 用户名
* @return
*/
public List<User> search(String name) {
UserDao dao = mDaoManager.getReadableDatabase().getUserDao();
return dao.queryBuilder().where(UserDao.Properties.Name.like("%" + name + "%")).list();
}
/**
* 删除用户
*
* @param id 用户id
*/
public void delete(long id) {
UserDao dao = mDaoManager.getReadableDatabase().getUserDao();
dao.queryBuilder().where(UserDao.Properties.Id.eq(id)).buildDelete().executeDeleteWithoutDetachingEntities();
}
}