GeenDao 3.0

 
 

  
  
关于GreenDao
  
  

  
  
greenDao是一个将对象映射到SQLite数据库中的轻量且快速的ORM解决方案。

关于greenDAO的概念可以看官网greenDAO
  
  

  
  
greenDAO 优势
  
  

  
  
1、一个精简的库

2、性能最大化

3、内存开销最小化

4、易于使用的 APIs

5、对 Android 进行高度优化
  
  

  
  
GreenDao 3.0使用
  
  

  
  
GreenDao 3.0采用注解的方式来定义实体类，通过gradle插件生成相应的代码。
  
  

  
  
一，在as中导入相关的包
  
  

  
  
compile'org.greenrobot:greendao:3.0.1'
compile'org.greenrobot:greendao-generator:3.0.0'

  
  
二，在build.gradle中进行配置：
  
  
apply plugin: 'org.greenrobot.greendao'
buildscript { 
    repositories { 
        mavenCentral()    
}    
dependencies {
    classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'    
    }
}
 
 


三. 在app build.gradle中添加 在android{} 下添加

greendao {
schemaVersion 1 //数据库schema版本，也可以理解为数据库版本号
daoPackage 'com.hlx.xqcopy.greendao.dao'  //设置DaoMaster、DaoSession、Dao包名
targetGenDir 'src/main/java' //设置DaoMaster、DaoSession、Dao目录
}

  
  

   
   
在gradle的根模块中加入上述代码，就完成了我们的基本配置了。


   
   

   
   
四，创建一个User的实体类
   
   

   
   
@Entity
public class User {
    @Id 
    private Long id; 
    private String name; 
    @Transient 
    private int tempUsageCount; // not persisted  
}
  
  

编译就会生成DaoMaster、DaoSession、xxxDao
五.注解类型
   
   

    
    
@Entity可以在不使用参数下使用，但是也可以给Entity配置参数，其参数如下


    
    
//如果该实体属于多个表单，可以使用该参数; 
schema = "myschema",  
// 该实体属于激活状态，激活状态的实体有更新，删除，刷新方法; 
active = true,  
// 给这个表指定一个名字，默认情况下是名字是类名 
nameInDb = "AWESOME_USERS",
 // 可以给多个属性定义索引和其他属性.
 indexes = { @Index(value = "name DESC", unique = true) },  
//是否使用GreenDao创建该表.
 createInDb = false,   
// 是否所有的属性构造器都应该被生成，无参构造器总是被要求
 generateConstructors = true,  
// 如果该类中没有set get方法是否自动生成 
generateGettersSetters = true
   
   
    
    

     
     
基本注释属性
@ID 一般会选择long/Long属性作为Entity ID（即数据库中的主键）autoincrement=true表示主键会自增如果false就会使用旧值
@Property 可以自定义一个该属性在数据库中的名称，默认情况下数据库中该属性名称是Bean对象中的 属性名但是不是以驼峰式而是以大写与下划线组合形式来命名的比如：customName将命名为 CUSTOM_NAME;注意：外键不能使用该属性；
@NotNull 确保属性值不会为null值;
@Transient 使用该注释的属性不会被存入数据库中;
@Unique 将属性变成唯一约束属性;也就是说在数据库中该值必须唯一
@Generated 提示开发者该属性不能被修改；并且实体类的方法，属性，构造器一旦被@Generated注释就不能被再次修改，否则或报错


     
     
Error:Execution failed for task ':app:greendao'.> Constructor (see 
ExampleEntity:21) has been changed after generation.Please either mark 
it with @Keep annotation instead of @Generated to keep it untouched,or
 use @Generated (without hash) to allow to replace it.

     
     
