彬_708c
彬_708c

Mybatis-ResultHandler,Cursor,RowBounds 源码分析

Mybatis3.5.1源码分析

  1. Mybatis-SqlSessionFactoryBuilder，XMLConfigBuilder，XPathParser源码解析
  2. Mybatis-Configuration源码解析
  3. Mybatis-事务对象源码解析
  4. Mybatis-数据源源码解析
  5. Mybatis缓存策略源码解析
  6. Mybatis-DatabaseIdProvider源码解析
  7. Mybatis-TypeHandler源码解析
  8. Mybatis-Reflector源码解析
  9. Mybatis-ObjectFactory，ObjectWrapperFactory源码分析
  10. Mybatis-Mapper各类标签封装类源码解析
  11. Mybatis-XMLMapperBuilder,XMLStatmentBuilder源码分析
  12. Mybatis-MapperAnnotationBuilder源码分析
  13. [Mybatis-MetaObject,MetaClass源码解析]https://www.jianshu.com/p/f51fa552f30a)
  14. Mybatis-LanguageDriver源码解析
  15. Mybatis-SqlSource源码解析
  16. Mybatis-SqlNode源码解析
  17. Mybatis-KeyGenerator源码解析
  18. Mybatis-Executor源码解析
  19. Mybatis-ParameterHandler源码解析
  20. Mybatis-StatementHandler源码解析
  21. Mybatis-DefaultResultSetHandler(一)源码解析
  22. Mybatis-DefaultResultSetHandler(二)源码解析
  23. Mybatis-ResultHandler,Cursor,RowBounds 源码分析
  24. Mybatis-MapperProxy源码解析
  25. Mybatis-SqlSession源码解析
  26. Mybatis-Interceptor源码解析

ResultHandler

/**
 *    Copyright 2009-2015 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.session;

/**
 * 结果处理类
 * @author Clinton Begin
 */
public interface ResultHandler {

  /**
   * 处理结果
   * @param resultContext 结果上下文
   */
  void handleResult(ResultContext resultContext);

}

DefaultResultHandler

/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.executor.result;

import java.util.ArrayList;
import java.util.List;

import org.apache.ibatis.reflection.factory.ObjectFactory;
import org.apache.ibatis.session.ResultContext;
import org.apache.ibatis.session.ResultHandler;

/**
 * 默认ResultHandler，通过ObjectFactory去构建list。本质是一个list
 * @author Clinton Begin
 */
public class DefaultResultHandler implements ResultHandler {

  /**
   * 集合
   */
  private final List list;

  public DefaultResultHandler() {
    list = new ArrayList<>();
  }

  @SuppressWarnings("unchecked")
  public DefaultResultHandler(ObjectFactory objectFactory) {
    list = objectFactory.create(List.class);
  }

  @Override
  public void handleResult(ResultContext context) {
    list.add(context.getResultObject());
  }

  public List getResultList() {
    return list;
  }

}



DefaultMapResultHandler


/**
 *    Copyright 2009-2015 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.executor.result;

import java.util.Map;

import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.ReflectorFactory;
import org.apache.ibatis.reflection.factory.ObjectFactory;
import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;
import org.apache.ibatis.session.ResultContext;
import org.apache.ibatis.session.ResultHandler;

/**
 * 默认Map的ResultHandler
 * @author Clinton Begin
 */
public class DefaultMapResultHandler implements ResultHandler {

  /**
   * 映射结果
   */
  private final Map mappedResults;
  /**
   * 映射Key
   * 

   *   指定一个字段作为返回Map中的key，这里一般也就是使用唯一键来做key.
   * 

   * 

   *     参考博客：https://blog.csdn.net/u012734441/article/details/85861337
   * 

   */
  private final String mapKey;
  /**
   * 对象工厂
   */
  private final ObjectFactory objectFactory;
  /**
   * 对象包装工厂
   */
  private final ObjectWrapperFactory objectWrapperFactory;
  /**
   * 反射工厂
   */
  private final ReflectorFactory reflectorFactory;

  /**
   *
   * @param mapKey 指定一个字段作为返回Map中的key，这里一般也就是使用唯一键来做key.
   *               参考博客：https://blog.csdn.net/u012734441/article/details/85861337
   * @param objectFactory 对象工厂
   * @param objectWrapperFactory 对象包装工厂
   * @param reflectorFactory 反射工厂
   */
  @SuppressWarnings("unchecked")
  public DefaultMapResultHandler(String mapKey, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
    this.objectFactory = objectFactory;
    this.objectWrapperFactory = objectWrapperFactory;
    this.reflectorFactory = reflectorFactory;
    this.mappedResults = objectFactory.create(Map.class);
    this.mapKey = mapKey;
  }

  @Override
  public void handleResult(ResultContext context) {
    //获取结果对象
    final V value = context.getResultObject();
    //value元对象
    final MetaObject mo = MetaObject.forObject(value, objectFactory, objectWrapperFactory, reflectorFactory);
    // TODO is that assignment always true?
    //获取mapKey的key
    final K key = (K) mo.getValue(mapKey);
    mappedResults.put(key, value);
  }

  public Map getMappedResults() {
    return mappedResults;
  }
}




Cursor


/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.cursor;

import java.io.Closeable;

/**
 * Cursor contract to handle fetching items lazily using an Iterator.
 * Cursors are a perfect fit to handle millions of items queries that would not normally fits in memory.
 * If you use collections in resultMaps then cursor SQL queries must be ordered (resultOrdered="true")
 * using the id columns of the resultMap.
 * 

 * 这个游标通过迭代器来获取一条条数据
 * 游标非常适合处理数百万查询数据，这个样百万数据并不适合内存中获取
 * 如果在resultMap去收集结果，那么sql查询必须是有序的即设置（在id列进行设置resultOrdered="true"）
 * 

 * https://blog.csdn.net/m0_37355951/article/details/97552290
 * @author Guillaume Darmont / [email protected]
 */
public interface Cursor extends Closeable, Iterable {

  /**
   * 游标开始从数据库获取数据这个就返回true
   * @return true if the cursor has started to fetch items from database.
   */
  boolean isOpen();

