How to use

ParameterHandler

in

org.apache.ibatis.executor.parameter

  /**
   * 代入参数值
   * 
   * @param ps
   * @param mappedStatement
   * @param boundSql
   * @param parameterObject
   * @throws SQLException
   */
  private void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql,
      Object parameterObject) throws SQLException {
    ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
    parameterHandler.setParameters(ps);
  }
}

@Override
public Object plugin(Object target) {
  if (target instanceof StatementHandler) {
    StatementHandler statementHandler = (StatementHandler) target;
    MetaObject metaStatementHandler = SystemMetaObject.forObject(statementHandler);
    String sql = statementHandler.getBoundSql().getSql();
    Pager pager = Pager.getAndReset();
    String newSql = sql;
    if (sql.trim().toLowerCase().startsWith("select")) {
      if (pager != null) {
        newSql = EasyOrmSqlBuilder.getInstance()
            .getActiveDatabase().getDialect()
            .doPaging(sql, pager.pageIndex(), pager.pageSize());
      }
      Object queryEntity = statementHandler.getParameterHandler().getParameterObject();
      if (queryEntity instanceof QueryParam && ((QueryParam) queryEntity).isForUpdate()) {
        newSql = newSql + " for update";
      }
      metaStatementHandler.setValue("delegate.boundSql.sql", newSql);
    }
  }
  return Plugin.wrap(target, this);
}

PreparedStatement pstmt = null;
ResultSet rs = null;
parameterHandler.getParameterObject();
logger.debug("Preparing: {} ", countSql.toString());
logger.debug("Parameters: {} ", JSON.toJSONString(parameterObject));
  parameterHandler.setParameters(pstmt);
  rs = pstmt.executeQuery();
  if (rs.next()) {

@Override
public void parameterize(Statement statement) throws SQLException {
 parameterHandler.setParameters((PreparedStatement) statement);
}

@Override
public void handleOutputParameters(CallableStatement cs) throws SQLException {
 final Object parameterObject = parameterHandler.getParameterObject();
 final MetaObject metaParam = configuration.newMetaObject(parameterObject);
 final List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
 for (int i = 0; i < parameterMappings.size(); i++) {
  final ParameterMapping parameterMapping = parameterMappings.get(i);
  if (parameterMapping.getMode() == ParameterMode.OUT || parameterMapping.getMode() == ParameterMode.INOUT) {
   if (ResultSet.class.equals(parameterMapping.getJavaType())) {
    handleRefCursorOutputParameter((ResultSet) cs.getObject(i + 1), parameterMapping, metaParam);
   } else {
    final TypeHandler<?> typeHandler = parameterMapping.getTypeHandler();
    metaParam.setValue(parameterMapping.getProperty(), typeHandler.getResult(cs, i + 1));
   }
  }
 }
}

@Override
public void parameterize(Statement statement) throws SQLException {
 parameterHandler.setParameters((PreparedStatement) statement);
}

@Override
public void handleOutputParameters(CallableStatement cs) throws SQLException {
 final Object parameterObject = parameterHandler.getParameterObject();
 final MetaObject metaParam = configuration.newMetaObject(parameterObject);
 final List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
 for (int i = 0; i < parameterMappings.size(); i++) {
  final ParameterMapping parameterMapping = parameterMappings.get(i);
  if (parameterMapping.getMode() == ParameterMode.OUT || parameterMapping.getMode() == ParameterMode.INOUT) {
   if (ResultSet.class.equals(parameterMapping.getJavaType())) {
    handleRefCursorOutputParameter((ResultSet) cs.getObject(i + 1), parameterMapping, metaParam);
   } else {
    final TypeHandler<?> typeHandler = parameterMapping.getTypeHandler();
    metaParam.setValue(parameterMapping.getProperty(), typeHandler.getResult(cs, i + 1));
   }
  }
 }
}

@Override
public void parameterize(Statement statement) throws SQLException {
 registerOutputParameters((CallableStatement) statement);
 parameterHandler.setParameters((CallableStatement) statement);
}

public void handleOutputParameters(CallableStatement cs) throws SQLException {
 final Object parameterObject = parameterHandler.getParameterObject();
 final MetaObject metaParam = configuration.newMetaObject(parameterObject);
 final List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
 for (int i = 0; i < parameterMappings.size(); i++) {
  final ParameterMapping parameterMapping = parameterMappings.get(i);
  if (parameterMapping.getMode() == ParameterMode.OUT || parameterMapping.getMode() == ParameterMode.INOUT) {
   if ("java.sql.ResultSet".equalsIgnoreCase(parameterMapping.getJavaType().getName())) {
    handleRefCursorOutputParameter(cs, parameterMapping, i, metaParam);
   } else {
    final TypeHandler typeHandler = parameterMapping.getTypeHandler();
    if (typeHandler == null) {
     throw new ExecutorException("Type handler was null on parameter mapping for property " + parameterMapping.getProperty() + ".  " +
       "It was either not specified and/or could not be found for the javaType / jdbcType combination specified.");
    }
    metaParam.setValue(parameterMapping.getProperty(), typeHandler.getResult(cs, i + 1));
   }
  }
 }
}

@Override
public void parameterize(Statement statement) throws SQLException {
 registerOutputParameters((CallableStatement) statement);
 parameterHandler.setParameters((CallableStatement) statement);
}

@Override
public Object plugin(Object target) {
  if (target instanceof StatementHandler) {
    StatementHandler statementHandler = (StatementHandler) target;
    MetaObject metaStatementHandler = SystemMetaObject.forObject(statementHandler);
    String sql = statementHandler.getBoundSql().getSql();
    Pager pager = Pager.getAndReset();
    String newSql = sql;
    if (sql.trim().toLowerCase().startsWith("select")) {
      if (pager != null) {
        newSql = EasyOrmSqlBuilder.getInstance()
            .getActiveDatabase().getDialect()
            .doPaging(sql, pager.pageIndex(), pager.pageSize());
      }
      Object queryEntity = statementHandler.getParameterHandler().getParameterObject();
      if (queryEntity instanceof QueryParam && ((QueryParam) queryEntity).isForUpdate()) {
        newSql = newSql + " for update";
      }
      metaStatementHandler.setValue("delegate.boundSql.sql", newSql);
    }
  }
  return Plugin.wrap(target, this);
}

public int queryForInt(BoundSql boundSql) throws SQLException {
  statement = connection.prepareStatement(boundSql.getSql());
  ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, boundSql.getParameterObject(), boundSql);
  parameterHandler.setParameters(statement);
  resultSet = statement.executeQuery();
  int totalCount = 0;
  if (resultSet.next()) {
    totalCount = resultSet.getInt(1);
  }
  return totalCount;
}

