import org.springframework.jdbc.core.ArgumentPreparedStatementSetter; //导入依赖的package包/类
@Override
public String toString() {
  if (prepared() && statementSetter instanceof ArgumentPreparedStatementSetter) {
    return String.format("sql: %s, args: %s", sql, Arrays.toString(args));
  } else if (prepared() && statementSetter instanceof ArgumentTypePreparedStatementSetter) {
    return String.format("sql: %s, args: %s, argTypes: %s", sql, Arrays.toString(args),
        Arrays.toString(argTypes));
  }
  return "sql: " + sql;
}
 

import org.springframework.jdbc.core.ArgumentPreparedStatementSetter; //导入依赖的package包/类
@Override
public long insert(String sql,Object... args) {
    logger.debug("Insert sql : \n" + sql);
    logger.debug("Paramters : \n" + ArrayUtils.toString(args));
    try {
        KeyHolder keyHolder = new GeneratedKeyHolder();
        final String sqlStr = sql;
        final Object[] argsArr = args;
        this.ownJdbcTemplate.getJdbcOperations().update(new PreparedStatementCreator() {
            @Override
            public PreparedStatement createPreparedStatement(Connection con)
                    throws SQLException {
                PreparedStatement ps = con.prepareStatement(sqlStr,Statement.RETURN_GENERATED_KEYS);
                if(argsArr != null && argsArr.length > 0){
                    PreparedStatementSetter argSetter = new ArgumentPreparedStatementSetter(argsArr);
                    if(argSetter != null){
                        argSetter.setValues(ps);
                    }
                }
                return ps;
            }
        }, keyHolder);
        if(keyHolder.getKey() == null) {
            return -1;
        }
        return keyHolder.getKey().longValue();
    } catch (DataAccessException ex) {
        logger.error(ex.getMessage(), ex);
        throw ex;
    }
}
 

import org.springframework.jdbc.core.ArgumentPreparedStatementSetter; //导入依赖的package包/类
private int executeInTransaction(final List<String> queries, final List<Object[]> args) {
	return jdbcTemplate.execute(new ConnectionCallback<Integer>() {
		@Override
		public Integer doInConnection(Connection connection) throws SQLException, DataAccessException {
			w.lock();
			try {
				connection.setAutoCommit(false);
				int ret = 0;
				// connection.createStatement().execute("begin transaction");
				for (int i = 0; i < queries.size(); i++) {
					if (args.get(i) == null) {
						ret += connection.createStatement().executeUpdate(queries.get(i));
					} else {
						PreparedStatement ps = connection.prepareStatement(queries.get(i));
						PreparedStatementSetter pssetter = new ArgumentPreparedStatementSetter(args.get(i));
						pssetter.setValues(ps);
						ret += ps.executeUpdate();
					}
				}
				connection.commit();
				// connection.createStatement().execute("commit transaction");
				return ret;
			} catch (Exception ex) {
				LOG.error("Error executing transaction. Details:");
				for (int i = 0; i < queries.size(); i++) {
					LOG.error("Query '" + queries.get(i) + "' args '" + Arrays.toString(args.get(i)) + "' ");
				}
				throw new RuntimeException(ex);
			} finally {
				try {
					connection.setAutoCommit(true);
				} catch (Throwable e) {
					throw new RuntimeException(e);
				}
				w.unlock();
			}
		}

	});
}
 

import org.springframework.jdbc.core.ArgumentPreparedStatementSetter; //导入依赖的package包/类
@Override
public void populateStatement(PreparedStatement ps, Iterator<?> iterator, int expectedParams) throws SQLException {
    if (expectedParams <= 0) {
        return;
    }

    final Object[] args = new Object[expectedParams];
    int i = 0;
    int argNumber = 1;

    while (iterator != null && iterator.hasNext()) {
        Object value = iterator.next();

        // special for SQL IN where we need to set dynamic number of values
        if (value instanceof CompositeIterator) {
            Iterator it = (Iterator) value;
            while (it.hasNext()) {
                Object val = it.next();
                LOG.trace("Setting parameter #{} with value: {}", argNumber, val);
                if (argNumber <= expectedParams) {
                    args[i] = val;
                }
                argNumber++;
                i++;
            }
        } else {
            LOG.trace("Setting parameter #{} with value: {}", argNumber, value);
            if (argNumber <= expectedParams) {
                args[i] = value;
            }
            argNumber++;
            i++;
        }
    }
    if (argNumber - 1 != expectedParams) {
        throw new SQLException("Number of parameters mismatch. Expected: " + expectedParams + ", was: " + (argNumber - 1));
    }

    // use argument setter as it deals with various JDBC drivers setObject vs setLong/setInteger/setString etc.
    ArgumentPreparedStatementSetter setter = new ArgumentPreparedStatementSetter(args);
    setter.setValues(ps);
}