  /**
   * 判断所有元素是否已经获取完
   * @return true if the cursor is fully consumed and has returned all elements matching the query.
   */
  boolean isConsumed();

  /**
   * 获取数据的索引，从0开始，如果没有数据就返回-1
   * Get the current item index. The first item has the index 0.
   * @return -1 if the first cursor item has not been retrieved. The index of the current item retrieved.
   */
  int getCurrentIndex();
}




DefaultCursor


/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.cursor.defaults;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.NoSuchElementException;

import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.resultset.DefaultResultSetHandler;
import org.apache.ibatis.executor.resultset.ResultSetWrapper;
import org.apache.ibatis.mapping.ResultMap;
import org.apache.ibatis.session.ResultContext;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

/**
 * This is the default implementation of a MyBatis Cursor.
 * This implementation is not thread safe.
 * 

 *  这个是默认的Mybatis Cursor接口实现类
 *  该实例并不是线程安全的
 * 

 * 

 *     默认的mybatis游标实例
 * 

 *
 * @author Guillaume Darmont / [email protected]
 */
public class DefaultCursor implements Cursor {

  // ResultSetHandler stuff
  /**
   * 默认的结果集处理器
   */
  private final DefaultResultSetHandler resultSetHandler;
  /**
   * Mapper.xml的resultMap标签信息封装类对象
   */
  private final ResultMap resultMap;
  /**
   * 结果集包装类对象
   */
  private final ResultSetWrapper rsw;
  /**
   * Mybatis的分页对象
   */
  private final RowBounds rowBounds;
  /**
   * 对象包装结果处理类
   */
  private final ObjectWrapperResultHandler objectWrapperResultHandler = new ObjectWrapperResultHandler<>();

  /**
   * 游标迭代器
   */
  private final CursorIterator cursorIterator = new CursorIterator();

  /**
   * 迭代器打开了的标记，该标记使得迭代器不能多次打开游标，只能打开一次
   */
  private boolean iteratorRetrieved;

  /**
   *  游标的默认状态是创建
   */
  private CursorStatus status = CursorStatus.CREATED;
  /**
   * 分页对象的索引位置为-1
   */
  private int indexWithRowBound = -1;

  /**
   * 游标状态枚举
   */
  private enum CursorStatus {

    /**
     * A freshly created cursor, database ResultSet consuming has not started.
     * 刚刚出炉的游标，数据库的结果集还没有被消费
     */
    CREATED,
    /**
     * A cursor currently in use, database ResultSet consuming has started.
     * 游标已经被使用，同时结果集数据已经开始被使用了
     */
    OPEN,
    /**
     * A closed cursor, not fully consumed.
     * 游标被关闭，可能并没有全部被消费掉
     */
    CLOSED,
    /**
     * A fully consumed cursor, a consumed cursor is always closed.
     * 表示游标已经遍历所有数据集，这个消费完游标一直将会被关闭掉
     */
    CONSUMED
  }

  /**
   *
   * @param resultSetHandler 默认结果集处理器
   * @param resultMap Mapper.xml的resultMap标签信息封装类对象
   * @param rsw 结果集包装类对象
   * @param rowBounds Mybatis的分页对象
   */
  public DefaultCursor(DefaultResultSetHandler resultSetHandler, ResultMap resultMap, ResultSetWrapper rsw, RowBounds rowBounds) {
    this.resultSetHandler = resultSetHandler;
    this.resultMap = resultMap;
    this.rsw = rsw;
    this.rowBounds = rowBounds;
  }

  /**
   * 游标是否打开了
   */
  @Override
  public boolean isOpen() {
    //如果当前游标状态为OPEN
    return status == CursorStatus.OPEN;
  }

  /**
   * 判断游标是否被消费完了
   */
  @Override
  public boolean isConsumed() {
    //如果当前游标状态为CONSUMED
    return status == CursorStatus.CONSUMED;
  }

  /**
   * 获取当前的索引
   */
  @Override
  public int getCurrentIndex() {
    //分页偏移量+游标迭代器索引位置
    return rowBounds.getOffset() + cursorIterator.iteratorIndex;
  }

  /**
   * 获取迭代器
   */
  @Override
  public Iterator iterator() {
    //如果是已经获取过一次迭代器了
    if (iteratorRetrieved) {
      //抛出只能迭代异常的异常
      throw new IllegalStateException("Cannot open more than one iterator on a Cursor");
    }
    //如果游标已经关闭
    if (isClosed()) {
      //抛出游标已关闭异常
      throw new IllegalStateException("A Cursor is already closed.");
    }
    //修改标记，防止重新调用该方法
    iteratorRetrieved = true;
    //返回游标迭代器
    return cursorIterator;
  }

  /**
   * 关闭游标
   */
  @Override
  public void close() {
    //如果游标已经关闭直接返回
    if (isClosed()) {
      return;
    }
    //获取结果集
    ResultSet rs = rsw.getResultSet();
    try {
      //如果结果集不为空
      if (rs != null) {
        //关闭结果集
        rs.close();
      }
    } catch (SQLException e) {
      // ignore 忽略关闭后异常
    } finally {
      //将游标状态设置为已关闭
      status = CursorStatus.CLOSED;
    }
  }

  /**
   * 使用Mybatis分页对象抓取下一个结果
   * @return 下一个结果
   */
  protected T fetchNextUsingRowBound() {
    //从数据库中获取下一个结果
    T result = fetchNextObjectFromDatabase();
    //通过下面的while循环，不断获取下一个结果直到达到分页对象设置的开始位置。
    //只要结果不为null 且 当前分页索引位置小于分页对象设置的开始位置 就继续获取下一个结果。
    while (result != null && indexWithRowBound < rowBounds.getOffset()) {
      //从数据库中获取下一个结果
      result = fetchNextObjectFromDatabase();
    }
    //返回结果
    return result;
  }

