忙里偷闲，继续上周的话题，记录Mybatis的扩展。
扩展5：设置默认的返回结果类型
大家知道，在Mybatis的sql-mapper配置文件中，我们需要给<select>元素添加resultType或resultMap属性，这两个属性有且只能有一个。2013年我在做一个系统的时候，因为业务关系，查询出的结果集字段经常变化，为了简化处理，采用map作为返回数据的载体，然后不得不在绝大多数<select>元素上添加类似 resultType='java.util.HashMap'（Mybatis有HashMap的简写形式，这里为了更清晰，使用全限定符），于是催生了一个想法，能不能设置默认的返回结果类型？后面经过调试，继承SqlSessionFactoryBean添加如下代码实现：
/**
* 设置默认的查询结果返回类型
* @param configuration
* @param cls
* @throws Exception
*/
private void setDefaultResultType(Configuration configuration, Class<?> cls) throws Exception{
try {
Field resultMaps = MappedStatement.class.getDeclaredField("resultMaps");
resultMaps.setAccessible(true);
for(Iterator<MappedStatement> i = configuration.getMappedStatements().iterator(); i.hasNext();){
Object o = i.next();
/**
* 这里添加类型判断，是因为Mybatis实现中还存放了Ambiguity对象（sql-id的最后一段id重复情况下）
*/
if(o instanceof MappedStatement){
MappedStatement ms = (MappedStatement)o;
if(SqlCommandType.SELECT.equals(ms.getSqlCommandType()) && ms.getResultMaps().isEmpty()){
ResultMap.Builder inlineResultMapBuilder = new ResultMap.Builder(configuration,ms.getId()+"-Inline",cls,new ArrayList<ResultMapping>(),null);
ResultMap resultMap = inlineResultMapBuilder.build();
List<ResultMap> rm = new ArrayList<ResultMap>();
rm.add(resultMap);
resultMaps.set(ms, Collections.unmodifiableList(rm));
}else{
}
}
}
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
这个实现有很多写死的代码，也没有做足够完备的测试，不过到目前为止，总算还没有出错。
我设置的默认返回结果类型是map，当然，这里其实可以更进一步扩展，添加一个SqlID模式和默认结果类型的映射接口，然后就根据需要去实现这个映射关系了。
扩展6：自动扫描类型简称
还是在SqlSessionFactoryBean继承类中，另外实现的一个扩展就是自动扫描类型简称。类型简称的用法如下：
(1)在mybatis全局配置文件中添加别名
<typeAliases>
<typeAlias alias="RoleBean" type="com.forms.beneform4j.webapp.systemmanage.role.bean.RoleBean" />
</typeAliases>
(2)在sql-mapper文件中使用alias。
通过添加自动扫描类型简称，就可以将第一段配置去掉，而直接使用别名了。具体实现大概如下所示：
private void scanTypeAliases(){
if (this.autoScanTypeAliases && hasLength(this.typeAliasesScanPackage) && null != baseClass) {
String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesScanPackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
List<Class<?>> list = new ArrayList<Class<?>>();
List<String> alias = new ArrayList<String>();
MetaObject meta = SystemMetaObject.forObject(this);
Class<?>[] orig = (Class<?>[])meta.getValue("typeAliases");
if(null != orig)
{
for(Class<?> t : orig){
list.add(t);
alias.add(t.getSimpleName().toLowerCase());
}
}
for (String packageToScan : typeAliasPackageArray) {
for(Class<?> type : CoreUtils.scanClassesByParentCls(packageToScan, baseClass)){
String a = type.getSimpleName().toLowerCase();
if (!alias.contains(a)) {
list.add(type);
alias.add(a);
}else{
CommonLogger.warn("Mybatis在自动扫描注册别名时，发现有多个可简写为"+type.getSimpleName()+"的类，将取第一个类，忽略"+type);
}
}
}
super.setTypeAliases(list.toArray(new Class<?>[list.size()]));
}
}
这里属性autoScanTypeAliases表示是否需要自动扫描，typeAliasesScanPackage表示扫描的包，baseClass表示扫描的接口或父类。
我们使用Mybatis，可以在父类中注入SqlSessionTemplate，然后子类调用相关方法，也可以通过写Dao的接口，让mybatis自动生成动态代理类，还可以编写一个静态帮助类，在这个帮助类中注入SqlSessionTemplate，然后提供相应的静态方法。这三种方法，以前用的多的是第三种方法，而现在，因为要让其他同事更容易接受，模块划分更清晰，采用了第二种方法。但这三种方法都有一个特点，那就是只使用Mybatis的SqlSession接口的原生方法。不能直接调用批处理、存储过程等，于是，我在SqlSession基础上，添加了一个IDaoTemplate接口：
public interface IDaoTemplate{
/**
* 查询单笔数据
* @param sqlId SQL-ID
* @return 单个对象
*/
public <T> T selectOne(String sqlId);
/**
* 查询单笔数据
* @param sqlId SQL-ID
* @param parameter 参数对象
* @return 单个对象
*/
public <T> T selectOne(String sqlId, Object parameter);
/**
* 查询列表数据
* @param sqlId SQL-ID
* @return 对象列表
*/
public <E> List<E> selectList(String sqlId);
/**
* 查询列表数据
* @param sqlId SQL-ID
* @param parameter 参数对象
* @return 对象列表
*/
public <E> List<E> selectList(String sqlId, Object parameter);
/**
* 查询分页列表数据
* @param sqlId SQL-ID
* @param page 分页对象
* @return 指定页的对象列表
*/
public <E> List<E> selectList(String sqlId, IPage page);
/**
* 查询分页列表数据
* @param sqlId SQL-ID
* @param parameter 参数对象
* @param page 分页对象
* @return 指定页的对象列表
*/
public <E> List<E> selectList(String sqlId, Object parameter, IPage page);
/**
* 流式查询
* @param sqlId SQL-ID
* @return 流式操作接口
*/
public <E>IListStreamReader<E> selectListStream(String sqlId);
/**
* 流式查询
* @param sqlId SQL-ID
* @param parameter 参数对象
* @return 流式操作接口
*/
public <E>IListStreamReader<E> selectListStream(String sqlId, Object parameter);
/**
* 流式查询
* @param sqlId SQL-ID
* @param fetchSize 每次读取的记录条数(0, 5000]
* @return 流式操作接口
*/
public <E>IListStreamReader<E> selectListStream(String sqlId, int fetchSize);
/**
* 流式查询
* @param sqlId SQL-ID
* @param parameter 参数对象
* @param fetchSize 每次读取的记录条数(0, 5000]
* @return 流式操作接口
*/
public <E>IListStreamReader<E> selectListStream(String sqlId, Object parameter, int fetchSize);
/**
* 新增
* @param sqlId SQL-ID
* @return 影响的记录条数
*/
public int insert(String sqlId);
/**
* 新增
* @param sqlId SQL-ID
* @param parameter 参数对象
* @return 影响的记录条数
*/
public int insert(String sqlId, Object parameter);
/**
* 修改
* @param sqlId SQL-ID
* @return 影响的记录条数
*/
public int update(String sqlId);
/**
* 修改
* @param sqlId SQL-ID
* @param parameter 参数对象
* @return 影响的记录条数
*/
public int update(String sqlId, Object parameter);
/**
* 删除
* @param sqlId SQL-ID
* @return 影响的记录条数
*/
public int delete(String sqlId);
/**
* 删除
* @param sqlId SQL-ID
* @param parameter 参数对象
* @return 影响的记录条数
*/
public int delete(String sqlId, Object parameter);
/**
* 执行批量：一个SQL执行多次
* @param sqlId SQL-ID
* @param parameters 参数对象数组
* @return 批量执行的影响记录数组
*/
public int[] executeBatch(String sqlId, List<?> parameters);
/**
* 执行批量：一次执行多个SQL
* @param sqlIds 要执行的一组SQL-ID
* @return 批量执行的影响记录数组
*/
public int[] executeBatch(List<String> sqlIds);
/**
* 执行批量：一次执行多个SQL
* @param sqlIds 要执行的一组SQL-ID
* @param parameters 参数对象数组
* @return 批量执行的影响记录数组
*/
public int[] executeBatch(List<String> sqlIds, List<?> parameters);
/**
* 打开批量执行模式
*/
public void openBatchType();
/**
* 恢复打开批量执行模式之前的执行模式
*/
public void resetBatchType();
/**
* 获取批量执行结果
* @return
*/
public int[] flushBatch();
/**
* 调用存储过程
* @param sqlId SQL-ID
* @return 存储过程返回结果接口
*/
public ICallResult call(String sqlId);
/**
* 调用存储过程
* @param sqlId SQL-ID
* @param parameter 参数对象
* @return 存储过程返回结果接口
*/
public ICallResult call(String sqlId, Object parameter);
}
可以看到，其中部分是简单调用SqlSession接口，但也有部分是我们的扩展。
扩展7：流式查询
流式查询有四个重置方法，sql-Id是必须的参数，查询参数parameter和每次处理的记录条数fetchSize是可选的。流式查询的结果接口如下：
public interface IListStreamReader<T> {
/**
* 读取当前批次的数据列表，如果没有数据，返回null
* @return 当前批次的数据列表
*/
public List<T> read();
/**
* 重置读取批次
*/
public void reset();
}
只有两个方法，其中关键方法是获取当前批次的数据结果集，辅助方法是重置读取批次。
流式查询本质上并没有执行查询，而只是将查询需要的要素包装成为一个对象，当调用者调用这个对象的read方法时，才真正执行数据库查询，而执行查询又使用实现内中内置的分页对象，每次读取只读取当前批次（当前页数）的结果集，查询之后，就内置分页对象的当前页数指向下一页。
流式查询适用于大数据量的查询处理，比如大数据量的数据需要生成Excel文件供客户端下载，一次性查询很容易内存溢出，使用流式查询就可以很好的解决这个问题。
把流式查询结果对象的抽象实现贴在这里，应该更便于理解：
public abstract class AbstractListStreamReader<T> implements IListStreamReader<T>{
/**
* 默认的每次读取记录数
*/
private static final int defaultFetchSize = 1000;
/**
* 最大的每次读取记录数
*/
private static final int maxFetchSize = 5000;
/**
* 实际的每次读取记录数
*/
private final int fetchSize;
/**
* 分页对象
*/
private final IPage page;
/**
* 是否完成的标志
*/
private transient boolean finish = false;//是否完成
/**
* 无参构造函数
*/
public AbstractListStreamReader() {
this(defaultFetchSize);
}
/**
* 使用指定读取数大小的构造函数
* @param fetchSize 每次读取的记录条数
*/
public AbstractListStreamReader(int fetchSize) {
if(fetchSize <= 0 || fetchSize > maxFetchSize){
Throw.throwRuntimeException(DaoExceptionCodes.BF020012, fetchSize, "(0, "+maxFetchSize+"]");
}
this.fetchSize = fetchSize;
BasePage page = new BasePage();
page.setPageSize(fetchSize);
this.page = page;
}
/**
* 读取当前批次的列表数据，读取的时候会加锁
*/
@Override
public synchronized List<T> read() {
if(!finish){
List<T> rs = doRead(page);//查询当前页数据
if(page.hasNextPage()){//有下一页，游标指向下一页
page.setPageProperty(page.getTotalRecords(), page.getCurrentPage()+1, fetchSize);
}else{//没有下一页，完成
finish = true;
}
return rs;
}
return null;
}
/**
* 执行实际的读取操作
* @param page 分页对象
* @return 和分页对象相对应的数据记录列表
*/
abstract protected List<T> doRead(IPage page);
/**
* 重置读取批次，重置过程中会加锁
*/
@Override
public synchronized void reset(){
this.finish = false;
this.page.setPageProperty(this.page.getTotalPages(), 1, fetchSize);
}
}
至于具体的实现，只要继承抽象实现，然后实现
abstract protected List<T> doRead(IPage page);
就可以了，而这个方法只是一个简单的分页查询，实现起来没有任何难度。
扩展8：调用存储过程
Mybatis中可以调用存储过程，但直接使用并不方便，我们将其封装如下：
public interface IDaoTemplate{
/**
* 这里省略了其它方法
*/
/**
* 调用存储过程
* @param sqlId SQL-ID
* @return 存储过程返回结果接口
*/
public ICallResult call(String sqlId);
/**
* 调用存储过程
* @param sqlId SQL-ID
* @param parameter 参数对象
* @return 存储过程返回结果接口
*/
public ICallResult call(String sqlId, Object parameter);
}
这样调用就非常方便了，那么这里的ICallResult是什么呢？看一下它的定义：
public interface ICallResult {
/**
* 获取存储过程返回值
* @return
*/
public <T> T getResult();
/**
* 根据参数名称返回输出参数
* @param name 输出参数名称
* @return 和输出参数名称相对应的返回结果，如果不存在输出参数，抛出平台运行时异常
*/
public <T> T getOutputParam(String name);
/**
* 返回输出参数名称的迭代器
* @return 输出参数名迭代器
*/
public Iterator<String> iterator();
}
使用过Mybatis调用存储过程的朋友，看了这个借口应该就能明白，但鉴于存储过程调用并不普通，这里举一个例子：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.forms.beneform4j.core.dao.mybatis.mapper.call.ICallDao"> <select id="call" statementType="CALLABLE">
{call BF_TEST_PACKAGE.BF_TEST_PROCEDURE(
#{input, jdbcType=VARCHAR},
#{output1, mode=OUT, jdbcType=VARCHAR},
#{output2, mode=OUT, jdbcType=VARCHAR},
#{rs1, mode=OUT, jdbcType=CURSOR},
#{rs2, mode=OUT, jdbcType=CURSOR}
)}
</select>
</mapper>
如上配置，传入sqlId和参数对象（含input属性）后，返回的ICallResult接口中，可以通过如下的方式获取存储过程的返回值（如果有）和输出参数：
@Repository
interface ICallDao { public ICallResult call(@Param("input")String input);
} @Service
public class ICallDaoTest { @Autowired
private ICallDao dao; @Test
public void call() throws Exception {
ICallResult rs = dao.call("1");
//直接访问返回结果和输出参数
Object returnValue = rs.getResult();
Object output1 = rs.getOutputParam("output1");
List<Object> rs1 = rs.getOutputParam("rs1"); //循环访问输出参数
Iterator<String> i = rs.iterator();
String name = "";
while(i.hasNext()){
name = i.next();
System.out.println(name + "============" + rs.getOutputParam(name));
}
}
}
说完了调用存储过程的用法，回过头来简单的提一下调用存储过程的实现：实际上很简单，只要添加一个Mybatis的拦截器即可，拦截结果处理接口ResultSetHandler的方法handleOutputParameters，然后将返回结果和输出参数包装到一个Map对象中即可，具体代码就不贴了。
时间关系，今天写到这里。下次再继续写Dao接口中SqlID的重定向、IDaoTemplate接口中的批量处理相关的扩展。