这是因为在通过javabean对象自动生成entities类时，greenDao会增加实体类代码，@Generated注释部分与GreenDao增加的代码相关，胡乱修改@Generated代码，就会导致entities部分属性与javabean不匹配导致报错；有俩种方法可以避免这种错误
     
     
还原@Generated 改动的部分，当然你也可以完全删除@Generated 注释的部分下一次 app build时将会自动生成；
使用@Keep 代替@Generated 这将告诉greenDao 不会使用该属性注释的代码，但是这种改变可能会破坏entities类和greenDAO的其他部分的连接；注意：默认情况下 greenDao会使用合理的默认值去设置实体类，因此开发者不需要为每个属性都添加注释
     
     
@Entity
public class User { 
      @Id(autoincrement = true)
       private Long id;  
      @Property(nameInDb = "USERNAME") 
       private String name;  
      @NotNull 
      private int repos;  
      @Transient 
      private int tempUsageCount; 
 ...}

     
     

     
     
主键限制
每个实体类都应该有一个long或者LONG型属性作为主键；如果你不想用long或者LONG型作为主键，你可以使用一个唯一索引(使用@Index(unique = true)注释使普通属性改变成唯一索引属性)属性作为关键属性。
     
     
@Id
private Long id; 
@Index(unique = true)
private String key;

     
     
索引属性
使用@Index 可以将一个属性变为数据库索引；其有俩个参数
name :不使用默认名称，自定义索引名称
unique : 给索引增加一个唯一约束，迫使该值唯一
     
     
@Entity
public class User { 
@Id 
private Long id;
 @Index(unique = true)
 private String name;
}

     
     
核心代码初始化
创建数据库过程
     
     
// 下面代码仅仅需要执行一次，一般会放在application
helper = new DaoMaster.DevOpenHelper(this, "notes-db", null);
db = helper.getWritableDatabase();
daoMaster = new DaoMaster(db);
daoSession = daoMaster.newSession();
// 在activity或者fragment中获取Dao对象
noteDao = daoSession.getNoteDao()

     
     
完成以上所有工作以后，我们的数据库就已经自动生成了，接下来就可以对数据库进行操作了；
     
     
增删改查
greenDao的增，删 ，改操作比较简单分别调用insert(),delete(),update()方法即可，save()方法比较特殊既能执行插入操作也能执行修改操作这个具体的可以查看greenDaoAPI
Query
与原生SQLitedatabases的查询操作相比，greenDao Query简直不能再简单;greenDao 使用QueryBuilder构建查询语句也支持原生的SQL查询语句
       
       
简单的查询语句 在用户表中查询叫姓“Joe”的所有的用户:
     
     
 List joes = userDao.queryBuilder() 
.where(Properties.FirstName.eq("Joe")) 
.orderAsc(Properties.LastName) .list(); 

     
     
嵌套挑去查询语句：查询一个出生在1970年10月或者以后的"joe"用户
     
     
QueryBuilder qb = userDao.queryBuilder();
qb.where(Properties.FirstName.eq("Joe"),//第一个约束条件姓乔
qb.or(Properties.YearOfBirth.gt(1970),//或者出生日期大于1970年
qb.and(Properties.YearOfBirth.eq(1970), 
Properties.MonthOfBirth.ge(10))//并且在1970年出生 但是月份大于
10月的));
List youngJoes = qb.list();

     
     
greenDao除了eq()操作之外还有很多其他方法大大方便了我们日常查询操作比如：
- eq()：==  
- noteq()：!= 
- gt()： >
- lt()：< 
- ge：>=
- le:<= 
- like()：包含
- between：俩者之间
- in：在某个值内 
- notIn：不在某个值内

     
     