  /**
   * 从数据库中获取下一个结果
   * @return 下一个结果
   */
  protected T fetchNextObjectFromDatabase() {
    // //判断游标是否已经关闭，已关闭返回null
    if (isClosed()) {
      return null;
    }
    try {
      //设置当前状态是游标打开状态
      status = CursorStatus.OPEN;
      //如果结果集包装类不是已经关闭
      if (!rsw.getResultSet().isClosed()) {
        /**
         *  构建出来的结果对象,如果父级结果属性映射不为null，会将结果对象赋值到父级结果属性对应的结果对象中，
         *  否则将结果对象加入到reusltHandler中
         */
        //把结果放入objectWrapperResultHandler对象的result中
        resultSetHandler.handleRowValues(rsw, resultMap, objectWrapperResultHandler, RowBounds.DEFAULT, null);
      }
    } catch (SQLException e) {
      throw new RuntimeException(e);
    }
    // 获取对象包装处理的结果
    T next = objectWrapperResultHandler.result;
    // 如果结果不为空结果， 索引++
    if (next != null) {
      indexWithRowBound++;
    }
    // No more object or limit reached
    ///next为null或者读取条数等于偏移量+限制条数,偏移量+限制条数=可读取的条数
    if (next == null || getReadItemsCount() == rowBounds.getOffset() + rowBounds.getLimit()) {
      //关闭游标
      close();
      //将游标状态修改为已消耗完的关闭状态
      status = CursorStatus.CONSUMED;
    }
    //把结果设置为null
    objectWrapperResultHandler.result = null;
    //返回结果
    return next;
  }

  /**
   * 游标是否已经关闭
   */
  private boolean isClosed() {
    //如果当前游标状态为CLOSED或者为CONSUMED
    return status == CursorStatus.CLOSED || status == CursorStatus.CONSUMED;
  }

  /**
   * 下一个读取索引位置
   */
  private int getReadItemsCount() {
    //当前分页对象索引位置+1
    return indexWithRowBound + 1;
  }

  /**
   * 对象包装结果处理类
   */
  private static class ObjectWrapperResultHandler implements ResultHandler {

    /**
     * 结果对象
     */
    private T result;

    @Override
    public void handleResult(ResultContext context) {
      //获取结果对象
      this.result = context.getResultObject();
      //标记结果上下文为停止
      context.stop();
    }
  }

  /**
   * 游标迭代器
   */
  private class CursorIterator implements Iterator {

    /**
     * Holder for the next object to be returned.
     * 保存下一个将会被返回的对象
     */
    T object;

    /**
     * 返回下一个对象的索引
     * Index of objects returned using next(), and as such, visible to users.
     */
    int iteratorIndex = -1;

    /**
     * 是否有下一个结果
     */
    @Override
    public boolean hasNext() {
      if (object == null) {
        object = fetchNextUsingRowBound();
      }
      return object != null;
    }

    /**
     * 获取下一个结果
     */
    @Override
    public T next() {
      // Fill next with object fetched from hasNext()
      T next = object;
      //执行过haNext()方法object的值才不会为null
      if (next == null) {
        ////表示没有执行hasNext()方法，所以在获取一次数据
        next = fetchNextUsingRowBound();
      }
      //如果下一个结果不为null
      if (next != null) {
        //保存下一个将会被返回的对象设置为null
        object = null;
        //下一个对象的索引++
        iteratorIndex++;
        //返回下一个结果
        return next;
      }
      //下一个结果为null时，抛出异常
      throw new NoSuchElementException();
    }

    /**
     * 不支持删除对象
     */
    @Override
    public void remove() {
      throw new UnsupportedOperationException("Cannot remove element from Cursor");
    }
  }
}




ResultLoaderMap


/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.executor.loader;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.BaseExecutor;
import org.apache.ibatis.executor.BatchResult;
import org.apache.ibatis.executor.ExecutorException;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

/**
 * 用来表示需要懒加载的属性集，本质是一个HashMap
 * https://blog.csdn.net/qq_39470742/article/details/88794755
 * @author Clinton Begin
 * @author Franta Mejta
 */
public class ResultLoaderMap {

  /**
   * 懒加载属性集
   */
  private final Map loaderMap = new HashMap<>();

  /**
   * 添加加载器到映射
   * @param property 属性名
   * @param metaResultObject 结果元对象
   * @param resultLoader  结果加载器
   */
  public void addLoader(String property, MetaObject metaResultObject, ResultLoader resultLoader) {
    /**
     *   将 {@code property} 转换成大写，如果 {@code property} 属于'xxx.xx.x'格式，
     *   则将'.'作为分割符分成数组，去数组的第一个元素转化成大写并返回出去。
     */
    String upperFirst = getUppercaseFirstProperty(property);
    //如果upperFirst忽略大小写的相等判断property不对应 且 加载器映射队列中已经含有upperFist
    if (!upperFirst.equalsIgnoreCase(property) && loaderMap.containsKey(upperFirst)) {
      throw new ExecutorException("Nested lazy loaded result property '" + property
              + "' for query id '" + resultLoader.mappedStatement.getId()
              + " already exists in the result map. The leftmost property of all lazy loaded properties must be unique within a result map.");
    }
    loaderMap.put(upperFirst, new LoadPair(property, metaResultObject, resultLoader));
  }

  public final Map getProperties() {
    return new HashMap<>(this.loaderMap);
  }

  public Set getPropertyNames() {
    return loaderMap.keySet();
  }

  public int size() {
    return loaderMap.size();
  }

  public boolean hasLoader(String property) {
    return loaderMap.containsKey(property.toUpperCase(Locale.ENGLISH));
  }

  /**
   * 执行对 {@code property} 的懒加载查询
   * @param property 属性名
   * @return 在加载器映射队列中存在该property对应的LoadPair对象时，返回true，否则返回false
   */
  public boolean load(String property) throws SQLException {
    //获取property对应的LoadPair对象，这里使用的是remove,所以只能获取一次
    LoadPair pair = loaderMap.remove(property.toUpperCase(Locale.ENGLISH));
    if (pair != null) {
      //执行懒加载查询
      pair.load();
      return true;
    }
    return false;
  }

  public void remove(String property) {
    loaderMap.remove(property.toUpperCase(Locale.ENGLISH));
  }

  /**
   * 执行对 加载器映射队列的所有元素 的懒加载查询
   */
  public void loadAll() throws SQLException {
    final Set methodNameSet = loaderMap.keySet();
    String[] methodNames = methodNameSet.toArray(new String[methodNameSet.size()]);
    for (String methodName : methodNames) {
      load(methodName);
    }
  }

