关于mybatis拦截器，对结果集进行拦截

　　因业务需要，需将结果集序列化为json返回，于是，网上找了好久资料，都是关于拦截参数的处理，拦截Sql语法构建的处理，就是很少关于对拦截结果集的处理，于是自己简单的写了一个对结果集的处理，

记录下。

 

一、MyBatis的框架设计图                                            

  

  参考：http://blog.csdn.net/luanlouis/article/details/40422941

1.如何将结果集改成我们想要的格式呢？                                 

　　1.1  由原理图我们可知，ResultSetHandler负责将resultSet转换为list，那么我们能不能在转换的时候加上自己的逻辑，我想应该是可以的，但是因为源码看不太懂，想想还是算了。

public List<Object> handleResultSets(Statement stmt) throws SQLException {  
  final List<Object> multipleResults = new ArrayList<Object>();  
  
  int resultSetCount = 0;  
  ResultSetWrapper rsw = getFirstResultSet(stmt);  
  
  List<ResultMap> resultMaps = mappedStatement.getResultMaps();  
  int resultMapCount = resultMaps.size();  
  validateResultMapsCount(rsw, resultMapCount);  
    
  while (rsw != null && resultMapCount > resultSetCount) {  
    ResultMap resultMap = resultMaps.get(resultSetCount);  
      
    //将resultSet  
    handleResultSet(rsw, resultMap, multipleResults, null);  
    rsw = getNextResultSet(stmt);  
    cleanUpAfterHandlingResultSet();  
    resultSetCount++;  
  }  
  
  String[] resultSets = mappedStatement.getResulSets();  
  if (resultSets != null) {  
    while (rsw != null && resultSetCount < resultSets.length) {  
      ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);  
      if (parentMapping != null) {  
        String nestedResultMapId = parentMapping.getNestedResultMapId();  
        ResultMap resultMap = configuration.getResultMap(nestedResultMapId);  
        handleResultSet(rsw, resultMap, null, parentMapping);  
      }  
      rsw = getNextResultSet(stmt);  
      cleanUpAfterHandlingResultSet();  
      resultSetCount++;  
    }  
  }  
  
  return collapseSingleResultList(multipleResults);  
}  

 

　　1.2 排除第一种方案，那么能不能跳过这个方法执行我们的自己的逻辑，答案是可以的，接下来我们会用到mybatis的拦截器。

 

 2.定义mybatis拦截器，用来拦截handleResultSets                

        2.1 我们需要拿到MappedStatement（维护了一条<select|update|delete|insert>节点的封装）这个对象，才能获得resultType是什么类型，用于判断，那我们该怎么获取这个对象呢？ 首先我们到方法handleResultSets所属类中的源码里面看看 。

　　(1)   MappedStatement 是怎么生成的呢？由源码我们可知，是用过构造函数赋值的 

  public DefaultResultSetHandler(Executor executor, MappedStatement mappedStatement, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql,
      RowBounds rowBounds) {
    this.executor = executor;
    this.configuration = mappedStatement.getConfiguration();
    this.mappedStatement = mappedStatement;
    this.rowBounds = rowBounds;
    this.parameterHandler = parameterHandler;
    this.boundSql = boundSql;
    this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
    this.objectFactory = configuration.getObjectFactory();
    this.resultHandler = resultHandler;
  }

 

         (2)  那么既然存在这个属性，就能获取到这个对象么，可是，当我尝试去找获得 MappedStatement这个对象的方法时，并未找到，所以我只能自己加上去了！

  public MappedStatement getMappedStatement() {
        return mappedStatement;
 }

 

       2.1   我们在拦截器中就能使用MappedStatement 对象，从而获得resultType的类型，为什么要这样做呢？因为我只想实现当resultType为String的时候，才执行我自己的逻辑。

@Intercepts({ @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = { Statement.class }) })
public class JsonPlugin implements Interceptor {

    public Object intercept(Invocation invocation) throws Throwable {
        List<String> resList = new ArrayList<String>();
        
        DefaultResultSetHandler defaultResultSetHandler = (DefaultResultSetHandler) invocation.getTarget();
        //MappedStatement维护了一条<select|update|delete|insert>节点的封装
        MappedStatement mappedStatement = defaultResultSetHandler.getMappedStatement();
        //获取节点属性的集合
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        //获取当前resutType的类型
        Class<?> resultType = resultMaps.get(0).getType();
        if (resultMapCount > 0 && resultType.getName().equals("java.lang.String")) {
            Object[] obj = invocation.getArgs();
            Statement statement = (Statement) invocation.getArgs()[0];
            //获得结果集
            ResultSet resultSet = statement.getResultSet();

            if (resultSet != null) {
                //获得对应列名
                ResultSetMetaData rsmd = resultSet.getMetaData();
                List<String> columnList = new ArrayList<String>();

                for (int i = 1; i <= rsmd.getColumnCount(); i++) {
                    columnList.add(rsmd.getColumnName(i));
                }
                while (resultSet.next()) {
                    LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>();
                    for (String colName : columnList) {
                        map.put(colName, resultSet.getObject(colName));
                    }
                    JSONObject.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd hh:mm:ss";// 设置日期格式
                    resList.add(JSON.toJSONString(map, SerializerFeature.WriteMapNullValue,
                            SerializerFeature.DisableCircularReferenceDetect,
                            SerializerFeature.WriteDateUseDateFormat));
                }
                return resList;
            }
        } 
        return invocation.proceed();
    }

    public Object plugin(Object target) {
        // 读取@Signature中的配置，判断是否需要生成代理类
        if (target instanceof ResultSetHandler) {
            return Plugin.wrap(target, this);
        } else {
            return target;
        }
    }

    public void setProperties(Properties properties) {

    }

　　2.2 加入拦截器配置

    <!-- 拦截器配置开始 -->
    <plugins>
        <plugin interceptor="com.smallhan.base.interceptor.JsonPlugin" />
    </plugins>

 

3.测试结果                                                                               

       3.1 ResultType为String的时候，如下图所示，并且绕过handleResultSets

　　　

 

　　 3.2 ResultType为其他类型的时候，跳过我们自己写的逻辑,执行invocation.proceed，调用下一个拦截器拦截目标方法。