ObjectSpace
ObjectSpace

MyBatis源码解析（二）—执行篇

前言

上一篇文章《MyBatis源码解析（一）—构造篇》提到了MyBatis是如何构建配置类的，也说了MyBatis在运行过程中主要分为两个阶段，第一是构建，第二就是执行，所以这篇文章会带大家来了解一下MyBatis是如何从构建完毕，到执行我们的第一条SQL语句的。

入口（代理对象的生成）

public static void main(String[] args) throws Exception {
    /******************************构造******************************/
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //创建SqlSessionFacory
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    /******************************分割线******************************/
    /******************************执行******************************/
    //SqlSession是帮我们操作数据库的对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //获取Mapper
    DemoMapper mapper = sqlSession.getMapper(DemoMapper.class);
    Map map = new HashMap<>();
    map.put("id","123");
    System.out.println(mapper.selectAll(map));
    sqlSession.close();
    sqlSession.commit();
  }

首先在没看源码之前希望大家可以回忆起来，我们在使用原生MyBatis的时候（不与Spring进行整合），操作SQL的只需要一个对象，那就是SqlSession对象，这个对象就是专门与数据库进行交互的。

我们在构造篇有提到，Configuration对象是在SqlSessionFactoryBuilder中的build方法中调用了XMLConfigBuilder的parse方法进行解析的，但是我们没有提到这个Configuration最终的去向。讲这个之前我们可以思考一下，这个Configuration生成之后，会在哪个环节被使用？毋庸置疑，它作为一个配置文件的整合，里面包含了数据库连接相关的信息，SQL语句相关信息等，在查询的整个流程中必不可少，而刚才我们又说过，SqlSession实际上是我们操作数据库的一个真实对象，所以可以得出这个结论：Configuration必然和SqlSession有所联系。

源码:

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      //解析config.xml(mybatis解析xml是用的  java dom)     dom4j sax...
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      //parse(): 解析config.xml里面的节点
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        inputStream.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
}

public SqlSessionFactory build(Configuration config) {
      //注入到SqlSessionFactory
    return new DefaultSqlSessionFactory(config);
}
public DefaultSqlSessionFactory(Configuration configuration) {
    this.configuration = configuration;
}

实际上我们从源码中可以看到，Configuration是SqlSessionFactory的一个属性，而SqlSessionFactoryBuilder在build方法中实际上就是调用XMLConfigBuilder对xml文件进行解析，然后注入到SqlSessionFactory中。

MyBatis源码解析（二）—执行篇_第1张图片
Configuration生成注入过程

明确了这一点我们就接着往下看。

根据主线我们现在得到了一个SqlSessionFactory对象，下一步就是要去获取SqlSession对象，这里会调用SqlSessionFactory.openSession()方法来获取，而openSession中实际上就是对SqlSession做了进一步的加工封装，包括增加了事务、执行器等。

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
        //对SqlSession对象进行进一步加工封装
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType);
        //构建SqlSession对象
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

到这里可以得出的小结论是，SqlSessionFactory对象中由于存在Configuration对象，所以它保存了全局配置信息，以及初始化环境和DataSource，而DataSource的作用就是用来开辟链接，当我们调用openSession方法时，就会开辟一个连接对象并传给SqlSession对象，交给SqlSession来对数据库做相关操作。

接着往下，现在我们获取到了一个SqlSession对象，而执行过程就是从这里开始的。

我们可以开始回忆了，平时我们使用MyBatis的时候，我们写的DAO层应该长这样：

public interface DemoMapper {
  public List>  selectAll(Map map);
}

实际上它是一个接口，而且并没有实现类，而我们却可以直接对它进行调用，如下：

 DemoMapper mapper = sqlSession.getMapper(DemoMapper.class);
 Map map = new HashMap();
 map.put("id","123");
 System.out.println(mapper.selectAll(map));

可以猜测了，MyBatis底层一定使用了动态代理，来对这个接口进行代理，我们实际上调用的是MyBatis为我们生成的代理对象。

我们在获取Mapper的时候，需要调用SqlSession的getMapper()方法，那么就从这里深入。

//getMapper方法最终会调用到这里，这个是MapperRegistry的getMapper方法
@SuppressWarnings("unchecked")
public  T getMapper(Class type, SqlSession sqlSession) {
      //MapperProxyFactory  在解析的时候会生成一个map  map中会有我们的DemoMapper的Class
    final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
}

可以看到这里mapperProxyFactory对象会从一个叫做knownMappers的对象中以type为key取出值，这个knownMappers是一个HashMap，存放了我们的DemoMapper对象，而这里的type，就是我们上面写的Mapper接口。那么就有人会问了，这个knownMappers是在什么时候生成的呢？实际上这是我上一篇漏讲的一个地方，在解析的时候，会调用parse()方法,相信大家都还记得，这个方法内部有一个bindMapperForNamespace方法，而就是这个方法帮我们完成了knownMappers的生成，并且将我们的Mapper接口put进去。

public void parse() {
      //判断文件是否之前解析过
    if (!configuration.isResourceLoaded(resource)) {
        //解析mapper文件
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      //这里：绑定Namespace里面的Class对象*
      bindMapperForNamespace();
    }

    //重新解析之前解析不了的节点
    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }
private void bindMapperForNamespace() {
    String namespace = builderAssistant.getCurrentNamespace();
    if (namespace != null) {
      Class boundType = null;
      try {
        boundType = Resources.classForName(namespace);
      } catch (ClassNotFoundException e) {
      }
      if (boundType != null) {
        if (!configuration.hasMapper(boundType)) {
          configuration.addLoadedResource("namespace:" + namespace);
            //这里将接口class传入
          configuration.addMapper(boundType);
        }
      }
    }
  }
public  void addMapper(Class type) {
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
          //这里将接口信息put进konwMappers。
        knownMappers.put(type, new MapperProxyFactory<>(type));
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
}

所以我们在getMapper之后，获取到的是一个Class，之后的代码就简单了，就是生成标准的代理类了，调用newInstance()方法。

public T newInstance(SqlSession sqlSession) {
    //首先会调用这个newInstance方法
    //动态代理逻辑在MapperProxy里面
    final MapperProxy mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    //通过这里调用下面的newInstance方法
    return newInstance(mapperProxy);
}
@SuppressWarnings("unchecked")
protected T newInstance(MapperProxy mapperProxy) {
     //jdk自带的动态代理
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

到这里，就完成了代理对象（MapperProxy）的创建，很明显的，MyBatis的底层就是对我们的接口进行代理类的实例化，从而操作数据库。

但是，我们好像就得到了一个空荡荡的对象，调用方法的逻辑呢？好像根本就没有看到，所以这也是比较考验Java功底的地方。

我们知道，一个类如果要称为代理对象，那么一定需要实现InvocationHandler接口，并且实现其中的invoke方法，进行一波推测，逻辑一定在invoke方法中。

于是就可以点进MapperProxy类，发现其的确实现了InvocationHandler接口，这里我将一些用不到的代码先删除了，只留下有用的代码，便于分析

/**
 * @author Clinton Begin
 * @author Eduardo Macarron
 */
public class MapperProxy implements InvocationHandler, Serializable {
    
  public MapperProxy(SqlSession sqlSession, Class mapperInterface, Map methodCache) {
      //构造
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }
   
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //这就是一个很标准的JDK动态代理了
    //执行的时候会调用invoke方法
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
          //判断方法所属的类
          //是不是调用的Object默认的方法
          //如果是  则不代理，不改变原先方法的行为
        return method.invoke(this, args);
      } else if (method.isDefault()) {
          //对于默认方法的处理
          //判断是否为default方法，即接口中定义的默认方法。
          //如果是接口中的默认方法则把方法绑定到代理对象中然后调用。
          //这里不详细说
        if (privateLookupInMethod == null) {
          return invokeDefaultMethodJava8(proxy, method, args);
        } else {
          return invokeDefaultMethodJava9(proxy, method, args);
        }
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    //如果不是默认方法，则真正开始执行MyBatis代理逻辑。
    //获取MapperMethod代理对象
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    //执行
    return mapperMethod.execute(sqlSession, args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
      //动态代理会有缓存，computeIfAbsent 如果缓存中有则直接从缓存中拿
      //如果缓存中没有，则new一个然后放入缓存中
      //因为动态代理是很耗资源的
    return methodCache.computeIfAbsent(method,
        k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }
}

在方法开始代理之前，首先会先判断是否调用了Object类的方法，如果是，那么MyBatis不会去改变其行为，直接返回，如果是默认方法，则绑定到代理对象中然后调用（不是本文的重点），如果都不是，那么就是我们定义的mapper接口方法了，那么就开始执行。

执行方法需要一个MapperMethod对象，这个对象是MyBatis执行方法逻辑使用的，MyBatis这里获取MapperMethod对象的方式是，首先去方法缓存中看看是否已经存在了，如果不存在则new一个然后存入缓存中，因为创建代理对象是十分消耗资源的操作。总而言之，这里会得到一个MapperMethod对象，然后通过MapperMethod的excute()方法，来真正地执行逻辑。

执行逻辑

  • 语句类型判断

    这里首先会判断SQL的类型：SELECT|DELETE|UPDATE|INSERT，我们这里举的例子是SELECT，其它的其实都差不多，感兴趣的同学可以自己去看看。判断SQL类型为SELECT之后，就开始判断返回值类型，根据不同的情况做不同的操作。然后开始获取参数--》执行SQL。

    //execute() 这里是真正执行SQL的地方
public Object execute(SqlSession sqlSession, Object[] args) {
  //判断是哪一种SQL语句
    Object result;
    switch (command.getType()) {
      case INSERT: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));
        break;
      }
      case UPDATE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.update(command.getName(), param));
        break;
      }
      case DELETE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.delete(command.getName(), param));
        break;
      }
      case SELECT:
          //我们的例子是查询
            
        //判断是否有返回值
        if (method.returnsVoid() && method.hasResultHandler()) {
          //无返回值
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          //返回值多行 这里调用这个方法
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          //返回Map
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          //返回Cursor
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
          if (method.returnsOptional()
              && (result == null || !method.getReturnType().equals(result.getClass()))) {
            result = Optional.ofNullable(result);
          }
        }
        break;
      case FLUSH:
        result = sqlSession.flushStatements();
        break;
      default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      throw new BindingException("Mapper method '" + command.getName()
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
}