  /**
   * 将 {@code property} 转换成大写，如果 {@code property} 属于'xxx.xx.x'格式，则将'.'作为
   * 分割符分成数组，去数组的第一个元素转化成大写并返回出去。
   * @param property 属性名
   * @return 大写的 {@code property}
   */
  private static String getUppercaseFirstProperty(String property) {
    String[] parts = property.split("\\.");
    return parts[0].toUpperCase(Locale.ENGLISH);
  }

  /**
   * 对于单个属性懒加载信息的封装，最重要的就是其load方法用来加载属性
   * 

   * Property which was not loaded yet.属性仍然未加载
   */
  public static class LoadPair implements Serializable {

    private static final long serialVersionUID = 20130412;
    /**
     * Name of factory method which returns database connection.
     * 

     *     返回数据库连接的工厂方法名
     * 

     */
    private static final String FACTORY_METHOD = "getConfiguration";
    /**
     * Object to check whether we went through serialization..
     * 

     *     对象用于来检查我们是否经过序列化。
     * 

     */
    private final transient Object serializationCheck = new Object();
    /**
     * Meta object which sets loaded properties.
     * 

     *     已加载属性的集合元对象
     * 

     */
    private transient MetaObject metaResultObject;
    /**
     * Result loader which loads unread properties.
     * 

     *     加载未读取的属性的结果加载器
     * 

     */
    private transient ResultLoader resultLoader;
    /**
     * Wow, logger.
     * 

     *     日志对象
     * 

     */
    private transient Log log;
    /**
     * Factory class through which we get database connection.
     * 

     *     用于获取数据库连接的工厂类
     * 

     */
    private Class configurationFactory;
    /**
     * Name of the unread property.
     * 

     *     未读取的属性名
     * 

     */
    private String property;
    /**
     * ID of SQL statement which loads the property.
     * 

     *     用于加载 {@link #property} 的ID的SQL脚本
     * 

     */
    private String mappedStatement;
    /**
     * Parameter of the sql statement.
     * 

     *     {@link #mappedStatement} 的参数对象
     * 

     */
    private Serializable mappedParameter;

    /**
     *
     * @param property 属性名
     * @param metaResultObject 已加载属性的集合元对象
     * @param resultLoader 结果加载器
     */
    private LoadPair(final String property, MetaObject metaResultObject, ResultLoader resultLoader) {
      this.property = property;
      this.metaResultObject = metaResultObject;
      this.resultLoader = resultLoader;

      //保存所需的信息只有原始对象可以序列化;
      /* Save required information only if original object can be serialized. */
      if (metaResultObject != null && metaResultObject.getOriginalObject() instanceof Serializable) {
        //获取参数对象
        final Object mappedStatementParameter = resultLoader.parameterObject;

        /* @todo May the parameter be null? */
        if (mappedStatementParameter instanceof Serializable) {
          //  Mapper.xml文件的select,delete,update,insert这些DML标签的封装类对象的Id
          this.mappedStatement = resultLoader.mappedStatement.getId();
          //参数对象序列化赋值
          this.mappedParameter = (Serializable) mappedStatementParameter;
          //获取数据库连接的工厂类
          this.configurationFactory = resultLoader.configuration.getConfigurationFactory();
        } else {
          //日志信息打印
          Log log = this.getLogger();
          if (log.isDebugEnabled()) {
            log.debug("Property [" + this.property + "] of ["
                    + metaResultObject.getOriginalObject().getClass() + "] cannot be loaded "
                    + "after deserialization. Make sure it's loaded before serializing "
                    + "forenamed object.");
          }
        }
      }
    }

    /**
     *  执行懒加载查询
     */
    public void load() throws SQLException {
      /* These field should not be null unless the loadpair was serialized.
       * Yet in that case this method should not be called. */
      //这些字段不能空,除非loadpair序列化，然而,在这种情况下这个方法不应该被称为。
      if (this.metaResultObject == null) {
        throw new IllegalArgumentException("metaResultObject is null");
      }
      if (this.resultLoader == null) {
        throw new IllegalArgumentException("resultLoader is null");
      }

      this.load(null);
    }

    /**
     * 执行懒加载查询，获取数据并且赋值到userObject中返回
     * @param userObject 用户对象
     */
    public void load(final Object userObject) throws SQLException {
      //合法性校验
      if (this.metaResultObject == null || this.resultLoader == null) {
        if (this.mappedParameter == null) {
          throw new ExecutorException("Property [" + this.property + "] cannot be loaded because "
                  + "required parameter of mapped statement ["
                  + this.mappedStatement + "] is not serializable.");
        }

        //获取mappedstatement并且校验
        final Configuration config = this.getConfiguration();
        final MappedStatement ms = config.getMappedStatement(this.mappedStatement);
        if (ms == null) {
          throw new ExecutorException("Cannot lazy load property [" + this.property
                  + "] of deserialized object [" + userObject.getClass()
                  + "] because configuration does not contain statement ["
                  + this.mappedStatement + "]");
        }

        //使用userObject构建metaobject
        this.metaResultObject = config.newMetaObject(userObject);
        //重新构建resultloader对象
        this.resultLoader = new ResultLoader(config, new ClosedExecutor(), ms, this.mappedParameter,
                metaResultObject.getSetterType(this.property), null, null);
      }

      /* We are using a new executor because we may be (and likely are) on a new thread
       * and executors aren't thread safe. (Is this sufficient?)
       *
       * A better approach would be making executors thread safe. */
      /**
       * 我们使用一个新的执行器，因为可能是新的线程和执行器不是线程安全
       * 一个更好的方法会使执行器线程安全
       */
      /**
       * this.serializationCheck == null表示如果序列化过，因为serializationCheck
       * 被tranisent关键字修饰着，所以不参与对象序列化，所以在
       * 反序列化后serializationCheck会变成null，从而得知loadPair对象是否序列化过
       */
      if (this.serializationCheck == null) {
        final ResultLoader old = this.resultLoader;
        //新建一个新的resultLoader对象，
        this.resultLoader = new ResultLoader(old.configuration, new ClosedExecutor(), old.mappedStatement,
                old.parameterObject, old.targetType, old.cacheKey, old.boundSql);
      }
      /**
       * 调用resultLoader的loadResult获取查询结果并赋值到metaResultObject中。
       *
       * 这里可能有会有疑问，resultLoader调用loadResult方法因为其resultLoader对象的executoer对象
       * 经过反序列后，executoer对象会被赋值成ClosedExecutoer对象，当调用ClosedExecutoer对象的
       * 关于执行SQL脚本的方法时会抛出异常，那岂不是得不到查询结果？
       * 其实resultLoader并没有使用ClosedExecutoer对象直接执行SQL脚本，而是调用executoer对象的
       * isClose()看看执行器是否已经关闭，若关闭了，通过构建一个SimpleExecutor对象来执行SQL脚本
       */
      this.metaResultObject.setValue(property, this.resultLoader.loadResult());
    }