private void setTotalCount(DigitalPage page, Object parameterObject, MappedStatement mappedStatement, Connection connection) {
  BoundSql boundSql = mappedStatement.getBoundSql(parameterObject);
  String sql = boundSql.getSql();
  String countSql = getTotalCountSql(sql);
  List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, parameterMappings, parameterObject);
  ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, countBoundSql);
  PreparedStatement preparedStatement = null;
  ResultSet resultSet = null;
  try {
    preparedStatement = connection.prepareStatement(countSql);
    parameterHandler.setParameters(preparedStatement);
    resultSet = preparedStatement.executeQuery();
    if (resultSet.next()) {
      int totalCount = resultSet.getInt(1);
      page.setTotalCount(totalCount);
    }
  } catch (SQLException e) {
    throw new RuntimeException(e);
  } finally {
    try {
      if (resultSet != null)
        resultSet.close();
      if (preparedStatement != null)
        preparedStatement.close();
    } catch (SQLException e) {
      throw new RuntimeException(e);
    }
  }
}

pstmt = connection.prepareStatement(countSql);
parameterHandler.setParameters(pstmt);

parameterHandler.setParameters(pstmt);
rs = pstmt.executeQuery();

public void parameterize(Statement statement)
  throws SQLException {
 KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
 ErrorContext.instance().store();
 keyGenerator.processBefore(executor, mappedStatement, statement, boundSql.getParameterObject());
 ErrorContext.instance().recall();
 rebindGeneratedKey();
 parameterHandler.setParameters((PreparedStatement) statement);
}

public void parameterize(Statement statement) throws SQLException {
 KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
 ErrorContext.instance().store();
 keyGenerator.processBefore(executor, mappedStatement, statement, boundSql.getParameterObject());
 ErrorContext.instance().recall();
 rebindGeneratedKey();
 registerOutputParameters((CallableStatement) statement);
 parameterHandler.setParameters((CallableStatement) statement);
}