Java 类org.springframework.jdbc.core.ArgumentPreparedStatementSetter 实例源码

@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;
}

@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;
    }
}

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();
            }
        }

    });
}

@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);
}