    /**
     * 获取配置
     */
    private Configuration getConfiguration() {
      //如果数据库连接工厂类为null
      if (this.configurationFactory == null) {
        throw new ExecutorException("Cannot get Configuration as configuration factory was not set.");
      }

      Object configurationObject;
      try {
        //获取工厂对象的返回数据库连接方法
        final Method factoryMethod = this.configurationFactory.getDeclaredMethod(FACTORY_METHOD);
        //如果返回数据库连接方法不是静态方法
        if (!Modifier.isStatic(factoryMethod.getModifiers())) {
          throw new ExecutorException("Cannot get Configuration as factory method ["
                  + this.configurationFactory + "]#["
                  + FACTORY_METHOD + "] is not static.");
        }

        //如果返回数据库连接方法不能访问
        if (!factoryMethod.isAccessible()) {
          /**
           * AccessController.doPrivileged是一个在AccessController类中的静态方法，允许在一个类实例中的代码通知这个AccessController：它的代码主体是享受"privileged(特权的)"，它单独负责对它的可得的资源的访问请求，而不管这个请求是由什么代码所引发的。
           * 这就是说，一个调用者在调用doPrivileged方法时，可被标识为 "特权"。在做访问控制决策时，如果checkPermission方法遇到一个通过doPrivileged调用而被表示为 "特权"的调用者，并且没有上下文自变量，checkPermission方法则将终止检查。如果那个调用者的域具有特定的许可，则不做进一步检查，checkPermission安静地返回，表示那个访问请求是被允许的；如果那个域没有特定的许可，则象通常一样，一个异常被抛出。
           */
          configurationObject = AccessController.doPrivileged((PrivilegedExceptionAction) () -> {
            try {
              //设置成可访问
              factoryMethod.setAccessible(true);
              //执行方法
              return factoryMethod.invoke(null);
            } finally {
              //设置成不可访问
              factoryMethod.setAccessible(false);
            }
          });
        } else {
          //执行方法
          configurationObject = factoryMethod.invoke(null);
        }
      } catch (final ExecutorException ex) {
        throw ex;
      } catch (final NoSuchMethodException ex) {
        throw new ExecutorException("Cannot get Configuration as factory class ["
                + this.configurationFactory + "] is missing factory method of name ["
                + FACTORY_METHOD + "].", ex);
      } catch (final PrivilegedActionException ex) {
        throw new ExecutorException("Cannot get Configuration as factory method ["
                + this.configurationFactory + "]#["
                + FACTORY_METHOD + "] threw an exception.", ex.getCause());
      } catch (final Exception ex) {
        throw new ExecutorException("Cannot get Configuration as factory method ["
                + this.configurationFactory + "]#["
                + FACTORY_METHOD + "] threw an exception.", ex);
      }

      //如果configurationObject没有继承Configuration
      if (!(configurationObject instanceof Configuration)) {
        throw new ExecutorException("Cannot get Configuration as factory method ["
                + this.configurationFactory + "]#["
                + FACTORY_METHOD + "] didn't return [" + Configuration.class + "] but ["
                + (configurationObject == null ? "null" : configurationObject.getClass()) + "].");
      }
      //将configuationObject强制转换成Configuration类型
      return Configuration.class.cast(configurationObject);
    }

    private Log getLogger() {
      if (this.log == null) {
        this.log = LogFactory.getLog(this.getClass());
      }
      return this.log;
    }
  }

  /**
   * 已关闭的执行器，不能执行任何SQL脚本，isClosed方法为true，表示已经关闭。
   * 如果执行任何SQL脚本，都会抛出执行UnsupportedOperationException异常
   */
  private static final class ClosedExecutor extends BaseExecutor {

    public ClosedExecutor() {
      super(null, null);
    }

    @Override
    public boolean isClosed() {
      return true;
    }

    @Override
    protected int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
      throw new UnsupportedOperationException("Not supported.");
    }

    @Override
    protected List doFlushStatements(boolean isRollback) throws SQLException {
      throw new UnsupportedOperationException("Not supported.");
    }

    @Override
    protected  List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
      throw new UnsupportedOperationException("Not supported.");
    }

    @Override
    protected  Cursor doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException {
      throw new UnsupportedOperationException("Not supported.");
    }
  }
}



RowBound


/**
 *    Copyright 2009-2017 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.session;

/**
 * Mybatis的分页对象
 * 

 *     Mybatis也支持分页查询，可以借助RowBounds对象，对数据分页，但是，基于RowBounds的分页是对ResultSet结果集进行分页，也就是逻辑分页，并不是物理分页。换句话说，也就是先把数据库中的数据全部查询出来，然后在进行过滤。
 * 

 * 参考博客:https://www.jianshu.com/p/84599f9a49d0
 * @author Clinton Begin
 */
public class RowBounds {
  /**
   * 从第0条开始
   */
  public static final int NO_ROW_OFFSET = 0;
  /**
   * 取最大记录数
   */
  public static final int NO_ROW_LIMIT = Integer.MAX_VALUE;
  public static final RowBounds DEFAULT = new RowBounds();

  /**
   * 从第几条开始
   */
  private final int offset;
  /**
   * 取多少条
   */
  private final int limit;