//返回值多行 这里调用这个方法
private  Object executeForMany(SqlSession sqlSession, Object[] args) {
  //返回值多行时执行的方法
    List result;
    //param是我们传入的参数，如果传入的是Map，那么这个实际上就是Map对象
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      //如果有分页
      RowBounds rowBounds = method.extractRowBounds(args);
        //执行SQL的位置
      result = sqlSession.selectList(command.getName(), param, rowBounds);
    } else {
      //如果没有
        //执行SQL的位置
      result = sqlSession.selectList(command.getName(), param);
    }
    // issue #510 Collections & arrays support
    if (!method.getReturnType().isAssignableFrom(result.getClass())) {
      if (method.getReturnType().isArray()) {
        return convertToArray(result);
      } else {
        return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
      }
    }
    return result;
}

/**
*  获取参数名的方法
*/
public Object getNamedParams(Object[] args) {
    final int paramCount = names.size();
    if (args == null || paramCount == 0) {
      //如果传过来的参数是空
      return null;
    } else if (!hasParamAnnotation && paramCount == 1) {
      //如果参数上没有加注解例如@Param，且参数只有一个，则直接返回参数
      return args[names.firstKey()];
    } else {
      //如果参数上加了注解，或者参数有多个。
          //那么MyBatis会封装参数为一个Map，但是要注意，由于jdk的原因，我们只能获取到参数下标和参数名，但是参数名会变成arg0,arg1.
      //所以传入多个参数的时候，最好加@Param，否则假设传入多个String，会造成#{}获取不到值的情况
      final Map param = new ParamMap<>();
      int i = 0;
      for (Map.Entry entry : names.entrySet()) {
        //entry.getValue 就是参数名称
        param.put(entry.getValue(), args[entry.getKey()]);
        //如果传很多个String，也可以使用param1，param2.。。
        // add generic param names (param1, param2, ...)
        final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
        // ensure not to overwrite parameter named with @Param
        if (!names.containsValue(genericParamName)) {
          param.put(genericParamName, args[entry.getKey()]);
        }
        i++;
      }
      return param;
    }
  }

  • SQL执行（二级缓存）

    执行SQL的核心方法就是selectList，即使是selectOne，底层实际上也是调用了selectList方法，然后取第一个而已。

    @Override
public  List selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      //MappedStatement:解析XML时生成的对象， 解析某一个SQL  会封装成MappedStatement，里面存放了我们所有执行SQL所需要的信息
      MappedStatement ms = configuration.getMappedStatement(statement);
      //查询,通过executor
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
}

    在这里我们又看到了上一篇构造的时候提到的，MappedStatement对象，这个对象是解析Mapper.xml配置而产生的，用于存储SQL信息，执行SQL需要这个对象中保存的关于SQL的信息，而selectList内部调用了Executor对象执行SQL语句，这个对象作为MyBatis四大对象之一，一会会说。

    public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //获取sql语句
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    //生成一个缓存的key  
    //这里是-1181735286:4652640444:com.DemoMapper.selectAll:0:2147483647:select * from test WHERE id =?:2121:development
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

@Override
//二级缓存查询
public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    //二级缓存的Cache
    Cache cache = ms.getCache();
    if (cache != null) {
      //如果Cache不为空则进入
      //如果有需要的话，就刷新缓存（有些缓存是定时刷新的，需要用到这个）
      flushCacheIfRequired(ms);
      //如果这个statement用到了缓存（二级缓存的作用域是namespace，也可以理解为这里的ms）
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        //先从缓存拿
        List list = (List) tcm.getObject(cache, key);
        if (list == null) {
          //如果缓存的数据等于空，那么查询数据库
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          //查询完毕后将数据放入二级缓存
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        //返回
        return list;
      }
    }
    //如果cache根本就不存在，那么直接查询一级缓存
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

    首先MyBatis在查询时，不会直接查询数据库，而是会进行二级缓存的查询，由于二级缓存的作用域是namespace，也可以理解为一个mapper，所以还会判断一下这个mapper是否开启了二级缓存，如果没有开启，则进入一级缓存继续查询。

  • SQL查询（一级缓存）

    //一级缓存查询
@Override
public  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List list;
    try {
       //查询栈+1
      queryStack++;
      //一级缓存
      list = resultHandler == null ? (List) localCache.getObject(key) : null;
      if (list != null) {
        //对于存储过程有输出资源的处理
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        //如果缓存为空，则从数据库拿
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
       //查询栈-1
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    //结果返回
    return list;
}

    如果一级缓存查到了，那么直接就返回结果了，如果一级缓存没有查到结果，那么最终会进入数据库进行查询。

  • SQL执行（数据库查询）

    //数据库查询
private  List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List list;
    //先往一级缓存中put一个占位符
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      //调用doQuery方法查询数据库
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    //往缓存中put真实数据
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
}
//真实数据库查询
@Override
public  List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      //封装，StatementHandler也是MyBatis四大对象之一
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      //#{} -> ? 的SQL在这里初始化
      stmt = prepareStatement(handler, ms.getStatementLog());
      //参数赋值完毕之后，才会真正地查询。
      return handler.query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
}

    在真正的数据库查询之前，我们的语句还是这样的：select * from test where id = ?，所以要先将占位符换成真实的参数值，所以接下来会进行参数的赋值。

    • 参数赋值

      因为MyBatis底层封装的就是java最基本的jdbc，所以赋值一定也是调用jdbc的putString()方法。

      /********************************参数赋值部分*******************************/