分页查询
       
       
limit(int): 限制查询的数量;
offset(int): 每次返回的数量; offset不能单独使用；
查询与LazyList类
       
       
Query ： Query类表示一个查询能够执行很多次;使用QueryBuilder.build()创建，而当通过QueryBuilder的任何查询方法（eg:list()）来获取查询结果时，querybuilder都会 在其内部创建Query来执行查询语句的;如果执行多次查询应该使用Query对象; 如果只想获取一个结果时可以使用Query(or QueryBuilder)中的unique()方法;
LazyList : 可以通过以下方法获取查询结果集合；
list() 缓存查询结果;list()类型一般为ArrayList
listLazy() 懒查询,只有当调用list()中的实体对象时才会执行查询操作并且只缓存第一次被查询的结果，需要关闭
listlazyUncached() 懒查询,只有当调用list()中的实体对象时才会执行查询操作并且不缓存;
listIterator() 对查询结果进行遍历，不缓存，需要关闭;
     
     
后面三个方法是LazyList类中的方法，LazyList为了执行不同的缓存策略其内部持有数据库的cursor对象；一般情况下这三个方法执行完毕后会自动关闭cursor；但是防止在还没有执行完查询结果时，对象被终结cursor还是无法被关闭的情况发生，需要手动关闭close();
     
     
多次执行查询语句
Query对象一旦生成就能多次被使用，你也可以为下一次查询增加查询条件
     
     
// fetch users with Joe as a first name born in 1970Query 
query = userDao.queryBuilder().where( 
Properties.FirstName.eq("Joe"), 
Properties.YearOfBirth.eq(1970)).build();List joesOf1970 = 
query.list(); // using the same Query object, we can change the 
parameters// to search for Marias born in 1977 
later:query.setParameter(0, "Maria");query.setParameter(1, 
1977);List mariasOf1977 = query.list();
    
    
	
	

     
     
 自定义SQL语句

    
    

Cursor cursor = dao.getDatabase().rawQuery("select t.sales_wx_nick_name,t.wx_nick_name,count(*),t.talker_id,t.sales_wx_account from chat_history t group by t.talker_id,t.sales_wx_account order by t.created_at desc", null);  
while (cursor.moveToNext()) {  
    String salesWxNickName = cursor.getString(0);  
    String clientWxNickName = cursor.getString(1);  
    int chatCount = cursor.getInt(2);  
    int talkerId = cursor.getInt(3);  
    String salesWxAccount = cursor.getString(4);  
}  


     
     

      
      
在多线程执行查询

如果有多条线程执行查询语句时需要调用forCurrentThread()方法将query对象与当前线程进行绑定，如果其他线程修改该Query对象，greenDao将会抛出一个异常;forCurrentThread()方法通过将Query创建时的时间作为 query标识;
使用SQL查询

如果QueryBuilder不能满足需求可以使用以下俩种方法来实现你的需求；
首选方法用SQL语句：


      
      
