Java DefaultParameterHandler类代码示例

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
/**
 * 查询总记录条数
 *
 * @param sql
 * @param mappedStatement
 * @param boundSql
 * @param page
 */
protected void queryTotal(boolean overflowCurrent, String sql, MappedStatement mappedStatement, BoundSql boundSql, Pagination page, Connection connection) {
    try (PreparedStatement statement = connection.prepareStatement(sql)) {
        DefaultParameterHandler parameterHandler = new MybatisDefaultParameterHandler(mappedStatement, boundSql.getParameterObject(), boundSql);
        parameterHandler.setParameters(statement);
        int total = 0;
        try (ResultSet resultSet = statement.executeQuery()) {
            if (resultSet.next()) {
                total = resultSet.getInt(1);
            }
        }
        page.setTotal(total);
        /*
         * 溢出总页数，设置第一页
*/
        int pages = page.getPages();
        if (overflowCurrent && (page.getCurrent() > pages)) {
            // 设置为第一条
            page.setCurrent(1);
        }
    } catch (Exception e) {
        logger.error("Error: Method queryTotal execution error !", e);
    }
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
public static int getCount(final MappedStatement ms, final Connection connection,
                           final Object parameterObject, Dialect dialect) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    String countSql = dialect.getCountString(boundSql.getSql());

    logger.debug("Total count SQL [{}]", countSql);
    logger.debug("Parameters: {} ", parameterObject);

    PreparedStatement stmt = null;
    ResultSet rs;
    try{
        stmt = connection.prepareStatement(countSql);
        DefaultParameterHandler handler = new DefaultParameterHandler(ms, parameterObject, boundSql);
        handler.setParameters(stmt);
        rs = stmt.executeQuery();

        int count = 0;
        if(rs.next()){
            count = rs.getInt(1);
        }

        return count;
    }finally {
        closeStatement(stmt);
    }
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
public Object intercept(Invocation invocation) throws Throwable {
	if (invocation.getTarget() instanceof DefaultParameterHandler) {
		DefaultParameterHandler parameterHandler = (DefaultParameterHandler) invocation
				.getTarget();

		Object paramObj = ReflectHelper
				.getValueByFieldName(parameterHandler, "parameterObject");
		if (paramObj instanceof BatchParameter) {
			// 不绑定参数，在执行阶段才绑定
			return null;
		}
	}

	return invocation.proceed();
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
protected int executeBatch(MappedStatement mappedStatement,
		BatchParameter<Object> paramObj,
		PreparedStatement ps, BoundSql boundSql,
		KeyGeneratorType keyGeneratorType) throws SQLException,
				SecurityException, NoSuchFieldException,
				IllegalArgumentException, IllegalAccessException {

	int batchSize = paramObj.getBatchSize();
	List<Object> parameterObject = paramObj.getData();
	List<Object> batchParams = new ArrayList<Object>(batchSize);

	for (Object pobject : parameterObject) {
		DefaultParameterHandler handler = new DefaultParameterHandler(
				mappedStatement, pobject, boundSql);
		handler.setParameters(ps);
		ps.addBatch();

		batchParams.add(pobject);
		if (batchParams.size() == batchSize) {
			executeBatch(mappedStatement, ps, paramObj, keyGeneratorType,
					batchParams);
			batchParams.clear();
		}
	}
	if (parameterObject.size() % batchSize != 0) {
		executeBatch(mappedStatement, ps, paramObj, keyGeneratorType,
				batchParams);
	}
	return 0;
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
/**
 * 获取总记录数
 *
 * @param sql      原始sql语句
 * @param conn
 * @param ms
 * @param boundSql
 * @return
 * @throws SQLException
 */
private int getTotalCount(String sql, Connection conn, MappedStatement ms, BoundSql boundSql) throws SQLException {
  int start = sql.indexOf("from");
  if (start == -1) {
    throw new RuntimeException("statement has no 'from' keyword");
  }
  int stop = sql.indexOf("order by");
  if (stop == -1) {
    stop = sql.length();
  }

  String countSql = "select count(0) " + sql.substring(start, stop);
  BoundSql countBoundSql = new BoundSql(ms.getConfiguration(), countSql, boundSql.getParameterMappings(), boundSql.getParameterObject());
  ParameterHandler parameterHandler = new DefaultParameterHandler(ms, boundSql.getParameterObject(), countBoundSql);
  PreparedStatement stmt = null;
  ResultSet rs = null;
  int count = 0;
  try {
    stmt = conn.prepareStatement(countSql);
    // 通过parameterHandler给PreparedStatement对象设置参数
    parameterHandler.setParameters(stmt);
    rs = stmt.executeQuery();
    if (rs.next()) {
      count = rs.getInt(1);
    }
  } finally {
    CloseableUtil.closeQuietly(rs);
    CloseableUtil.closeQuietly(stmt);
  }
  return count;
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
private List<String> getParameters(MappedStatement ms, Object parameterObject, BoundSql boundSql) throws SQLException {
    // DefaultParameterHandler is the only implementation of parameterHandler interface currently. it may be changed later.
    // need additional codes to find a appropriate implementation in that case.
    ParameterHandler parameterHandler = new DefaultParameterHandler(ms, parameterObject, boundSql);
    PreparedStatementParameterLogger parameterLogger = new PreparedStatementParameterLogger();
    parameterHandler.setParameters(parameterLogger);
    return parameterLogger.getParameters();
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
/**
 * 获取查询对象的总行数
 * @param sql  获取总行数的SQL
 * @param statementHandler
 * @param configuration
 * @param boundSql
 * @param connection
 * @throws Throwable
 */
public static void getCount(String sql, PreparedStatementHandler statementHandler,
                     Configuration configuration, BoundSql boundSql,
                     Connection connection)
        throws Throwable{
    Object parameterObject = statementHandler.getParameterHandler().getParameterObject();
    if (logger.isDebugEnabled()) {
        logger.debug("Total count SQL [{}] ", sql);
        logger.debug("Total count Parameters: {} ", parameterObject);
    }


    PreparedStatement countStmt = null;
    ResultSet rs = null;
    try {
        countStmt = connection.prepareStatement(sql);
        final BoundSql countBS = new BoundSql(configuration, sql,
                boundSql.getParameterMappings(), parameterObject);

        MappedStatement mappedStatement = (MappedStatement) FieldUtils.readField(statementHandler, MAPPED_STATEMENT, true);

        DefaultParameterHandler handler =
                new DefaultParameterHandler(mappedStatement, parameterObject, countBS);
        handler.setParameters(countStmt);

        rs = countStmt.executeQuery();
        int count = 0;
        if (rs.next()) {
            count = rs.getInt(1);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Total count: {}", count);
        }
        totalRowCountHolder.set(count);
    } finally {
        try {
            if (rs != null) {
                rs.close();
            }
        } finally {
            if (countStmt != null) {
                countStmt.close();
            }
        }
    }
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
@Override
public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
  return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
@Override
public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
@Override
 public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
   //返回默认的参数处理器
return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
 }
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
  return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
private void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql,
        Object parameterObject) throws SQLException {
    ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
    parameterHandler.setParameters(ps);
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
public Object intercept(Invocation invocation) throws Throwable {
	if (invocation.getTarget() instanceof DefaultParameterHandler) {
		DefaultParameterHandler parameterHandler = (DefaultParameterHandler) invocation
				.getTarget();

		MappedStatement mappedStatement = (MappedStatement) ReflectHelper
				.getValueByFieldName(parameterHandler, "mappedStatement");

		Object paramObj = ReflectHelper.getValueByFieldName(
				parameterHandler, "parameterObject");
		if (paramObj instanceof BatchInsertParameter) {

			PreparedStatement ps = (PreparedStatement) invocation.getArgs()[0];
			BoundSql boundSql = (BoundSql) ReflectHelper
					.getValueByFieldName(parameterHandler, "boundSql");

			@SuppressWarnings({ "unchecked", "rawtypes" })
			List<Object> parameterObject = (List) ((BatchInsertParameter) paramObj)
					.getData();

			ps.clearBatch();
			ps.clearParameters();

			@SuppressWarnings("rawtypes")
			int batchSize = ((BatchInsertParameter) paramObj)
					.getBatchSize();
			int i = 0;
			for (Object pobject : parameterObject) {
				DefaultParameterHandler handler = new DefaultParameterHandler(
						mappedStatement, pobject, boundSql);
				handler.setParameters(ps);
				ps.addBatch();
				i += 1;
				if (i % batchSize == 0) {
					ps.executeBatch();
				}
			}
			if (parameterObject.size() % batchSize != 0) {
				ps.executeBatch();
			}

			return i;
		}
	}

	return invocation.proceed();
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
/**
 * Creates a {@link ParameterHandler} that passes the actual parameters
 * to the the JDBC statement.
 *
 * @see DefaultParameterHandler
 * @param mappedStatement The mapped statement that is being executed
 * @param parameterObject The input parameter object (can be null)
 * @param boundSql The resulting SQL once the dynamic language has been executed.
 */
@Override
public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject,
    BoundSql boundSql) {
  // As default XMLLanguageDriver
  return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
}
 

import org.apache.ibatis.scripting.defaults.DefaultParameterHandler; //导入依赖的package包/类
/**
 * 代入参数值
 * 
 * @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);
}