//由于是#{}，所以使用的是prepareStatement，预编译SQL
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    //拿连接对象
    Connection connection = getConnection(statementLog);
    //初始化prepareStatement
    stmt = handler.prepare(connection, transaction.getTimeout());
    //获取了PrepareStatement之后，这里给#{}赋值
    handler.parameterize(stmt);
    return stmt;
}

/**
* 预编译SQL进行put值
*/
@Override
public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    //参数列表
    List parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
      for (int i = 0; i < parameterMappings.size(); i++) {
        ParameterMapping parameterMapping = parameterMappings.get(i);
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          Object value;
          //拿到xml中#{}   参数的名字  例如 #{id}  propertyName==id
          String propertyName = parameterMapping.getProperty();
          if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
            value = boundSql.getAdditionalParameter(propertyName);
          } else if (parameterObject == null) {
            value = null;
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            value = parameterObject;
          } else {
              //metaObject存储了参数名和参数值的对应关系
            MetaObject metaObject = configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }
          TypeHandler typeHandler = parameterMapping.getTypeHandler();
          JdbcType jdbcType = parameterMapping.getJdbcType();
          if (value == null && jdbcType == null) {
            jdbcType = configuration.getJdbcTypeForNull();
          }
          try {
            //在这里给preparedStatement赋值，通过typeHandler，setParameter最终会调用一个叫做setNonNullParameter的方法。代码贴在下面了。
            typeHandler.setParameter(ps, i + 1, value, jdbcType);
          } catch (TypeException | SQLException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
          }
        }
      }
    }
}
//jdbc赋值
public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType)
      throws SQLException {
    //这里就是最最原生的jdbc的赋值了
    ps.setString(i, parameter);
}
/********************************参数赋值部分*******************************/

    • 正式执行

      当参数赋值完毕后，SQL就可以执行了，在上文中的代码可以看到当参数赋值完毕后，直接通过hanler.query()方法进行数据库查询。

       @Override
public  List query(Statement statement, ResultHandler resultHandler) throws SQLException {
    //通过jdbc进行数据库查询。
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    //处理结果集 resultSetHandler 也是MyBatis的四大对象之一
    return resultSetHandler.handleResultSets(ps);
}

      可以很明显看到，这里实际上也就是调用我们熟悉的原生jdbc对数据库进行查询。

  • 执行阶段总结

    到这里，MyBatis的执行阶段从宏观角度看，一共完成了两件事：

    1. 代理对象的生成
    2. SQL的执行

    而SQL的执行用了大量的篇幅来进行分析，虽然是根据一条查询语句的主线来进行分析的，但是这么看下来一定很乱，所以这里我会话一个流程图来帮助大家理解：

    MyBatis源码解析（二）—执行篇_第2张图片
    执行阶段流程图

  • 结果集处理

    在SQL执行阶段，MyBatis已经完成了对数据的查询，那么现在还存在最后一个问题，那就是结果集处理，换句话来说，就是将结果集封装成对象。在不用框架的时候我们是使用循环获取结果集，然后通过getXXXX()方法一列一列地获取，这种方法劳动强度太大，看看MyBatis是如何解决的。

     @Override
public List handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
  //resultMap可以通过多个标签指定多个值，所以存在多个结果集
    final List multipleResults = new ArrayList<>();

    int resultSetCount = 0;
    //拿到当前第一个结果集
    ResultSetWrapper rsw = getFirstResultSet(stmt);

    //拿到所有的resultMap
    List resultMaps = mappedStatement.getResultMaps();
    //resultMap的数量
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    //循环处理每一个结果集
    while (rsw != null && resultMapCount > resultSetCount) {
      //开始封装结果集 list.get(index) 获取结果集
      ResultMap resultMap = resultMaps.get(resultSetCount);
      //传入resultMap处理结果集 rsw 当前结果集（主线）
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

    String[] resultSets = mappedStatement.getResultSets();
    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);
}
//处理结果集
private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List multipleResults, ResultMapping parentMapping) throws SQLException {
   //处理结果集
    try {
      if (parentMapping != null) {
        handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
      } else {
        if (resultHandler == null) {
          //判断resultHandler是否为空，如果为空建立一个默认的。
          //结果集处理器
          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
          //处理行数据
          handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
          multipleResults.add(defaultResultHandler.getResultList());
        } else {
          handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
        }
      }
    } finally {
      // issue #228 (close resultsets)
      //关闭结果集
      closeResultSet(rsw.getResultSet());
    }
}
 
    上文的代码，会创建一个处理结果集的对象，最终调用handleRwoValues()方法进行行数据的处理。
     
    //处理行数据