Query query = userDao.queryBuilder().where( new 
StringCondition("_ID IN " + "(SELECT USER_ID FROM 
USER_MESSAGE WHERE READ_FLAG = 0)")).build();

      
      
备选方法 ：
使用queryRaw 或者queryRawCreate：
      
      
Query query = userDao.queryRawCreate( ", GROUP G WHERE 
G.NAME=? AND T.GROUP_ID=G._ID", "admin");
     
     

      
      

       
       
在同一个session中如果一个entities已经被session记录那么下一次再次操作该实体时，greenDao会先从内存中查找，如果内存中没有再去数据库中查找。这样一方面就极大的提高greenDao的查询效率，另一方面也是需要特别注意的是当entities更新过 greenDao仍然会从内存中取出旧值，所以如果entities更新过，需要去调用daoseesion.clear()方法清除缓存后才能查到最新值，否则查询到的将还是保存在内存中的值。

下面介绍下清除缓存有两种方法

       
       
清除所所有的缓存


       
       
daoSession.clear();

       
       
清除指定Dao类的缓存
       
       
projectDao = daoSession.getNoteDao();
projectDao.detachAll();
      
      

       
       

        
        
多表关联

        
        
1. 1：1关联

当我们在使用sqlite数据库来实现表的1：1关联时，通常我们会在主表中定义一个外键去关联副表，当要查询对应的数据时，首先我们要知道查询数据的外键，然后需要用外键去副表中查询所需要的数据。比如下面这样

        
        
  public class Customer {
    private Long id;
  }
  public class Order {
    private Long id;
    private Date date;
    private long customerId;
  }

        
        
Customer表通过id与Order表关联，查询Order的Customer时需要先知道Order中的customerId然后根据id=customerId值再去数据库中查询该id所对应的Customer对象。然而在greenDao中一个注释就可以搞定，只需要使用@ToOne注释来定义一个关联对象即可。
        
        
@ToOne 定义了一个entities与另一个entities的1：1对应关系。通过joinProperty参数来定义一个外键下面是代码示例
        
        
public class Order {    
  @Id 
  private Long id;   

  private long customerId;  
  
  @ToOne(joinProperty = "customerId")  
  private Customer customer;
}

@Entity
public class Customer {    
    @Id 
    private Long id;
}

        
        
这样只要获得Order对象就能通过getCustomer()方法获取Order所对应的Customer了，这样是不是很高效，很简便。其实getCustomer方法也很简单，就是在底层帮助我们封装好了查询语句而已，另外getCustomer获取的对象也是懒查询机制，只有真正使用getCustomer方法查询到的对象时greenDao才会执行查询操作。如果你想立即执行查询操作可以调用DAO类的loadDeep()与queryDeep()方法。
        
        
2. 1：N 关联
在1对1关联中每个顾客只能与一个订单对应，但是现实生活中肯定不只是这样，也会出现一个顾客下多个订单的情况。如果出现这种需求的话，按照原生Sqlite的思路一样是通过外键关联即可，只是这一次查询的对象会有很多个，但是使用greenDao的1：1关联方式显然不行。不过别担心greenDao还给我们准备了@ToMany注释。
        
        
@ToMany 定义了一个entities(这个标记为源实体)与另一个entities(这个标记为目标实体)的多个对象的关联关系：@Tomany有一下三种方式来定义1：N的映射关系。
        
        
referencedJoinProperty  在目标实体中我们需要定义一个与源实体关联起来的外键，即Order中的customerId，然后需要在源实体里我们需要将customerId作为referencedJoinProperty的属性。说起来很拗口，其实代码很简单；
        
        
    @Entity
    public class Customer {
        @Id private Long id;

        @ToMany(referencedJoinProperty = "customerId")
        @OrderBy("date ASC")
        private List<Order> orders;
    }

    @Entity
    public class Order {
        @Id private Long id;
        private Date date;
        private long customerId;
    }

        
        
是不是很简单通过referencedJoinProperty来标注下俩个实体之间的外键即可
        
        
joinProperties这个参数是referencedJoinProperty 参数的升级版。在referencedJoinProperty参数中我们发现俩个实体关联的外键是CustomerId与id，但是如果我们的需求是外键不能通过id来定义，需要用自己自定义属性来定义，第一种方法就没法用了，而joinProperties就是为了解决这个需求的。
        
        
    @Entity
    public class Customer {
        @Id private Long id;
        @Unique private String tag;

        @ToMany(joinProperties = {
                @JoinProperty(name = "tag", referencedName = "customerTag")
        })
        @OrderBy("date ASC")
        private List<Site> orders;
    }

    @Entity
    public class Order {
        @Id private Long id;
        private Date date;
        @NotNull private String customerTag;
    }

        
        
其实如果把
        
        
 @ToMany(joinProperties = {
                @JoinProperty(name = "id", referencedName = "customerId")
        })

        
        
这样的话就和第一种方法实现原理是一样的了。
        
        
@JoinEntity 定义了N：M的映射关系。
        
        
    @Entity
    public class Product {
        @Id private Long id;

        @ToMany
        @JoinEntity(
                entity = JoinProductsWithOrders.class,
                sourceProperty = "productId",
                targetProperty = "orderId"
        )
        private List<Order> ordersWithThisProduct;
    }

    @Entity
    public class JoinProductsWithOrders {
        @Id private Long id;
        private Long productId;
        private Long orderId;
    }

    @Entity
    public class Order {
        @Id private Long id;
    }

        
        
3. 关联表的更新与解析
关联的查询也是懒加载机制，而且查询的结果会保存在缓存中下一次查询的时候如果缓存有会直接从缓存中获取结果。
        
        
同样关联表更新时因为有缓存机制的存在你需要将改动的表手动的通过add()方法来更新关联表中的对象或者直接清除缓存。
        
        
// 获取当前顾客的订单列表
List<Order> orders1 = customer.getOrders();

// 插入一个新订单
Order order = new Order();
order.setCustomerId(customer.getId());
daoSession.insert(order);

// 再一次获取顾客的订单
List<Order> orders2 = customer.getOrders();

// 因为缓存列表没有更新所以订单1与订单2的大小相等
assert(orders1.size() == orders2.size);
// 也是相同的对象
assert(orders1.equals(orders2));

//调用该方法后，才能更新缓存列表
orders1.add(newOrder);

//删除时也许要手动将缓存列表里面的数据删除
List orders = customer.getOrders();
// 从数据库中移除
daoSession.delete(someOrder);
// 手动从缓存列表移除
orders.remove(someOrder);

//如果数据库更新后不想手动添加数据可以使用resetXX()方法来清除缓存

customer.resetOrders();
List orders = customer.getOrders();

        
        
多表查询
        
        
有些时候我们的表没有使用ToOne与ToMany建立关联关系，但是我们又想一步到位。这时我们可以使用greenDao的多表查询功能来帮助我们减少不必要的代码。
1. 关联单个表
        
        
//查询地址是住在迪拜大楼的用户
QueryBuilder<User> queryBuilder = userDao.queryBuilder();
queryBuilder.join(Address.class, AddressDao.Properties.userId)
  .where(AddressDao.Properties.Street.eq("迪拜大楼"));
List<User> users = queryBuilder.list();

        
        
通过queryBuilder.join()方法即可完成，其用法也很简单第一个参数是关联的类，第二个是关联类中的关联属性。
        
        
2.关联多个表
        
        
//查询在欧洲人口超过100000的城市
QueryBuilder qb = cityDao.queryBuilder().where(Properties.Population.ge(1000000));
Join country = qb.join(Properties.CountryId, Country.class);
Join continent = qb.join(country, CountryDao.Properties.ContinentId,
Continent.class, ContinentDao.Properties.Id);
continent.where(ContinentDao.Properties.Name.eq("Europe"));
List<City> bigEuropeanCities = qb.list();

        
        
通过queryBuilder.join()链式调用来实现多表查询
注意：多表查询的前提是我们已经定义好了外键来关联表与表之间的关系。
        
        
自定义参数类型
        
        
默认类型参数 ：greenDao默认支持的类型参数如下
        
        
boolean, Boolean
int, Integer
short, Short
long, Long
float, Float
double, Double
byte, Byte
byte[]
String
Date

        
        
自定义类型参数： 如果greenDao的默认参数类型满足不了你的需求，比如你想定义一个颜色属性，那么你可以使用数据库支持的原生数据类型通过PropertyConverter类转换成你想要的颜色属性。
        
        
首先你需要给自定义类型参数添加 @Convert注释并添加对应参数
converter：参数转换类，columnType：在数据库中对应的类型
实现PropertyConverter类
下面是用通过使用数据库支持的Integer类型来转换成数据库不支持的枚举类型
        
        
@Entity
public class User {
    @Id
    private Long id;
 
    @Convert(converter = RoleConverter.class, columnType = Integer.class)
    private Role role;
 
    public enum Role {
        DEFAULT(0), AUTHOR(1), ADMIN(2);
        final int id;
        
        Role(int id) {
            this.id = id;
        }
    }
 
    public static class RoleConverter implements PropertyConverter<Role, Integer> {
      //将Integer值转换成Role值
        @Override
        public Role convertToEntityProperty(Integer databaseValue) {
            if (databaseValue == null) {
                return null;
            }
            for (Role role : Role.values()) {
                if (role.id == databaseValue) {
                    return role;
                }
            }
            return Role.DEFAULT;
        }
       
      //将Role值转换成Integer值
        @Override
        public Integer convertToDatabaseValue(Role entityProperty) {
            return entityProperty == null ? null : entityProperty.id;
        }
    }
}