GreenDao源码详解第一篇（Dao、Mater等类生成原理）
GreenDao官方为什么说自己的数据库框架运行快呢，首先，第一点这个框架不像其他框架通过运行期反射创建ORM映射，而是通过freemarker模板方式在编译期之前帮你生成可用的和数据库生成有关的表帮助对象，所以说这第一点就比其他数据库框架的速度快。不了解java模板freemarker用法的请去官方文档查看，freemarker官方。
首先看一下GreenDao的官方给我们提供的例子:
public static void main(String[] args) throws Exception {
//第一个参数数据库版本,第二个参数生成java的包名
Schema schema = new Schema(3, "de.greenrobot.daoexample");
addNote(schema);
addCustomerOrder(schema);
new DaoGenerator().generateAll(schema, "../GreenDao/src-gen");
}
private static void addNote(Schema schema) {
Entity note = schema.addEntity("Note");
note.addIdProperty();
note.addStringProperty("text").notNull();
note.addStringProperty("comment");
note.addDateProperty("date");
}
private static void addCustomerOrder(Schema schema) {
Entity customer = schema.addEntity("Customer");
customer.addIdProperty();
customer.addStringProperty("name").notNull();
Entity order = schema.addEntity("Order");
order.setTableName("ORDERS"); // "ORDER" is a reserved keyword
order.addIdProperty();
Property orderDate = order.addDateProperty("date").getProperty();
Property customerId = order.addLongProperty("customerId").notNull().getProperty();
order.addToOne(customer, customerId);
ToMany customerToOrders = customer.addToMany(order, customerId);
customerToOrders.setName("orders");
customerToOrders.orderAsc(orderDate);
}
public PropertyBuilder addStringProperty(String propertyName) {
return addProperty(PropertyType.String, propertyName);
}
先看看 PropertyType.String是什么鬼
/**
* 枚举声明类型
* @author Administrator
*
*/
public enum PropertyType {
Byte(true), Short(true), Int(true), Long(true), Boolean(true), Float(true), Double(true),
String(false), ByteArray(false), Date(false);
private final boolean scalar;
PropertyType(boolean scalar) {
this.scalar = scalar;
}
/** True if the type can be prepresented using a scalar (primitive type). */
public boolean isScalar() {
return scalar;
}
}这是一个枚举类，可以看出它定义了很多类型，那么这些类型一看就是标记java字段类型到数据库表类型之间的映射，这也属于枚举的高级用法，那么接下来继续跟进代码
/**
* 将属性名字和属性特性加入
*
* @param propertyType
* @param propertyName
* @return
*/
public PropertyBuilder addProperty(PropertyType propertyType,
String propertyName) {
if (!propertyNames.add(propertyName)) {
throw new RuntimeException("Property already defined: "
+ propertyName);
}
PropertyBuilder builder = new PropertyBuilder(schema, this,
propertyType, propertyName);
properties.add(builder.getProperty());
return builder;
}很明显吗，将属性名字添加到set集合中以确保属性名唯一性，然后创建 Property的构造者 PropertyBuilder ， 最终返回构造者，有意思，这个框架对属性特性的添加使用了构造者模式，当参数过多了，为了让客户端用起来舒服所以采用此模式，接着将属性添加到属性集合中，索引为位置和属性名的索引位置一一对应。满足我们上面的猜想。那么接着看例子。
private static void addCustomerOrder(Schema schema) {
Entity customer = schema.addEntity("Customer");
customer.addIdProperty();
customer.addStringProperty("name").notNull();
Entity order = schema.addEntity("Order");
order.setTableName("ORDERS"); // "ORDER" is a reserved keyword
order.addIdProperty();
Property orderDate = order.addDateProperty("date").getProperty();
Property customerId = order.addLongProperty("customerId").notNull().getProperty();
order.addToOne(customer, customerId);
ToMany customerToOrders = customer.addToMany(order, customerId);
customerToOrders.setName("orders");
customerToOrders.orderAsc(orderDate);
}
public ToOne addToOne(Entity target, Property fkProperty) {
if (protobuf) {
throw new IllegalStateException(
"Protobuf entities do not support realtions, currently");
}
//外键属性
Property[] fkProperties = { fkProperty };
ToOne toOne = new ToOne(schema, this, target, fkProperties, true);
toOneRelations.add(toOne);
return toOne;
}public ToMany addToMany(Entity target, Property targetProperty) {
Property[] targetProperties = { targetProperty };
return addToMany(null, target, targetProperties);
}
public ToMany addToMany(Property[] sourceProperties, Entity target,
Property[] targetProperties) {
if (protobuf) {
throw new IllegalStateException(
"Protobuf entities do not support relations, currently");
}
/**
* 创建ToMany对象
*/
ToMany toMany = new ToMany(schema, this, sourceProperties, target,
targetProperties);
//加入集合
toManyRelations.add(toMany);
//同时多的一方也将ToMany保存到集合中
target.incomingToManyRelations.add(toMany);
return toMany;
}完成所有的配置后，开始执行生成最终的java类，第二参数表示在当前路径下的产生java文件
new DaoGenerator().generateAll(schema, "../GreenDao/src-gen"); public DaoGenerator() throws IOException {
System.out.println("greenDAO Generator");
System.out.println("Copyright 2011-2016 Markus Junginger, greenrobot.de. Licensed under GPL V3.");
System.out.println("This program comes with ABSOLUTELY NO WARRANTY");
patternKeepIncludes = compilePattern("INCLUDES");
patternKeepFields = compilePattern("FIELDS");
patternKeepMethods = compilePattern("METHODS");
//通过freemarker的api获取Configuration配置
Configuration config = getConfiguration("dao.ftl");
//得到模板dao.ftl的模板
templateDao = config.getTemplate("dao.ftl");
//得到dao-master.ftl的模板
templateDaoMaster = config.getTemplate("dao-master.ftl");
//得到dao-session.ftl的模板
templateDaoSession = config.getTemplate("dao-session.ftl");
//得到entity.ftl的模板
templateEntity = config.getTemplate("entity.ftl");
//得到dao-unit-test.ftl的模板
templateDaoUnitTest = config.getTemplate("dao-unit-test.ftl");
//得到content-provider.ftl的模板
templateContentProvider = config.getTemplate("content-provider.ftl");
}
最重要的是注释的部分，根据 ftl文件生成模板类,这的 ftl是什么鬼呢？ ftl是 freemarker框架定义的一种语法规则，想生成什么东西（比如 html， jsp， java文件等），只要写 ftl文件满足它的要求那么再利用它提供的api，几句代码就可以实现动态的生成代码， ftl语法是什么用的呢？请移植上方看官方文档。
这里我们配置一下让freemarker找到我们的ftl文件
//声明配置的版本号
Configuration config = new Configuration(Configuration.VERSION_2_3_23);
//第二个参数设置ftl的保存路径
config.setClassForTemplateLoading(getClass(), "");
GreenDao的源码有给提供这些ftl文件，看图
那么咱们运行一下看看会产生哪些文件
由于例子中写了三张表，所以映射了三个表对象，那么不管有几张表，总会至少产生四个类，一个表映射对象类、一个表+Dao类、一个DaoSession类、一个DaoMaster的类，正好对应了模板解析的ftl文件
//得到模板dao.ftl的模板
templateDao = config.getTemplate("dao.ftl");
//得到dao-master.ftl的模板
templateDaoMaster = config.getTemplate("dao-master.ftl");
//得到dao-session.ftl的模板
templateDaoSession = config.getTemplate("dao-session.ftl");
//得到entity.ftl的模板
templateEntity = config.getTemplate("entity.ftl");
public void generateAll(Schema schema, String outDir, String outDirEntity, String outDirTest) throws Exception {
long start = System.currentTimeMillis();
File outDirFile = toFileForceExists(outDir);
File outDirEntityFile = outDirEntity != null ? toFileForceExists(outDirEntity) : outDirFile;
File outDirTestFile = outDirTest != null ? toFileForceExists(outDirTest) : null;
//初始化并检查一些参数(例如表名没有设置，那么根据类名产生默认值，检查字段的类型是否是枚举声明的那些类型)
schema.init2ndPass();
//初始化并检查一些参数(例如表名没有设置，那么根据类名产生默认值，检查字段的类型是否是枚举声明的那些类型)
schema.init3rdPass();
System.out.println("Processing schema version " + schema.getVersion() + "...");
/**
* 开始遍历表对象
*/
List entities = schema.getEntities();
for (Entity entity : entities) {
//创建表操作类，表+Dao
generate(templateDao, outDirFile, entity.getJavaPackageDao(), entity.getClassNameDao(), schema, entity);
if (!entity.isProtobuf() && !entity.isSkipGeneration()) {
//创建表对象
generate(templateEntity, outDirEntityFile, entity.getJavaPackage(), entity.getClassName(), schema, entity);
}
if (outDirTestFile != null && !entity.isSkipGenerationTest()) {
String javaPackageTest = entity.getJavaPackageTest();
String classNameTest = entity.getClassNameTest();
File javaFilename = toJavaFilename(outDirTestFile, javaPackageTest, classNameTest);
if (!javaFilename.exists()) {
//创建测试类
generate(templateDaoUnitTest, outDirTestFile, javaPackageTest, classNameTest, schema, entity);
} else {
System.out.println("Skipped " + javaFilename.getCanonicalPath());
}
}
for (ContentProvider contentProvider : entity.getContentProviders()) {
Map additionalObjectsForTemplate = new HashMap<>();
additionalObjectsForTemplate.put("contentProvider", contentProvider);
generate(templateContentProvider, outDirFile, entity.getJavaPackage(), entity.getClassName()
+ "ContentProvider", schema, entity, additionalObjectsForTemplate);
}
}
//创建master类
generate(templateDaoMaster, outDirFile, schema.getDefaultJavaPackageDao(),
schema.getPrefix() + "DaoMaster", schema, null);
//创建session类
generate(templateDaoSession, outDirFile, schema.getDefaultJavaPackageDao(),
schema.getPrefix() + "DaoSession", schema, null);
long time = System.currentTimeMillis() - start;
System.out.println("Processed " + entities.size() + " entities in " + time + "ms");
} 最重要的代码在标记处，其他的文件比如测试类的创建，由于没有配置，所以不会走，那么先看一下
generate(templateDao, outDirFile, entity.getJavaPackageDao(), entity.getClassNameDao(), schema, entity);private void generate(Template template, File outDirFile,
String javaPackage, String javaClassName, Schema schema,
Entity entity, Map additionalObjectsForTemplate)
throws Exception {
Map root = new HashMap<>();
// 声明两个对象填入，最终会在ftl中以$被引用
root.put("schema", schema);
root.put("entity", entity);
if (additionalObjectsForTemplate != null) {
root.putAll(additionalObjectsForTemplate);
}
try {
File file = toJavaFilename(outDirFile, javaPackage, javaClassName);
// noinspection ResultOfMethodCallIgnored
file.getParentFile().mkdirs();
if (entity != null && entity.getHasKeepSections()) {
checkKeepSections(file, root);
}
Writer writer = new FileWriter(file);
try {
//将参数传入并写入到文件字符流之中
template.process(root, writer);
writer.flush();
System.out.println("Written " + file.getCanonicalPath());
} finally {
writer.close();
}
} catch (Exception ex) {
System.err.println("Data map for template: " + root);
System.err.println("Error while generating " + javaPackage + "."
+ javaClassName + " (" + outDirFile.getCanonicalPath()
+ ")");
throw ex;
}
} root.put("schema", schema);
root.put("entity", entity);那么看一下ftl是怎么引用这两个对象的字段值的
<#-- @ftlvariable name="entity" type="org.greenrobot.greendao.generator.Entity" -->
<#-- @ftlvariable name="schema" type="org.greenrobot.greendao.generator.Schema" --><#assign toBindType = {"Boolean":"Long", "Byte":"Long", "Short":"Long", "Int":"Long", "Long":"Long", "Float":"Double", "Double":"Double", "String":"String", "ByteArray":"Blob", "Date": "Long" } />
<#if entity.toOneRelations?has_content || entity.incomingToManyRelations?has_content>
import java.util.List;
<#if entity.toOneRelations?has_content>
import java.util.ArrayList;
import android.database.Cursor;
import android.database.sqlite.SQLiteStatement;
import org.greenrobot.greendao.AbstractDao;
import org.greenrobot.greendao.Property;
<#if entity.toOneRelations?has_content>
import org.greenrobot.greendao.internal.SqlUtils;
import org.greenrobot.greendao.internal.DaoConfig;
import org.greenrobot.greendao.database.Database;
import org.greenrobot.greendao.database.DatabaseStatement;
<#if entity.incomingToManyRelations?has_content>
import org.greenrobot.greendao.query.Query;
import org.greenrobot.greendao.query.QueryBuilder;
<#if entity.javaPackageDao != schema.defaultJavaPackageDao>
import ${schema.defaultJavaPackageDao}.${schema.prefix}DaoSession;
<#if entity.additionalImportsDao?has_content>
<#list entity.additionalImportsDao as additionalImport>
import ${additionalImport};
<#if entity.javaPackageDao != entity.javaPackage>
import ${entity.javaPackage}.${entity.className};
<#if entity.protobuf>
import ${entity.javaPackage}.${entity.className}.Builder;正好对应了OrderDao类的包
import java.util.List;
import java.util.ArrayList;
import android.database.Cursor;
import android.database.sqlite.SQLiteStatement;
import org.greenrobot.greendao.AbstractDao;
import org.greenrobot.greendao.Property;
import org.greenrobot.greendao.internal.SqlUtils;
import org.greenrobot.greendao.internal.DaoConfig;
import org.greenrobot.greendao.database.Database;
import org.greenrobot.greendao.database.DatabaseStatement;
import org.greenrobot.greendao.query.Query;
import org.greenrobot.greendao.query.QueryBuilder;倒完包之后就开始写我们的类文件了
public class ${entity.classNameDao} extends AbstractDao<${entity.className}, ${entity.pkType}> {用entity里面的属性替换掉当前，假如此时的entity是Customer，那么上面的经过转化就为
public class CustomerDao extends AbstractDao
public static class Properties {
<#list entity.propertiesColumns as property>
public final static Property ${property.propertyName?cap_first} = new Property(${property_index}, ${property.javaType}.class, "${property.propertyName}", ${property.primaryKey?string}, "${property.dbName}");
${property_index}索引从0开始，每次加1
public static class Properties {
public final static Property Id = new Property(0, Long.class, "id", true, "_id");
public final static Property Name = new Property(1, String.class, "name", false, "NAME");
}
<#if entity.active>
private ${schema.prefix}DaoSession daoSession;
private DaoSession daoSession;<#list entity.properties as property><#if property.customType?has_content><#--
--> private final ${property.converterClassName} ${property.propertyName}Converter = new ${property.converterClassName}();
接下来定义构造函数
public ${entity.classNameDao}(DaoConfig config) {
super(config);
}
public ${entity.classNameDao}(DaoConfig config, ${schema.prefix}DaoSession daoSession) {
super(config, daoSession);
<#if entity.active>
this.daoSession = daoSession;
} public OrderDao(DaoConfig config) {
super(config);
}
public OrderDao(DaoConfig config, DaoSession daoSession) {
super(config, daoSession);
this.daoSession = daoSession;
}
好了，下面解析的原理都是一样的，不再一 一阐述，看到这流程基本上就通了，想产生我们想要的数据库操作类的话，利用GreenDao的封装属性，把我们想建的表全部写进
Schema的 Entry集合内，然后通过FreeMarker模板框架根据ftl文件解析生成我们需要的类，最终把我们需要的类拿过来直接操作数据库。生成流程就分析到这里，感兴趣的小伙伴，可以自己尝试解放双手，让模板为你自动写代码，毕竟程序员要学会高级的懒吗。