public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    //是否存在内嵌的结果集
    if (resultMap.hasNestedResultMaps()) {
      ensureNoRowBounds();
      checkResultHandler();
      handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
      //不存在内嵌的结果集
      handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
}
//没有内嵌结果集时调用
private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
      throws SQLException {
    DefaultResultContext resultContext = new DefaultResultContext<>();
    //获取当前结果集
    ResultSet resultSet = rsw.getResultSet();
    skipRows(resultSet, rowBounds);
    while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
      //遍历结果集
      ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
      //拿到行数据，将行数据包装成一个Object
      Object rowValue = getRowValue(rsw, discriminatedResultMap, null);
      storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
    }
}
 
    这里的代码主要是通过每行的结果集，然后将其直接封装成一个Object对象，那么关键就是在于getRowValue()方法，如何让行数据变为Object对象的。
     
    private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
  //创建一个空的Map存值
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    //创建一个空对象装行数据
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())){
      //通过反射操作返回值
        //此时metaObject.originalObject = rowValue
      final MetaObject metaObject = configuration.newMetaObject(rowValue);
      boolean foundValues = this.useConstructorMappings;
      if (shouldApplyAutomaticMappings(resultMap, false)) {
    //判断是否需要自动映射，默认自动映射，也可以通过resultMap节点上的autoMapping配置是否自动映射
          //这里是自动映射的操作。
        foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
      }
      foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
      foundValues = lazyLoader.size() > 0 || foundValues;
      rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
    }
    return rowValue;
}

     
    在getRowValue中会判断是否是自动映射的，我们这里没有使用ResultMap，所以是自动映射（默认），那么就进入applyAutomaticMappings()方法，而这个方法就会完成对象的封装。
     
      private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
    //自动映射参数列表
    List autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
      //是否找到了该列
    boolean foundValues = false;
    if (!autoMapping.isEmpty()) {
      //遍历
      for (UnMappedColumnAutoMapping mapping : autoMapping) {
        //通过列名获取值
        final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
        if (value != null) {
          //如果值不为空，说明找到了该列
          foundValues = true;
        }
        if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
          // gcode issue #377, call setter on nulls (value is not 'found')
          //在这里赋值
          metaObject.setValue(mapping.property, value);
        }
      }
    }
    return foundValues;
}

     
    我们可以看到这个方法会通过遍历参数列表从而通过metaObject.setValue(mapping.property, value);对返回对象进行赋值，但是返回对象有可能是Map，有可能是我们自定义的对象，会有什么区别呢？
     
    实际上，所有的赋值操作在内部都是通过一个叫ObjectWrapper的对象完成的，我们可以进去看看它对于Map和自定义对象赋值的实现有什么区别，问题就迎刃而解了。
     
    先看看上文中代码的metaObject.setValue()方法
     
    public void setValue(String name, Object value) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
      if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
        if (value == null) {
          // don't instantiate child path if value is null
          return;
        } else {
          metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
        }
      }
      metaValue.setValue(prop.getChildren(), value);
    } else {
        //这个方法最终会调用objectWrapper.set()对结果进行赋值
      objectWrapper.set(prop, value);
    }
}

     
    我们可以看看objectWrapper的实现类：
     
   
     
    
     
     
     
      MyBatis源码解析（二）—执行篇_第3张图片 
     
     
    
     
    
    
      objectWrapper的实现类 
    
     
   
     
    而我们今天举的例子，DemoMapper的返回值是Map，所以objectWrapper会调用MapWrapper的set方法，如果是自定义类型，那么就会调用BeanWrapper的set方法，下面看看两个类中的set方法有什么区别:
     
    //MapWrapper的set方法
public void set(PropertyTokenizer prop, Object value) {
    if (prop.getIndex() != null) {
      Object collection = resolveCollection(prop, map);
      setCollectionValue(prop, collection, value);
    } else {
      //实际上就是调用了Map的put方法将属性名和属性值放入map中
      map.put(prop.getName(), value);
    }
}