  public RowBounds() {
    this.offset = NO_ROW_OFFSET;
    this.limit = NO_ROW_LIMIT;
  }

  /**
   *
   * @param offset 从第几条开始
   * @param limit 取多少条
   */
  public RowBounds(int offset, int limit) {
    this.offset = offset;
    this.limit = limit;
  }

  public int getOffset() {
    return offset;
  }

  public int getLimit() {
    return limit;
  }

}


























你可能感兴趣的:(Mybatis-ResultHandler,Cursor,RowBounds 源码分析)






    

  • JVM源码分析之堆外内存完全解读
HeapDump性能社区

    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    

    • 

  • Golang Channel
PandaSkr
golang

    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    

    • 

  • matlab游标标注移动,matlab实现图形窗口的数据游标
莫白想
matlab游标标注移动

    DatacursorsforfigurewindowSeveralrelatedfunctions:CreateCursorsetsupaverticalcursoronallaxesinafigure.Thecursorscanbemovedaroundusingthemouse.MultiplecursorsaresupportedineachfigureGetCursorLocationre
    

    • 

  • Java集合类框架源码分析 之 RoleList源码解析 【6】
yunzhonghefei
Java集合类源码分析RoleList源码解析

    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    

    • 

  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
"小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为

    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    

    • 

  • SQLite的入门级项目学习记录（二）
深蓝海拓
SQLite学习笔记sqlite学习数据库

    再补充一些基础知识：并行操作的问题1、可以多游标同时运行SQLite，对于同一个连接sqlite3.connect(db_file)，可以同时创建多个游标，每个游标都是独立的，可以执行各自的SQL命令序列。importsqlite3#创建数据库连接conn=sqlite3.connect('example.db')#创建第一个游标cursor1=conn.cursor()cursor1.execu
    

    • 

  • Java高并发编程详解系列-深入理解Thread构造
nihui123
高并发Java高并发Java高并发

    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
    

    • 

  • 【QT教程】QT6硬件图形界面编程 QT硬件编程
QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程

    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
    

    • 

  • css鼠标移上去向上移动,css3鼠标移动图片上移效果
