Mybatis Cursor

Cursor

  • 源码位置:org.apache.ibatis.cursor.Cursor
  • 继承Iterable说明是一个迭代器,继承Closeable说明有一个东西需要关闭
  1. public interface Cursor<T> extends Closeable, Iterable<T> {
  3.     /**
  4.      * 游标开始从数据库获取数据,返回true,反之false
  5.      *
  6.      * @return true if the cursor has started to fetch items from database.
  7.      */
  8.     boolean isOpen();
  10.     /**
  11.      * 数据库元素都被获取,返回true,反之false
  12.      *
  13.      * @return true if the cursor is fully consumed and has returned all elements matching the query.
  14.      */
  15.     boolean isConsumed();
  17.     /**
  18.      * 获取数据索引,从0开始,没有返回-1
  19.      * Get the current item index. The first item has the index 0.
  20.      *
  21.      * @return -1 if the first cursor item has not been retrieved. The index of the current item retrieved.
  22.      */
  23.     int getCurrentIndex();
  24. }

DefaultCursor

  1. public class DefaultCursor<T> implements Cursor<T> {
  3.     /**
  4.      * 对象包装结果处理类
  5.      */
  6.     protected final ObjectWrapperResultHandler<T> objectWrapperResultHandler = new ObjectWrapperResultHandler<>();
  7.     // ResultSetHandler stuff
  8.     /**
  9.      * ResultSet 处理器
  10.      */
  11.     private final DefaultResultSetHandler resultSetHandler;
  12.     /**
  13.      * 结果映射
  14.      */
  15.     private final ResultMap resultMap;
  16.     /**
  17.      * ResultSet 包装对象
  18.      */
  19.     private final ResultSetWrapper rsw;
  20.     /**
  21.      * 分页的
  22.      */
  23.     private final RowBounds rowBounds;
  24.     /**
  25.      * 游标的迭代器
  26.      */
  27.     private final CursorIterator cursorIterator = new CursorIterator();
  29.     /**
  30.      * 游标开启判断
  31.      */
  32.     private boolean iteratorRetrieved;
  34.     /**
  35.      * 游标状态,默认是创建未使用
  36.      */
  37.     private CursorStatus status = CursorStatus.CREATED;
  38.     /**
  39.      * 分页索引,默认-1
  40.      */
  41.     private int indexWithRowBound = -1;
  43.     /**
  44.      * 构造方法
  45.      *
  46.      * @param resultSetHandler
  47.      * @param resultMap
  48.      * @param rsw
  49.      * @param rowBounds
  50.      */
  51.     public DefaultCursor(DefaultResultSetHandler resultSetHandler, ResultMap resultMap, ResultSetWrapper rsw, RowBounds rowBounds) {
  52.         this.resultSetHandler = resultSetHandler;
  53.         this.resultMap = resultMap;
  54.         this.rsw = rsw;
  55.         this.rowBounds = rowBounds;
  56.     }
  59.     @Override
  60.     public boolean isOpen() {
  61.         return status == CursorStatus.OPEN;
  62.     }
  64.     @Override
  65.     public boolean isConsumed() {
  66.         return status == CursorStatus.CONSUMED;
  67.     }
  69.     /**
  70.      * 当前索引
  71.      * @return
  72.      */
  73.     @Override
  74.     public int getCurrentIndex() {
  75.         return rowBounds.getOffset() + cursorIterator.iteratorIndex;
  76.     }
  78.     /**
  79.      * 迭代器获取
  80.      * @return
  81.      */
  82.     @Override
  83.     public Iterator<T> iterator() {
  84.         // 是否获取过
  85.         if (iteratorRetrieved) {
  86.             throw new IllegalStateException("Cannot open more than one iterator on a Cursor");
  87.         }
  88.         // 是否关闭
  89.         if (isClosed()) {
  90.             throw new IllegalStateException("A Cursor is already closed.");
  91.         }
  92.         iteratorRetrieved = true;
  93.         return cursorIterator;
  94.     }
  96.     /**
  97.      * {@link Closeable} 关闭{@link ResultSet}
  98.      */
  99.     @Override
  100.     public void close() {
  101.         // 判断是否关闭
  102.         if (isClosed()) {
  103.             return;
  104.         }
  106.         ResultSet rs = rsw.getResultSet();
  107.         try {
  108.             if (rs != null) {
  109.                 rs.close();
  110.             }
  111.         } catch (SQLException e) {
  112.             // ignore
  113.         } finally {
  114.             // 设置游标状态
  115.             status = CursorStatus.CLOSED;
  116.         }
  117.     }
  119.     /**
  120.      * 去到真正的数据行
  121.      * @return
  122.      */
  123.     protected T fetchNextUsingRowBound() {
  124.         T result = fetchNextObjectFromDatabase();
  125.         while (objectWrapperResultHandler.fetched && indexWithRowBound < rowBounds.getOffset()) {
  126.             result = fetchNextObjectFromDatabase();
  127.         }
  128.         return result;
  129.     }
  131.     /**
  132.      * 从数据库获取数据
  133.      * @return
  134.      */
  135.     protected T fetchNextObjectFromDatabase() {
  136.         if (isClosed()) {
  137.             return null;
  138.         }
  140.         try {
  141.             objectWrapperResultHandler.fetched = false;
  142.             // 游标状态设置
  143.             status = CursorStatus.OPEN;
  144.             if (!rsw.getResultSet().isClosed()) {
  145.                 // 处理数据结果放入，objectWrapperResultHandler
  146.                 resultSetHandler.handleRowValues(rsw, resultMap, objectWrapperResultHandler, RowBounds.DEFAULT, null);
  147.             }
  148.         } catch (SQLException e) {
  149.             throw new RuntimeException(e);
  150.         }
  152.         // 获取处理结果
  153.         T next = objectWrapperResultHandler.result;
  154.         // 结果不为空
  155.         if (objectWrapperResultHandler.fetched) {
  156.             // 索引+1
  157.             indexWithRowBound++;
  158.         }
  159.         // No more object or limit reached
  160.         // 如果没有数据, 或者 当前读取条数= 偏移量+限额量
  161.         if (!objectWrapperResultHandler.fetched || getReadItemsCount() == rowBounds.getOffset() + rowBounds.getLimit()) {
  162.             // 关闭游标
  163.             close();
  164.             status = CursorStatus.CONSUMED;
  165.         }
  166.         // 设置结果为null
  167.         objectWrapperResultHandler.result = null;
  169.         return next;
  170.     }
  172.     /**
  173.      * 是否关闭状态判断
  174.      *
  175.      * @return
  176.      */
  177.     private boolean isClosed() {
  178.         return status == CursorStatus.CLOSED || status == CursorStatus.CONSUMED;
  179.     }
  181.     /**
  182.      * 下一个索引
  183.      * @return
  184.      */
  185.     private int getReadItemsCount() {
  186.         return indexWithRowBound + 1;
  187.     }
  189.     /**
  190.      * 游标的状态
  191.      */
  192.     private enum CursorStatus {
  194.         /**
  195.          * 新创建的游标, ResultSet 还没有使用过
  196.          * A freshly created cursor, database ResultSet consuming has not started.
  197.          */
  198.         CREATED,
  199.         /**
  200.          * 游标使用过, ResultSet 被使用
  201.          * A cursor currently in use, database ResultSet consuming has started.
  202.          */
  203.         OPEN,
  204.         /**
  205.          * 游标关闭, 可能没有被消费完全
  206.          * A closed cursor, not fully consumed.
  207.          */
  208.         CLOSED,
  209.         /**
  210.          * 游标彻底消费完毕, 关闭了
  211.          * A fully consumed cursor, a consumed cursor is always closed.
  212.          */
  213.         CONSUMED
  214.     }
  216.     /**
  217.      * 对象处理结果的包装类
  218.      * @param <T>
  219.      */
  220.     protected static class ObjectWrapperResultHandler<T> implements ResultHandler<T> {
  222.         /**
  223.          * 数据结果
  224.          */
  225.         protected T result;
  226.         /**
  227.          * 是否null
  228.          */
  229.         protected boolean fetched;
  231.         /**
  232.          * 从{@link ResultContext} 获取结果对象
  233.          * @param context
  234.          */
  235.         @Override
  236.         public void handleResult(ResultContext<? extends T> context) {
  237.             this.result = context.getResultObject();
  238.             context.stop();
  239.             fetched = true;
  240.         }
  241.     }
  243.     /**
  244.      * 游标迭代器
  245.      */
  246.     protected class CursorIterator implements Iterator<T> {
  248.         /**
  249.          * 下一个数据
  250.          * Holder for the next object to be returned.
  251.          */
  252.         T object;
  254.         /**
  255.          * 下一个的索引
  256.          * Index of objects returned using next(), and as such, visible to users.
  257.          */
  258.         int iteratorIndex = -1;
  260.         /**
  261.          * 是否有下一个值
  262.          * @return
  263.          */
  264.         @Override
  265.         public boolean hasNext() {
  266.             if (!objectWrapperResultHandler.fetched) {
  267.                 object = fetchNextUsingRowBound();
  268.             }
  269.             return objectWrapperResultHandler.fetched;
  270.         }
  272.         /**
  273.          * 下一个值
  274.          * @return
  275.          */
  276.         @Override
  277.         public T next() {
  278.             // Fill next with object fetched from hasNext()
  279.             T next = object;
  281.             if (!objectWrapperResultHandler.fetched) {
  282.                 next = fetchNextUsingRowBound();
  283.             }
  285.             if (objectWrapperResultHandler.fetched) {
  286.                 objectWrapperResultHandler.fetched = false;
  287.                 object = null;
  288.                 iteratorIndex++;
  289.                 return next;
  290.             }
  291.             throw new NoSuchElementException();
  292.         }
  294.         /**
  295.          * 不可执行抛出异常
  296.          */
  297.         @Override
  298.         public void remove() {
  299.             throw new UnsupportedOperationException("Cannot remove element from Cursor");
  300.         }
  301.     }
  302. }