//BeanWrapper的set方法
public void set(PropertyTokenizer prop, Object value) {
    if (prop.getIndex() != null) {
      Object collection = resolveCollection(prop, object);
      setCollectionValue(prop, collection, value);
    } else {
      //在这里赋值，通过反射赋值，调用setXX()方法赋值
      setBeanProperty(prop, object, value);
    }
}
private void setBeanProperty(PropertyTokenizer prop, Object object, Object value) {
    try {
      Invoker method = metaClass.getSetInvoker(prop.getName());
      Object[] params = {value};
      try {
        method.invoke(object, params);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    } catch (Throwable t) {
      throw new ReflectionException("Could not set property '" + prop.getName() + "' of '" + object.getClass() + "' with value '" + value + "' Cause: " + t.toString(), t);
    }
}

     
    上面两个set方法分别是MapWrapper和BeanWrapper的不同实现，MapWrapper的set方法实际上就是将属性名和属性值放到map的key和value中，而BeanWrapper则是使用了反射，调用了Bean的set方法，将值注入。
     
   
     
    
     
     
     
      MyBatis源码解析（二）—执行篇_第4张图片 
     
     
    
     
    
    
      反射注入 
    
     
   
      
  
 
    结语
     
 
    至此，MyBatis的执行流程就为止了，本篇主要聊了从构建配置对象后，MyBatis是如何执行一条查询语句的，一级查询语句结束后是如何进行对结果集进行处理，映射为我们定义的数据类型的。
     
 
    由于是源码分析文章，所以如果只是粗略的看，会显得有些乱，所以我还是再提供一张流程图，会比较好理解一些。
     
 
     
  
     
   
     
    MyBatis源码解析（二）—执行篇_第5张图片 
   
     
  
     
  
    
    执行过程完整流程图 
  
     
 
     
 
    当然这张流程图里并没有涉及到关于回写缓存的内容，关于MyBatis的一级缓存、二级缓存相关的内容，我会在第三篇源码解析中阐述。
     
 
    欢迎大家访问我的个人博客：Object's Blog
     

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(MyBatis源码解析（二）—执行篇)
    
        
    
            
    
                
      
                    
    • 情绪觉察日记第37天
                        露露_e800

                        
      今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
      
                    
      • 
                    
    • 一百九十四章. 自相矛盾
                        巨木擎天

                        
      唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
      
                    
      • 
                    
    • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
      本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
      
                    
      • 
                    
    • C语言宏函数
                        南林yan
C语言c语言
                        
      一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
      • 
                    
    • 谢谢你们，爱你们！
                        鹿游儿

                        
      昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
      
                    
      • 
                    
    • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
      在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
      
                    
      • 
                    
    • 爬山后遗症
                        璃绛

                        
      爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
      
                    
      • 
                    
    • 《策划经理回忆录之二》
                        路基雅虎

                        
      话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
      
                    
      • 
                    
    • 那个抄袭的大张伟
                        猫小努

                        
      最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
      
                    
      • 
                    
    • 《大清方方案》| 第二话
                        谁佐清欢

                        
      和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
      
                    
      • 
                    
    • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
      提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
      
                    
      • 
                    
    • 本周第二次约练
                        2cfbdfe28a51

                        
      中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
      
                    
      • 
                    
    • 2022-07-08
                        保利学府里李楚怡1307022

                        
      ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
      
                    
      • 
                    
    • 直抒《紫罗兰永恒花园外传》
                        雷姆的黑色童话

                        
      没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
      
                    
      • 
                    
    • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
      智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
      
                    
      • 
                    
    • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
                        成长时间线

                        
      7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
      
                    
      • 
                    
    • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
      随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
      
                    
      • 
                    
    • 如果做到轻松在股市赚钱？只要坚持这三个原则。
                        履霜之人

                        
      大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
      
                    
      • 
                    
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      
                    
      • 
                    
    • 特殊的拜年
                        飘雪的天堂

                        
      文/雪儿大年初一，家家户户没有了轰响的鞭炮声，大街上没有了人流涌动的喧闹，几乎看不到人影，变得冷冷清清。天刚亮不大会儿，村里的大喇叭响了起来：由于当前正值疾病高发期，流感流行的高峰期。同时，新型冠状病毒感染的肺炎进入第二波流行的上升期。为了自己和他人的健康安全着想，请大家尽量不要串门拜年，不要在街里走动。可以通过手机微信，视频，电话，信息拜年……今年的春节真是特别。禁止燃放鞭炮，烟花爆竹，禁止出村
      
                    
      • 
                    
    • 高端密码学院笔记285
                        柚子_b4b4

                        
      高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
      
                    
      • 
                    
    • 398顺境，逆境
                        戴骁勇

                        
      2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
      
                    
      • 
                    
    • 利用Requests Toolkit轻松完成HTTP请求
                        nseejrukjhad
http网络协议网络python
                        
      RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
      
                    
      • 
                    
    • 想明白这个问题，你才能写下去
                        文自拾

                        
      春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
      
                    
      • 
                    
    • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
      大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
      
                    
      • 
                    
    • 【JS】执行时长(100分) |思路参考+代码解析（C++）
                        l939035548
JS算法数据结构c++
                        
      题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
      
                    
      • 
                    
    • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
      随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
      
                    
      • 
                    
    • 其二
                        十八尾喵

                        
      你知道吗？图片发自App我今天知道了你有喜欢的人，不是我。心空空的，整个人都不是我的了。可，怎么办？还是要好好的活着，毕竟你喜欢的人，我不能杀，可是我可以杀其他喜欢你的人呀！也罢，此生无缘，来世再见。鱼干
      
                    
      • 
                    
    • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集
                        高省APP珊珊

                        
      这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
      
                    
      • 
                    
    • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
      在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
      
                    
      • 
                                
    • ztree设置禁用节点
                                    3213213333332132
JavaScriptztreejsonsetDisabledNodeAjax
                                    
      ztree设置禁用节点的时候注意，当使用ajax后台请求数据,必须要设置为同步获取数据，否者会获取不到节点对象，导致设置禁用没有效果。 
 
 
$(function(){            	
                showTree();
	            setDisabledNode();

});
                   
        
      
                                
      • 
                                
    • JVM patch by Taobao
                                    bookjovi
javaHotSpot
                                    
      在网上无意中看到淘宝提交的hotspot patch，共四个，有意思，记录一下。 
  
7050685：jsdbproc64.sh has a typo in the package name 
7058036：FieldsAllocationStyle=2 does not work in 32-bit VM 
7060619：C1 should respect inline and
      
                                
      • 
                                
    • 将session存储到数据库中
                                    dcj3sjt126com
sqlPHPsession
                                    
      CREATE TABLE sessions (
  id CHAR(32) NOT NULL,
  data TEXT,
  last_accessed TIMESTAMP NOT NULL,
  PRIMARY KEY (id)
); 
  
<?php
/**
 * Created by PhpStorm.
 * User: michaeldu
 * Date
      
                                
      • 
                                
    • Vector
                                    171815164
vector
                                    
      public Vector<CartProduct> delCart(Vector<CartProduct> cart, String id) {
		for (int i = 0; i < cart.size(); i++) {
			if (cart.get(i).getId().equals(id)) {
				cart.remove(i);
				
      
                                
      • 
                                
    • 各连接池配置参数比较
                                    g21121
连接池
                                    
              排版真心费劲，大家凑合看下吧，见谅~ 
      
  
Druid 
DBCP 
C3P0 
Proxool   
数据库用户名称 Username Username User     
数据库密码 Password Password Password     
驱动名
      
                                
      • 
                                
    • [简单]mybatis insert语句添加动态字段
                                    53873039oycg
mybatis
                                    
            mysql数据库,id自增,配置如下： 
      
<insert id="saveTestTb" useGeneratedKeys="true" keyProperty="id"
		parameterType=&
      
                                
      • 
                                
    • struts2拦截器配置
                                    云端月影
struts2拦截器
                                    
      struts2拦截器interceptor的三种配置方法 
方法1. 普通配置法 
 
<struts> 
    <package name="struts2" extends="struts-default"> 
        &
      
                                
      • 
                                
    • IE中页面不居中，火狐谷歌等正常
                                    aijuans
IE中页面不居中
                                    
      问题是首页在火狐、谷歌、所有IE中正常显示，列表页的页面在火狐谷歌中正常，在IE6、7、8中都不中，觉得可能那个地方设置的让IE系列都不认识，仔细查看后发现，列表页中没写HTML模板部分没有添加DTD定义，就是<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3
      
                                
      • 
                                
    • String,int,Integer,char 几个类型常见转换
                                    antonyup_2006
htmlsql.net
                                    
      如何将字串 String 转换成整数 int? 
int i = Integer.valueOf(my_str).intValue(); 
 
int i=Integer.parseInt(str); 
 
如何将字串 String 转换成Integer ? 
Integer integer=Integer.valueOf(str); 
 
如何将整数 int 转换成字串 String ? 
1.
      
                                
      • 
                                
    • PL/SQL的游标类型
                                    百合不是茶
显示游标(静态游标)隐式游标游标的更新和删除%rowtyperef游标(动态游标)
                                    
      游标是oracle中的一个结果集,用于存放查询的结果; 
  
PL/SQL中游标的声明; 
1,声明游标

2,打开游标(默认是关闭的);

3,提取数据

4,关闭游标
 
  
  
注意的要点:游标必须声明在declare中,使用open打开游标,fetch取游标中的数据,close关闭游标 
  
隐式游标:主要是对DML数据的操作隐
      
                                
      • 
                                
    • JUnit4中@AfterClass @BeforeClass @after @before的区别对比
                                    bijian1013
JUnit4单元测试
                                    
      一.基础知识 
JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation： @Before：初始化方法   对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）@After：释放资源  对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次
      
                                
      • 
                                
    • 精通Oracle10编程SQL(12)开发包
                                    bijian1013
oracle数据库plsql
                                    
      /*
 *开发包
 *包用于逻辑组合相关的PL/SQL类型（例如TABLE类型和RECORD类型）、PL/SQL项（例如游标和游标变量）和PL/SQL子程序（例如过程和函数）
 */
--包用于逻辑组合相关的PL/SQL类型、项和子程序，它由包规范和包体两部分组成
--建立包规范：包规范实际是包与应用程序之间的接口，它用于定义包的公用组件，包括常量、变量、游标、过程和函数等
--在包规
      
                                
      • 
                                
    • 【EhCache二】ehcache.xml配置详解
                                    bit1129
ehcache.xml
                                    
      在ehcache官网上找了多次，终于找到ehcache.xml配置元素和属性的含义说明文档了，这个文档包含在ehcache.xml的注释中！ 
ehcache.xml ： http://ehcache.org/ehcache.xml 
ehcache.xsd ： http://ehcache.org/ehcache.xsd 
ehcache配置文件的根元素是ehcahe 
  ehcac
      
                                
      • 
                                
    • java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL
                                    白糖_
javaeclipsespringtomcatWeb
                                    
      今天学习spring+cxf的时候遇到一个问题：在web.xml中配置了spring的上下文监听器： 
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> 
 随后启动
      
                                
      • 
                                
    • angular.element
                                    boyitech
AngularJSAngularJS APIangular.element
                                    
      angular.element 
描述:      包裹着一部分DOM element或者是HTML字符串，把它作为一个jQuery元素来处理。（类似于jQuery的选择器啦）       如果jQuery被引入了，则angular.element就可以看作是jQuery选择器，选择的对象可以使用jQuery的函数；如果jQuery不可用，angular.e
      
                                
      • 
                                
    • java-给定两个已排序序列，找出共同的元素。
                                    bylijinnan
java
                                    
      
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class CommonItemInTwoSortedArray {

	/**
	 * 题目：给定两个已排序序列，找出共同的元素。
	 * 1.定义两个指针分别指向序列的开始。
	 * 如果指向的两个元素
      
                                
      • 
                                
    • sftp 异常，有遇到的吗？求解
                                    Chen.H
javajcraftauthjschjschexception
                                    
      com.jcraft.jsch.JSchException: Auth cancel 
 at com.jcraft.jsch.Session.connect(Session.java:460) 
 at com.jcraft.jsch.Session.connect(Session.java:154) 
 at cn.vivame.util.ftp.SftpServerAccess.connec
      
                                
      • 
                                
    • [生物智能与人工智能]神经元中的电化学结构代表什么?
                                    comsci
人工智能
                                    
           我这里做一个大胆的猜想,生物神经网络中的神经元中包含着一些化学和类似电路的结构,这些结构通常用来扮演类似我们在拓扑分析系统中的节点嵌入方程一样,使得我们的神经网络产生智能判断的能力,而这些嵌入到节点中的方程同时也扮演着"经验"的角色.... 
 
     我们可以尝试一下...在某些神经
      
                                
      • 
                                
    • 通过LAC和CID获取经纬度信息
                                    dai_lm
laccid
                                    
      方法1： 
用浏览器打开http://www.minigps.net/cellsearch.html，然后输入lac和cid信息(mcc和mnc可以填0)，如果数据正确就可以获得相应的经纬度 
 
方法2： 
发送HTTP请求到http://www.open-electronics.org/celltrack/cell.php?hex=0&lac=<lac>&cid=&
      
                                
      • 
                                
    • JAVA的困难分析
                                    datamachine
java
                                    
      前段时间转了一篇SQL的文章（http://datamachine.iteye.com/blog/1971896），文章不复杂，但思想深刻，就顺便思考了一下java的不足，当砖头丢出来，希望引点和田玉。 
  
-----------------------------------------------------------------------------------------
      
                                
      • 
                                
    • 小学5年级英语单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
      money 钱 
paper 纸 
speak 讲，说 
tell 告诉 
  
remember 记得，想起 
knock 敲，击，打 
question 问题 
number 数字，号码 
  
learn 学会，学习 
street 街道 
carry 搬运，携带 
send 发送，邮寄，发射 
  
must 必须 
light 灯，光线，轻的 
front 
      
                                
      • 
                                
    • linux下面没有tree命令
                                    dcj3sjt126com
linux
                                    
      centos p安装 
yum -y install tree 
  
mac os安装 
brew install tree 
  首先来看tree的用法  
tree  中文解释：tree
功能说明：以树状图列出目录的内容。
语　　法：tree [-aACdDfFgilnNpqstux][-I <范本样式>][-P <范本样式
      
                                
      • 
                                
    • Map迭代方式，Map迭代，Map循环
                                    蕃薯耀
Map循环Map迭代Map迭代方式
                                    
      Map迭代方式，Map迭代，Map循环 
  
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年
      
                                
      • 
                                
    • Spring Cache注解+Redis
                                    hanqunfeng
spring
                                    
      Spring3.1 Cache注解  
依赖jar包： 
<!-- redis -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			
      
                                
      • 
                                
    • Guava中针对集合的 filter和过滤功能
                                    jackyrong
filter
                                    
      在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子： 
 
   

@Test
public void whenFilterWithIterables_thenFiltered() {
    List<String> names = Lists.newArrayList("John"
      
                                
      • 
                                
    • 学习编程那点事
                                    lampcy
编程androidPHPhtml5
                                    
      一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
      
                                
      • 
                                
    • 架构师之流处理---------bytebuffer的mark,limit和flip
                                    nannan408
ByteBuffer
                                    
      1.前言。 
  如题，limit其实就是可以读取的字节长度的意思，flip是清空的意思，mark是标记的意思 。 
2.例子. 
 

例子代码:
     String str = "helloWorld";  
        ByteBuffer buff  = ByteBuffer.wrap(str.getBytes());  
        Sy
      
                                
      • 
                                
    • org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, column 1
                                    Everyday都不同
$转义el表达式
                                    
      最近在做Highcharts的过程中，在写js时，出现了以下异常： 
  
严重: Servlet.service() for servlet jsp threw exception 
org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, 
      
                                
      • 
                                
    • 用Java实现发送邮件到163
                                    tntxia
java实现
                                    
      /*

 在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。

 本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。

 此篇仅介绍用
      
                                
      • 
                                
    • 探索实体类存在的真正意义
                                    java小叶檀
POJO
                                    
      一. 实体类简述   
 实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口，在程序中仅作为数据容器用来持久化存储数据用的 
POJO（Plain Old Java Objects）简单的Java对象 
  
它的一般格式就是 
public class A{
      private String id;
      public Str
      
                                
      •