yo xiba
css鼠标移上去向上移动

    css3的功能真是很强大，学无止境，不多说，直接上代码css部分：*{margin:;padding:;}.text-center{text-align:center}.col_cont{width:300px;height:300px;margin:auto}.thumbnail{cursor:pointer;text-decoration:none;display:block;padding:
    

    • 

  • Jetpack LiveData源码分析
xiangxiongfly915
#AndroidJetpack系列JetpackLiveData源码分析

    文章目录JetpackLiveData源码分析前提源码分析注册订阅流程LiveData#observe()LifecycleRegistry#addObserver()ObserverWithState#dispatchEvent()LiveData#removeObserver()LiveData$LifecycleBoundObserver类LifecycleBoundObserver#sho
    

    • 

  • ExoPlayer架构详解与源码分析（17）——TrackSelector
山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码

    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    

    • 

  • ExoPlayer架构详解与源码分析（12）——Cache
山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码

    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    

    • 

  • ExoPlayer架构详解与源码分析（7）——SampleQueue(4)
2401_83740189
程序员架构

    long[]newSourceIds=newlong[newCapacity];long[]newOffsets=newlong[newCapacity];long[]newTimesUs=newlong[newCapacity];int[]newFlags=newint[newCapacity];int[]newSizes=newint[newCapacity];CryptoData[]newC
    

    • 

  • 【HarmonyOS】- 常见算法简单写法
数的羊都睡了
HarmonyOSArkTS鸿蒙

    文章目录知识回顾前言源码分析1.冒泡排序2.二分法查找拓展知识时间、空间复杂度总结知识回顾前言常见算法简单写法源码分析1.冒泡排序functionbubbleSort(arr:number[]):number[]{constn=arr.length;for(leti=0;iarr[j+1]){//交换元素consttemp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;
    

    • 

  • [ docker-ce源码分析系列 ] 修改resolv.conf文件被还原的原因
nangonghen
dockerdocker

    1概述：1.1环境版本信息如下：a、操作系统：centos7.6，amd64b、服务器docker版本：v18.09.22resolv.conf文件被还原的现象：容器中的/etc/resolv.conf文件，是由宿主机/var/lib/docker/containers/xxxx/resolv.conf文件挂载。在dockerrestart容器之前，手动修改了/var/lib/docker/con
    

    • 

  • dispatch_once源码分析
福伟_Y

    GCD里的单例函数dispatch_once是我们经常会用到的，今天我们来稍做深入分析一下。GCD的源码都在libdispatch.dylib库里，这个库在libSystem_initializer被初始化，可理解为在dyld里被加载和初始化的(之前的文章有分析过)。dispatch_once作为单例的使用入口，通过分析得到它是一个宏定义，_dispatch_once函数在libdispatch.
    

    • 

  • jQuery Easyui 源码分析之combo组件
90后北京程序员
前端-easyuieasyui之combobox

    /***jQueryEasyUI1.3.1*该源码完全由压缩码翻译而来，并非网络上放出的源码，请勿索要。*/(function($){functionsetSize(target,width){varopts=$.data(target,"combo").options;varcombo=$.data(target,"combo").combo;varpanel=$.data(target,"co
    

    • 

  • CSS学习16--CSS高级技巧：用户界面样式、精灵技术、字体图标、滑动门
乌鸦不像写字台
css学习css学习前端

    CSS高级技巧一、用户界面样式1.鼠标样式cursor2.轮廓outline3.防止拖拽文本域resize4.vertical-align垂直对齐5.去除图片底侧空白缝隙6.溢出文字隐藏二、精灵技术sprite1.精灵技术产生背景2.精灵技术的本质3.精灵技术的使用4.制作精灵图三、字体图标1.字体图标优点2.字体图标使用流程3.追加新图标四、滑动门1.滑动门的背景2.核心技术3.技术实现一、用户
    

    • 

  • html5carousel图片轮播,全面解析Bootstrap中Carousel轮播的使用方法
RemusrickCat

    本文实例为大家全面的解析了Bootstrap中Carousel的使用方法，供大家参考，具体内容如下源码文件：Carousel.scssCarousel.js实现原理：隐藏所有要显示的元素，然后指定当前要显示的为block，宽、高自适应源码分析：1、Html结构：主要分为以四个部分1.1、容器：最外层div，需要一个data-ride=”carousel”来指定为轮播放插件，并且提供一个Id，方便圆
    

    • 

  • 用户投稿|Cursor——软件开发行业新变革
豆包MarsCode
人工智能python数据分析开发语言推荐算法

    本文来自AGI掘金用户投稿产品：CursorCursor是一款基于人工智能的代码编辑器，创建了一个集成开发环境（IDE）。旨在帮助开发人员编写代码，并与AI进行实时互动，提供代码建议、错误检测和自动补全功能。产品信息一览产品形态集成开发环境（IDE），支持多种编程语言（如Python、JavaScript、Java等）。Cursor团队表示，未来还会推出支持更多编程语言、增强调试功能等更新，让Cu
    

    • 

  • Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector
Colourful．
Java集合java集合

    文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List
    

    • 

  • React Native通讯原理
zbl_zbl
androidReactNativ

    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
    

    • 

  • [linux 驱动]增加一个文件节点控制led灯亮灭
嵌入式成长家
linux内核的系统实战linux驱动linux驱动led灯驱动

    目录1修改设备树2修改驱动3驱动源码3.1驱动源码3.2设备树节点3.3驱动源码分析3.3.1##解释3.3.2class_create解释3.3.3class_create_file解释3.3.4of_get_named_gpio_flags解释3.3.5devm_gpio_request解释3.3.6platform_driver_register解释3.3.7platform_driver_
    

    • 

  • 【QT教程】QT6对话框编程
QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程

    QT6对话框编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6对话框编程基础1.1QT6对话框简介1.1.1QT6对话框简介QT6对话框简介
    

    • 

  • 鸿蒙轻内核M核源码分析系列十二 事件Event
OpenHarmony_小贾
OpenHarmonyHarmonyOS鸿蒙开发harmonyosopenharmony鸿蒙内核鸿蒙开发移动开发嵌入式硬件驱动开发

    事件（Event）是一种任务间通信的机制，可用于任务间的同步。多任务环境下，任务之间往往需要同步操作，一个等待即是一个同步。事件可以提供一对多、多对多的同步操作。本文通过分析鸿蒙轻内核事件模块的源码，深入掌握事件的使用。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取
    

    • 

  • 鸿蒙轻内核M核源码分析系列四 中断Hwi
OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSharmonyos单片机OpenHarmony嵌入式硬件鸿蒙开发移动开发鸿蒙内核

    在鸿蒙轻内核源码分析系列前几篇文章中，剖析了重要的数据结构。本文，我们讲述一下中断，会给读者介绍中断的概念，鸿蒙轻内核的中断模块的源代码。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1、中断概念介绍中断是指出现需要时，CPU暂停执行当前程序，转而执行新程序的过程。当外设需要CPU时，将通过产生中断信号使CPU立即中断当前任务来响应中断请求。在剖析中断源代码之前，下面介绍些
    

    • 

  • 鸿蒙轻内核M核源码分析系列五 时间管理
OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发harmonyosopenharmony鸿蒙开发NAPI鸿蒙内核移动开发嵌入式

    在鸿蒙轻内核源码分析上一篇文章中，我们剖析了中断的源码，简单提到了Tick中断。本文会继续分析Tick和时间相关的源码，给读者介绍鸿蒙轻内核的时间管理模块。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。时间管理模块以系统时钟为基础，可以分为2部分，一部分是SysT
    

    • 

  • 鸿蒙轻内核M核源码分析系列六 任务及任务调度（1）任务栈
OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSHarmonyOSopenharmony鸿蒙开发移动开发鸿蒙内核驱动开发嵌入式硬件

    继续分析鸿蒙轻内核源码，我们本文开始要分析下任务及任务调度模块。首先，我们介绍下任务栈的基础概念。任务栈是高地址向低地址生长的递减栈，栈指针指向即将入栈的元素位置。初始化后未使用过的栈空间初始化的内容为宏OS_TASK_STACK_INIT代表的数值0xCACACACA，栈顶初始化为宏OS_TASK_MAGIC_WORD代表的数值0xCCCCCCCC。一个任务栈的示意图如下，其中，栈底指针是栈的最
    

    • 

  • 鸿蒙轻内核M核源码分析系列三 数据结构-任务排序链表
OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发数据结构harmonyos移动开发OpenHarmony鸿蒙内核鸿蒙开发嵌入式硬件

    在鸿蒙轻内核源码分析系列一和系列二，我们分析了双向循环链表、优先级就绪队列的源码。本文会继续给读者介绍鸿蒙轻内核源码中重要的数据结构：任务排序链表TaskSortLinkAttr。鸿蒙轻内核的任务排序链表，用于任务延迟到期/超时唤醒等业务场景，是一个非常重要、非常基础的数据结构。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1任务排序链表我们先看下任务排序链接的数据结构。任
    

    • 

  • 鸿蒙轻内核A核源码分析系列七 进程管理 (2)
OpenHarmony_小贾
HarmonyOS鸿蒙开发OpenHarmonyharmonyosOpenHarmony移动开发驱动开发鸿蒙内核LiteOS-A内核进程通信

    本文先熟悉下进程管理的文件kernel\base\core\los_process.c中的内部接口，读读代码，做些记录。1、LiteOS-A内核进程全局变量⑴是进程池，存放各个进程控制块LosProcessCB的信息。⑵处开始的g_freeProcess是空闲进程链表，挂载各个空闲进程控制块；g_processRecycleList是待回收进程控制块链表，挂载各个等待回收的进程控制块。⑶处开始的g
    

    • 

  • Spring的注解积累
yijiesuifeng
spring注解

    用注解来向Spring容器注册Bean。
 
需要在applicationContext.xml中注册：
<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。
如：在base-package指明一个包   
<context:component-sc
    

    • 

  • 传感器
百合不是茶
android传感器

    android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件
 
下面就以重力传感器为例;
 
1,在onCreate中获得传感器服务
 
private SensorManager sm;// 获得系统的服务
private Sensor sensor;// 创建传感器实例
@Override
protected void 
    

    • 

  • [光磁与探测]金吕玉衣的意义
comsci

          这是一个古代人的秘密:现在告诉大家
      信不信由你们:
      穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星
      这就是为什么古代
    

    • 

  • 精简的反序打印某个数
沐刃青蛟
打印

    以前看到一些让求反序打印某个数的程序。
比如：输入123，输出321。
 
记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。
 
似乎最后是用到%和/方法解决的。
 
而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）
 
代码如下：
long num, num1=0;
    

    • 

  • PHP：6种方法获取文件的扩展名
IT独行者
PHP扩展名

     
PHP：6种方法获取文件的扩展名
 
1、字符串查找和截取的方法
  1
$extension
=
substr
(
strrchr
(
$file
, 
'.'
), 1);
2、字符串查找和截取的方法二
  1
$extension
=
substr 
    

    • 

  • 面试111
文强chu
面试

     1事务隔离级别有那些 ，事务特性是什么（问到一次）
2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问）
3 struts默认提供了那些拦截器 （一次）
4 过滤器和拦截器的区别 （频率也挺高）
5 final，finally final
    

    • 

  • XML的四种解析方式
小桔子
domjdomdom4jsax

    在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。 　　预 备 　　测试环境： 　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server 
    

    • 

  • wordpress中常见的操作
aichenglong
中文注册wordpress移除菜单

    1 wordpress中使用中文名注册解决办法
  1)使用插件
  2)修改wp源代码
     进入到wp-include/formatting.php文件中找到
      function sanitize_user( $username, $strict = false 
    

    • 

  • 小飞飞学管理-1
alafqq
管理

    项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。
今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。
结合我自己经历写下心得
对于公司选拔和培养项目经理的制度有什么毛病呢？
1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。
2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。
3，公司对项目经理的工作缺乏进行指
    

    • 

  • IO输入输出部分探讨
百合不是茶
IO

    
 //文件处理  在处理文件输入输出时要引入java.IO这个包；
/*
1，运用File类对文件目录和属性进行操作
2，理解流，理解输入输出流的概念
3，使用字节/符流对文件进行读/写操作
4，了解标准的I/O
5，了解对象序列化
*/
 
//1，运用File类对文件目录和属性进行操作
 
//在工程中线创建一个text.txt
    

    • 

  • getElementById的用法
bijian1013
element

            getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。
       返回具有指定ID属性值的第一个对象的一个引用。
       语法：
&n
    

    • 

  • 励志经典语录
bijian1013
励志人生

    经典语录1:
  哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
    

    • 

  • [MongoDB学习笔记三]MongoDB分片
bit1129
mongodb

    MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。
本篇介绍MongoDB的切片(Sharding)
  1.何时需要分片
&nbs
    

    • 

  • 【Spark八十三】BlockManager在Spark中的使用场景
bit1129
manager

    1. Broadcast变量的存储，在HttpBroadcast类中可以知道
2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的
3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
    

    • 

  • yum方式部署zabbix
ronin47
yum方式部署zabbix

    安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
    

    • 

  • Hibernate4和MySQL5.5自动创建表失败问题解决方法
byalias
J2EEHibernate4

    今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤：
①创建hibernate.cfg.xml文件
②创建持久化对象
③创建*.hbm.xml映射文件
④编写hibernate相应代码
在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
    

    • 

  • Netty源码学习-FrameDecoder
bylijinnan
javanetty

    Netty 3.x的user guide里FrameDecoder的例子，有几个疑问：
1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received.
为什么每次有新数据到达时，都会调用decode方法？
2.Dec
    

    • 

  • SQL行列转换方法
chicony
行列转换

    
create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int)
insert into tb values('三星' , '0-5' , 74)
insert into tb values('三星' , '10-15' , 83)
insert into tb values('苹果' , '0-5' , 93)

    

    • 

  • 中文编码测试
ctrain
编码

    循环打印转换编码
String[] codes = {
"iso-8859-1",
"utf-8",
"gbk",
"unicode"
};
for (int i = 0; i < codes.length; i++) {
for (int j 
    

    • 

  • hive 客户端查询报堆内存溢出解决方法
daizj
hive堆内存溢出

    hive> select * from t_test where ds=20150323 limit 2;
OK
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
 
问题原因： hive堆内存默认为256M
 
这个问题的解决方法为：
修改/us
    

    • 

  • 人有多大懒，才有多大闲 (评论『卓有成效的程序员』)
dcj3sjt126com
程序员

     
卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，  懒到事情都交给机器去做 ，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。
 
在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。
不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
    

    • 

  • Eclipse简单有用的配置
dcj3sjt126com
eclipse

    1、显示行号  Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers
 
2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
    

    • 

  • 在tomcat上面安装solr4.8.0全过程
eksliang
Solrsolr4.0后的版本安装solr4.8.0安装

    转载请出自出处：
http://eksliang.iteye.com/blog/2096478
      首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了
       
第一步：当然是下载去官网上下载最新的solr版本，下载地址
    

    • 

  • Android APP通用型拒绝服务、漏洞分析报告
gg163
漏洞androidAPP分析

    点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。 
0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。 
针对序列化对象而出现的拒绝服务主要
    

    • 

  • HoverTree项目已经实现分层
hvt
编程.netWebC#ASP.ENT

    HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
    

    • 

  • Google Maps API v3: Remove Markers 移除标记
天梯梦
google maps api

    Simply do the following:
 
I. Declare a global variable:
var markersArray = [];
 
II. Define a function:
function clearOverlays() {
for (var i = 0; i < markersArray.length; i++ )
    

    • 

  • jQuery选择器总结
lq38366
jquery选择器

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
    

    • 

  • 基础数据结构和算法六：Quick sort
sunwinner
AlgorithmQuicksort

    Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
    

    • 

  • 如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作
刘星宇
htmlWeb

    今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。
让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。
方法如下：

    

    • 

  • Mybatis实用Mapper SQL汇总示例
wdmcygah
sqlmysqlmybatis实用

    Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。
不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，
    

    •