1. 前面分析了guzz加载guzz.xml的过程，今天继续解析guzz加载数据库方言，初始化数据类型的过程
2. 首先在GuzzContextImpl的initFromMainConfig方法中找到下面的代码：
//加载dialect初始化数据类型
Map ds = builder.getConfiguredDialect() ;
if(ds == null){
log.warn("dialect(s) not found.") ;
}else{
this.dialects = ds ;
}
这里就是guzz在加载dialect初始化数据类型，主要的实现在GuzzConfigFileBuilder的getConfiguredDialect方法中，因为整个guzz.xml的文件都是加载到了GuzzConfigFileBuilder中，进入到getConfiguredDialect()方法中
public Map getConfiguredDialect(){
List ls = this.rootDoc.selectNodes("dialect") ;
if(ls == null) return null ;
if(ls.isEmpty()) return null ;
HashMap ds = new HashMap() ;
for(int i = 0 ; i < ls.size() ; i++){
Element e = (Element) ls.get(i) ;
String d_cls = e.attributeValue("class") ;
String d_name = e.attributeValue("name") ;
if(StringUtil.isEmpty(d_name)){
d_name = "default" ;
}
Dialect dialect = (Dialect) BeanCreator.newBeanInstance(d_cls) ;
//注册用户自定义的类型
List types = e.selectNodes("type") ;
for(int j = 0 ; j < types.size() ; j++){
Element t = (Element) types.get(j) ;
String typeName = t.attributeValue("name") ;
String className = t.attributeValue("class") ;
Class cls = ClassUtil.getClass(className) ;
Assert.assertTrue(SQLDataType.class.isAssignableFrom(cls), "user-defined data type must be a instance of type:" + SQLDataType.class.getName()) ;
dialect.registerUserDefinedTypes(typeName, cls) ;
}
ds.put(d_name, dialect) ;
}
return ds ;
}
首先查询了文档中所有的dialect节点，然后查询了每一个节点的属性（calss,name)，若没有配置name属性，那么就默认是default，这里和帮助文档中的一致，根据配置的class，通过BeanCreator创建了一个实例，具体是什么对象，要看guzz.xml中的配置，我这里的配置是：
<dialect class="org.guzz.dialect.Mysql5Dialect"></dialect>
所有创建的实例就是Mysql5Dialect，由于guzz.xml支持多个数据库，所以方言肯定也是不同的，Guzz的方言类结构图如下：
从类结构图可以看出来guzz支持的数据库有哪些，当然我们自己根据需要也可以自己定义需要的数据库方言，只要实现AbstractDialect这个抽象类就可以了，因为我使用的是mysql，所以也就只看了Mysql5Dialect，打开看类，只有一个主要的方法，就是对mysql的limit的出来，每一中数据库的分页查询方式都有不同的实现。接着就是查看父类进入到AbstractDialect类，有3个重要的方法regSystemTypes，getDataType，registerUserDefinedTypes
3. 首先看regSystemTypes，部分代码：
protected void regSystemTypes(){
sqlTypes.put("int", IntegerSQLDataType.class) ;
sqlTypes.put("Integer", IntegerObjectSQLDataType.class) ;
sqlTypes.put(Integer.class.getName(), IntegerObjectSQLDataType.class) ;
sqlTypes.put("string", StringSQLDataType.class) ;
sqlTypes.put("varchar", StringSQLDataType.class) ;
sqlTypes.put("nvarchar", StringSQLDataType.class) ;
....
}
一看就明白，把java对应的数据类型和数据库中的数据类型都写了一个对应的出来类，放入到了一个map对象中。getDataType方法看名字也知道了是获取数据列的类型处理类也就是SQLDataType，类结构图：
4. 然后我们回到getConfiguredDialect，继续看，在这个方法中我们看到了在找了dialect节点后，又在dialect节点下面找子节点type，若是有配有type的话就解析后调用registerUserDefinedTypes方法，这个方法是注册用户自定义的数据类型，这点在帮助文档中没有提到，但实际上Guzz是有这个功能的。
出来完了所有的dialect节点后返回存有dialect的一个map，这个map中村了所有的dialect，每一个dialect对象中又存有所有的数据类型（SQLDataType)
5. 到此为止，guzz 完成了加载dialect初始化数据类型。
6. 刚才说到guzz可以自定义数据类型，出来特定类型的对象，但是guzz帮助文档没有提到，我们写一个简单的例子测试这个功能：
6.1 定义两个实体类员工类 Emp 和部门类Depart
package com.hqhp.maven.model;
import javax.persistence.Column;
import org.guzz.annotations.Table;
/**
* 员工
* @author 确实比较男
*/
@javax.persistence.Entity
@org.guzz.annotations.Entity(businessName = "emp")
@Table(name = "tb_emp")
public class Emp extends BaseModel {
private static final long serialVersionUID = -3759132536120038862L;
private String name;
private int age;
@Column(name = "departid")
private Depart depart;
//getter setter 省略
@Override
public String toString() {
return "Emp [name=" + name + ", age=" + age + ", depart=" + depart + "]";
}
}
package com.hqhp.maven.model;
import org.guzz.annotations.Table;
/**
* 部门
* @author 确实比较男
*/
@javax.persistence.Entity
@org.guzz.annotations.Entity(businessName = "depart")
@Table(name = "tb_depart")
public class Depart extends BaseModel {
private static final long serialVersionUID = -2394287758178521691L;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Depart [name=" + name + "]";
}
}
6.2 guzz.xml配置文件如下：
<guzz-configs>
<dialect class="org.guzz.dialect.Mysql5Dialect">
<type name="com.hqhp.maven.model.Depart" class="org.guzz.orm.type.DepartSQLDataType" />
</dialect>
<tran locator="spring">
<dbgroup name="default" masterDBConfigName="masterDB" />
</tran>
<!-- 类似于Mysql数据库的配置文件 -->
<config-server>
<server class="org.guzz.config.LocalFileConfigServer">
<param name="resource" value="guzz_app.properties" />
</server>
</config-server>
<business-scan resources="classpath*:com/hqhp/maven/model/*.class" />
</guzz-configs>
根据源码的分析，我们的dialect节点可以这样写。
6.3 接下来我们就开始写org.guzz.orm.type.DepartSQLDataType，也就是自定义SQLDataType，仿照到guzz的写，代码如下：
package org.guzz.orm.type;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.guzz.exception.DataTypeException;
import com.hqhp.maven.dao.UserDao;
import com.hqhp.maven.model.Depart;
import com.hqhp.maven.utils.SpringUtil;
/**
* @author 确实比较男
*/
public class DepartSQLDataType implements SQLDataType {
@Override
public void setNullToValue(Object nullValue) {
System.out.println("setNullToValue...............");
if (nullValue != null) {
throw new DataTypeException("null value unsupported. nullValue is:" + nullValue);
}
}
@Override
public Object getSQLValue(ResultSet rs, String colName) throws SQLException {
System.out.println("getSQLValue...........colName....");
String departid = rs.getString(colName);
System.out.println("=====:" + departid);
UserDao userDao = (UserDao) SpringUtil.getBean("userDao");
Depart depart = userDao.queryDepart(departid);
System.out.println(depart.getId() + " " + depart.getName());
return depart;
}
@Override
public Object getSQLValue(ResultSet rs, int colIndex) throws SQLException {
System.out.println("getSQLValue..........colIndex.....");
String departid = rs.getString(colIndex);
UserDao userDao = (UserDao) SpringUtil.getBean("userDao");
Depart depart = userDao.queryDepart(departid);
System.out.println(depart.getId() + " " + depart.getName());
return depart;
}
@Override
public void setSQLValue(PreparedStatement pstm, int parameterIndex, Object value) throws SQLException {
System.out.println("setSQLValue...................");
System.out.println(value);
Depart depart = (Depart) value;
System.out.println(depart.getId());
pstm.setString(parameterIndex, depart.getId());
}
@Override
public Class getDataType() {
System.out.println("getDataType...............");
return Depart.class;
}
@Override
public Object getFromString(String value) {
System.out.println("getFromString...............");
return null;
}
}
主要是这两个方法，在保存和查询的时候会调用。
6.4 最后写一个查询类去查询和保存emp对象：
public boolean insertEmp(Emp emp) {
TransactionManager tm = guzzDao.getTransactionManager();
WriteTranSession session = tm.openRWTran(true);
try {
return session.insert(emp) == null ? false : true;
} finally {
session.close();
}
}
public Emp queryEmp(Serializable id) {
TransactionManager tm = guzzDao.getTransactionManager();
ReadonlyTranSession session = tm.openDelayReadTran();
try {
return (Emp) session.findObjectByPK(Emp.class, id);
} finally {
session.close();
}
}
向数据库中插入一个emp对象，若是把depart的id存入了数据库那么说明保存对象正确；查询一个emp对象，若是取出的emp对象的depart对象不为空那么查询也是正确的，就可以直接存取对象了，说明自定义数据类型正确
Depart depart = new Depart();
depart.setName("技术前沿研究所");
userDao.insertDepart(depart);
depart.setId("402881eb4371f277014371f358b70000");
Emp emp = new Emp();
emp.setName("silentwu");
emp.setAge(21);
emp.setDepart(depart);
empDao.insertEmp(emp); //保存emp
//查询emp
Emp emp= empDao.queryEmp("402881eb4372033c01437203744f0000");
System.out.println(emp);
测是结果正确。