net.hasor.db.jdbc

接口 JdbcOperations

所有已知子接口:

LambdaOperations

所有已知实现类:

JdbcTemplate, LambdaTemplate

public interface JdbcOperations

该接口声明了一些 JDBC 基本操作。

版本:

: 2013-10-9

作者:

Thomas Risberg, Juergen Hoeller, 赵永春 (zyc@hasor.net)

方法概要

限定符和类型	方法和说明
<T> T	call(CallableStatementCreator csc, CallableStatementCallback<T> action)
Map<String,Object>	call(CallableStatementCreator csc, List<SqlParameter> declaredParameters)
<T> T	call(String callString, CallableStatementCallback<T> action)
<T> T	call(String callString, CallableStatementSetter setter, CallableStatementCallback<T> action)
Map<String,Object>	call(String callString, List<SqlParameter> declaredParameters)
<T> T	execute(ConnectionCallback<T> action) 通过回调函数执行一个JDBC数据访问操作。
<T> T	execute(PreparedStatementCreator psc, PreparedStatementCallback<T> action) 执行一个 JDBC 操作。
<T> T	execute(PreparedStatementCreator psc, PreparedStatementSetter pss, ResultSetExtractor<T> rse)
<T> T	execute(StatementCallback<T> action) 通过回调函数执行一个JDBC数据访问操作。
boolean	execute(String sql) 执行一个 SQL语句，通常是一个 DDL 语句.
<T> T	execute(String sql, Map<String,?> paramMap, PreparedStatementCallback<T> action) 执行一个动态 SQL 语句。
<T> T	execute(String sql, PreparedStatementCallback<T> action) 执行一个动态 SQL 语句。
<T> T	execute(String sql, SqlParameterSource paramSource, PreparedStatementCallback<T> action) 执行一个 JDBC 操作。
int[]	executeBatch(String[] sql) 批量执行 insert 或 update、delete 语句，返回值用于表示受影响的行数。
int[]	executeBatch(String sql, BatchPreparedStatementSetter pss) 批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
int[]	executeBatch(String sql, Map<String,?>[] batchValues) 批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
int[]	executeBatch(String sql, Object[][] batchValues) 批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
int[]	executeBatch(String sql, SqlParameterSource[] batchArgs) 批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
int	executeUpdate(PreparedStatementCreator psc) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
int	executeUpdate(PreparedStatementCreator psc, PreparedStatementSetter pss) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
int	executeUpdate(String sql) 执行一条 insert 或 update、delete 语句，返回值用于表示受影响的行数。
int	executeUpdate(String sql, Map<String,?> paramMap) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
int	executeUpdate(String sql, Object[] args) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
int	executeUpdate(String sql, PreparedStatementSetter pss) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
int	executeUpdate(String sql, SqlParameterSource paramSource) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
List<Object>	multipleExecute(String sql) 执行一个 SQL语句块，语句块可能返回多个结果.
List<Object>	multipleExecute(String sql, Map<String,?> paramMap) 执行一个 SQL语句块，语句块可能返回多个结果.
List<Object>	multipleExecute(String sql, Object[] args) 执行一个 SQL语句块，语句块可能返回多个结果.
List<Object>	multipleExecute(String sql, SqlParameterSource parameterSource) 执行一个 SQL语句块，语句块可能返回多个结果.
<T> T	query(PreparedStatementCreator psc, ResultSetExtractor<T> rse) 执行一个动态查询 SQL 语句。
void	query(PreparedStatementCreator psc, RowCallbackHandler rch) Query using a prepared statement, reading the ResultSet on a per-row basis with a RowCallbackHandler.
<T> List<T>	query(PreparedStatementCreator psc, RowMapper<T> rowMapper) Query using a prepared statement, mapping each row to a Java object via a RowMapper.
<T> T	query(String sql, Map<String,?> paramMap, ResultSetExtractor<T> rse) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。
void	query(String sql, Map<String,?> paramMap, RowCallbackHandler rch) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
<T> List<T>	query(String sql, Map<String,?> paramMap, RowMapper<T> rowMapper) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<T> T	query(String sql, Object[] args, ResultSetExtractor<T> rse) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。
void	query(String sql, Object[] args, RowCallbackHandler rch) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
<T> List<T>	query(String sql, Object[] args, RowMapper<T> rowMapper) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<T> T	query(String sql, PreparedStatementSetter pss, ResultSetExtractor<T> rse) 执行一个动态查询 SQL 语句。
void	query(String sql, PreparedStatementSetter pss, RowCallbackHandler rch) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
<T> List<T>	query(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<T> T	query(String sql, ResultSetExtractor<T> rse) 执行一个静态 SQL 语句。
void	query(String sql, RowCallbackHandler rch) 执行一个静态 SQL 语句。
<T> List<T>	query(String sql, RowMapper<T> rowMapper) 执行一个静态 SQL 语句，并使用 RowMapper 处理结果集。
<T> T	query(String sql, SqlParameterSource paramSource, ResultSetExtractor<T> rse) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。
void	query(String sql, SqlParameterSource paramSource, RowCallbackHandler rch) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
<T> List<T>	query(String sql, SqlParameterSource paramSource, RowMapper<T> rowMapper) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
int	queryForInt(String sql) 执行一个静态 SQL 语句，并取得 int 类型数据。
int	queryForInt(String sql, Map<String,?> paramMap) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
int	queryForInt(String sql, Object[] args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
int	queryForInt(String sql, SqlParameterSource paramSource) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
List<Map<String,Object>>	queryForList(String sql) 执行一个静态 SQL 语句，结果将被映射到一个列表(一个条目为每一行)的对象， 列表中每一条记录都是Map类型对象。
<T> List<T>	queryForList(String sql, Class<T> elementType) 执行一个静态 SQL 语句，结果将被映射到一个列表(一个条目为每一行)的对象，列表中每一条记录都是elementType参数指定的类型对象。
List<Map<String,Object>>	queryForList(String sql, Map<String,?> paramMap) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<T> List<T>	queryForList(String sql, Map<String,?> paramMap, Class<T> elementType) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
List<Map<String,Object>>	queryForList(String sql, Object[] args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<T> List<T>	queryForList(String sql, Object[] args, Class<T> elementType) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
List<Map<String,Object>>	queryForList(String sql, PreparedStatementSetter args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
List<Map<String,Object>>	queryForList(String sql, SqlParameterSource paramSource) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<T> List<T>	queryForList(String sql, SqlParameterSource paramSource, Class<T> elementType) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
long	queryForLong(String sql) 执行一个静态 SQL 语句，并取得 long 类型数据。
long	queryForLong(String sql, Map<String,?> paramMap) 查询一个 SQL 语句，sql 参数通过 Map 封装。
long	queryForLong(String sql, Object[] args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
long	queryForLong(String sql, SqlParameterSource paramSource) 查询一个 SQL 语句，sql 参数通过 SqlParameterSource 封装。
Map<String,Object>	queryForMap(String sql) 执行一个静态 SQL 语句，并将结果集数据转换成Map。
Map<String,Object>	queryForMap(String sql, Map<String,?> paramMap) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
Map<String,Object>	queryForMap(String sql, Object[] args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
Map<String,Object>	queryForMap(String sql, SqlParameterSource paramSource) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<T> T	queryForObject(String sql, Class<T> requiredType) 执行一个静态 SQL 语句，并将结果集数据转换成requiredType参数指定的类型对象。
<T> T	queryForObject(String sql, Map<String,?> paramMap, Class<T> requiredType) 查询一个 SQL 语句，查询参数使用 Map 封装，并将查询结果使用 requiredType 参数表示的类型返回。
<T> T	queryForObject(String sql, Map<String,?> paramMap, RowMapper<T> rowMapper) 查询一个 SQL 语句，查询参数使用 Map 封装。
<T> T	queryForObject(String sql, Object[] args, Class<T> requiredType) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<T> T	queryForObject(String sql, Object[] args, RowMapper<T> rowMapper) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<T> T	queryForObject(String sql, RowMapper<T> rowMapper) 执行一个静态 SQL 语句，并使用 RowMapper 处理结果集。
<T> T	queryForObject(String sql, SqlParameterSource paramSource, Class<T> requiredType) 查询一个 SQL 语句，查询参数使用 SqlParameterSource 封装，并将查询结果使用 requiredType 参数表示的类型返回。
<T> T	queryForObject(String sql, SqlParameterSource paramSource, RowMapper<T> rowMapper) 查询一个 SQL 语句，查询参数使用 SqlParameterSource 封装。
String	queryForString(String sql) 执行一个静态 SQL 语句，并取得 String 类型数据。
String	queryForString(String sql, Map<String,?> paramMap) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
String	queryForString(String sql, Object[] args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
String	queryForString(String sql, SqlParameterSource paramSource) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。

方法详细资料

execute

<T> T execute(ConnectionCallback<T> action)
       throws SQLException

通过回调函数执行一个JDBC数据访问操作。

抛出:

SQLException

execute

<T> T execute(StatementCallback<T> action)
       throws SQLException

通过回调函数执行一个JDBC数据访问操作。

抛出:

SQLException

execute

<T> T execute(PreparedStatementCreator psc,
              PreparedStatementCallback<T> action)
       throws SQLException

执行一个 JDBC 操作。这个 JDBC 调用操作将会使用 PreparedStatement 接口执行。

抛出:

SQLException

execute

<T> T execute(PreparedStatementCreator psc,
              PreparedStatementSetter pss,
              ResultSetExtractor<T> rse)
       throws SQLException

抛出:

SQLException

execute

<T> T execute(String sql,
              PreparedStatementCallback<T> action)
       throws SQLException

执行一个动态 SQL 语句。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 PreparedStatementCallback 执行。

抛出:

SQLException

execute

<T> T execute(String sql,
              SqlParameterSource paramSource,
              PreparedStatementCallback<T> action)
       throws SQLException

执行一个 JDBC 操作。这个 JDBC 调用操作将会使用 PreparedStatement 接口执行。

抛出:

SQLException

execute

<T> T execute(String sql,
              Map<String,?> paramMap,
              PreparedStatementCallback<T> action)
       throws SQLException

执行一个动态 SQL 语句。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 PreparedStatementCallback 执行。

抛出:

SQLException

execute

boolean execute(String sql)
         throws SQLException

执行一个 SQL语句，通常是一个 DDL 语句.

抛出:

SQLException

multipleExecute

List<Object> multipleExecute(String sql)
                      throws SQLException

执行一个 SQL语句块，语句块可能返回多个结果.（需要数据库驱动支持，例如mysql 要设置 allowMultiQueries=true 参数）

抛出:

SQLException

multipleExecute

List<Object> multipleExecute(String sql,
                             Object[] args)
                      throws SQLException

执行一个 SQL语句块，语句块可能返回多个结果.（需要数据库驱动支持，例如mysql 要设置 allowMultiQueries=true 参数）

抛出:

SQLException

multipleExecute

List<Object> multipleExecute(String sql,
                             Map<String,?> paramMap)
                      throws SQLException

执行一个 SQL语句块，语句块可能返回多个结果.（需要数据库驱动支持，例如mysql 要设置 allowMultiQueries=true 参数）

抛出:

SQLException

multipleExecute

List<Object> multipleExecute(String sql,
                             SqlParameterSource parameterSource)
                      throws SQLException

执行一个 SQL语句块，语句块可能返回多个结果.（需要数据库驱动支持，例如mysql 要设置 allowMultiQueries=true 参数）

抛出:

SQLException

query

<T> T query(PreparedStatementCreator psc,
            ResultSetExtractor<T> rse)
     throws SQLException

执行一个动态查询 SQL 语句。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 PreparedStatementCallback 执行。 返回的结果集使用 ResultSetExtractor 转换。

抛出:

SQLException

query

<T> T query(String sql,
            ResultSetExtractor<T> rse)
     throws SQLException

执行一个静态 SQL 语句。并通过 ResultSetExtractor 转换结果集。

抛出:

SQLException

query

<T> T query(String sql,
            PreparedStatementSetter pss,
            ResultSetExtractor<T> rse)
     throws SQLException

执行一个动态查询 SQL 语句。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 PreparedStatementSetter 为动态 SQL 设置属性。返回的结果集使用 ResultSetExtractor 转换。

抛出:

SQLException

query

<T> T query(String sql,
            Object[] args,
            ResultSetExtractor<T> rse)
     throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。

抛出:

SQLException

query

<T> T query(String sql,
            SqlParameterSource paramSource,
            ResultSetExtractor<T> rse)
     throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。

抛出:

SQLException

query

<T> T query(String sql,
            Map<String,?> paramMap,
            ResultSetExtractor<T> rse)
     throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。

抛出:

SQLException

query

void query(PreparedStatementCreator psc,
           RowCallbackHandler rch)
    throws SQLException

Query using a prepared statement, reading the ResultSet on a per-row basis with a RowCallbackHandler.

A PreparedStatementCreator can either be implemented directly or configured through a PreparedStatementCreatorFactory.

参数:

psc - object that can create a PreparedStatement given a Connection

rch - object that will extract results, one row at a time

抛出:

SQLException

query

void query(String sql,
           RowCallbackHandler rch)
    throws SQLException

执行一个静态 SQL 语句。并通过 RowCallbackHandler 处理结果集。

抛出:

SQLException

query

void query(String sql,
           PreparedStatementSetter pss,
           RowCallbackHandler rch)
    throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。

抛出:

SQLException

query

void query(String sql,
           Object[] args,
           RowCallbackHandler rch)
    throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。

抛出:

SQLException

query

void query(String sql,
           SqlParameterSource paramSource,
           RowCallbackHandler rch)
    throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。

抛出:

SQLException

query

void query(String sql,
           Map<String,?> paramMap,
           RowCallbackHandler rch)
    throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。

抛出:

SQLException

query

<T> List<T> query(PreparedStatementCreator psc,
                  RowMapper<T> rowMapper)
           throws SQLException

Query using a prepared statement, mapping each row to a Java object via a RowMapper.

A PreparedStatementCreator can either be implemented directly or configured through a PreparedStatementCreatorFactory.

参数:

psc - object that can create a PreparedStatement given a Connection

rowMapper - object that will map one object per row

返回:

the result List, containing mapped objects

抛出:

SQLException

query

<T> List<T> query(String sql,
                  PreparedStatementSetter pss,
                  RowMapper<T> rowMapper)
           throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将返回一个 List，每一行将通过 RowMapper 映射。

抛出:

SQLException

query

<T> List<T> query(String sql,
                  Object[] args,
                  RowMapper<T> rowMapper)
           throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将返回一个 List，每一行将通过 RowMapper 映射。

抛出:

SQLException

query

<T> List<T> query(String sql,
                  RowMapper<T> rowMapper)
           throws SQLException

执行一个静态 SQL 语句，并使用 RowMapper 处理结果集。

抛出:

SQLException

query

<T> List<T> query(String sql,
                  SqlParameterSource paramSource,
                  RowMapper<T> rowMapper)
           throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将返回一个 List，每一行将通过 RowMapper 映射。

抛出:

SQLException

query

<T> List<T> query(String sql,
                  Map<String,?> paramMap,
                  RowMapper<T> rowMapper)
           throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将返回一个 List，每一行将通过 RowMapper 映射。

抛出:

SQLException

queryForList

<T> List<T> queryForList(String sql,
                         Class<T> elementType)
                  throws SQLException

执行一个静态 SQL 语句，结果将被映射到一个列表(一个条目为每一行)的对象，列表中每一条记录都是elementType参数指定的类型对象。

抛出:

SQLException

queryForList

<T> List<T> queryForList(String sql,
                         Object[] args,
                         Class<T> elementType)
                  throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 elementType 参数所表示的类型。

抛出:

SQLException - if the query fails

queryForList

<T> List<T> queryForList(String sql,
                         SqlParameterSource paramSource,
                         Class<T> elementType)
                  throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 elementType 参数所表示的类型。

抛出:

SQLException - if the query fails

queryForList

<T> List<T> queryForList(String sql,
                         Map<String,?> paramMap,
                         Class<T> elementType)
                  throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 elementType 参数所表示的类型。

抛出:

SQLException - if the query fails

queryForObject

<T> T queryForObject(String sql,
                     RowMapper<T> rowMapper)
              throws SQLException

执行一个静态 SQL 语句，并使用 RowMapper 处理结果集。 预计该方法只会处理一条数据，如果查询结果存在多条数据将取第一条记录作为结果。

返回:

当不存在记录时返回null。

抛出:

SQLException

queryForObject

<T> T queryForObject(String sql,
                     Object[] args,
                     RowMapper<T> rowMapper)
              throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将通过 RowMapper 映射转换并返回。

预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。

抛出:

SQLException - if the query fails

queryForObject

<T> T queryForObject(String sql,
                     SqlParameterSource paramSource,
                     RowMapper<T> rowMapper)
              throws SQLException

查询一个 SQL 语句，查询参数使用 SqlParameterSource 封装。

预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。

抛出:

SQLException - if the query fails

queryForObject

<T> T queryForObject(String sql,
                     Map<String,?> paramMap,
                     RowMapper<T> rowMapper)
              throws SQLException

查询一个 SQL 语句，查询参数使用 Map 封装。

预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。

抛出:

SQLException - if the query fails

queryForObject

<T> T queryForObject(String sql,
                     Class<T> requiredType)
              throws SQLException

执行一个静态 SQL 语句，并将结果集数据转换成requiredType参数指定的类型对象。 预计该方法只会处理一条数据，如果查询结果存在多条数据将取第一条记录作为结果。

返回:

当不存在记录时返回null。

抛出:

SQLException

queryForObject

<T> T queryForObject(String sql,
                     Object[] args,
                     Class<T> requiredType)
              throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将通过 requiredType 参数所表示的类型封装。

预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。

抛出:

SQLException - if the query fails

queryForObject

<T> T queryForObject(String sql,
                     SqlParameterSource paramSource,
                     Class<T> requiredType)
              throws SQLException

查询一个 SQL 语句，查询参数使用 SqlParameterSource 封装，并将查询结果使用 requiredType 参数表示的类型返回。

预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。

抛出:

SQLException - if the query fails

queryForObject

<T> T queryForObject(String sql,
                     Map<String,?> paramMap,
                     Class<T> requiredType)
              throws SQLException

查询一个 SQL 语句，查询参数使用 Map 封装，并将查询结果使用 requiredType 参数表示的类型返回。

预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。

抛出:

SQLException - if the query fails

queryForMap

Map<String,Object> queryForMap(String sql)
                        throws SQLException

执行一个静态 SQL 语句，并将结果集数据转换成Map。 预计该方法只会处理一条数据，如果查询结果存在多条数据将取第一条记录作为结果。

返回:

当不存在记录时返回null。

抛出:

SQLException

queryForMap

Map<String,Object> queryForMap(String sql,
                               Object[] args)
                        throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将使用 Map 封装。

预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。

抛出:

SQLException - if the query fails

queryForMap

Map<String,Object> queryForMap(String sql,
                               SqlParameterSource paramSource)
                        throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将使用 Map 封装。

预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。

抛出:

SQLException - if the query fails

queryForMap

Map<String,Object> queryForMap(String sql,
                               Map<String,?> paramMap)
                        throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将使用 Map 封装。

预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。

抛出:

SQLException - if the query fails

queryForLong

long queryForLong(String sql)
           throws SQLException

执行一个静态 SQL 语句，并取得 long 类型数据。 预计该方法只会处理一条数据，如果查询结果存在多条数据或者多列将会引发异常。

返回:

the long value, or 0 in case of SQL NULL

抛出:

SQLException

queryForLong

long queryForLong(String sql,
                  Object[] args)
           throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 long 类型。 所以需要保证查询的结果只有一行一列，否则执行会引发异常。

抛出:

SQLException - if the query fails

queryForLong

long queryForLong(String sql,
                  SqlParameterSource paramSource)
           throws SQLException

查询一个 SQL 语句，sql 参数通过 SqlParameterSource 封装。查询结果将转换成 long 类型。 所以需要保证查询的结果只有一行一列，否则执行会引发异常。

抛出:

SQLException - if the query fails

queryForLong

long queryForLong(String sql,
                  Map<String,?> paramMap)
           throws SQLException

查询一个 SQL 语句，sql 参数通过 Map 封装。查询结果将转换成 long 类型。 所以需要保证查询的结果只有一行一列，否则执行会引发异常。

抛出:

SQLException - if the query fails

queryForInt

int queryForInt(String sql)
         throws SQLException

执行一个静态 SQL 语句，并取得 int 类型数据。 预计该方法只会处理一条数据，如果查询结果存在多条数据或者多列将会引发异常。

返回:

the int value, or 0 in case of SQL NULL

抛出:

SQLException

queryForInt

int queryForInt(String sql,
                Object[] args)
         throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 int 类型。 所以需要保证查询的结果只有一行一列，否则执行会引发异常。

抛出:

SQLException - if the query fails

queryForInt

int queryForInt(String sql,
                SqlParameterSource paramSource)
         throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 int 类型。 所以需要保证查询的结果只有一行一列，否则执行会引发异常。

抛出:

SQLException - if the query fails

queryForInt

int queryForInt(String sql,
                Map<String,?> paramMap)
         throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 int 类型。 所以需要保证查询的结果只有一行一列，否则执行会引发异常。

抛出:

SQLException - if the query fails

queryForString

String queryForString(String sql)
               throws SQLException

执行一个静态 SQL 语句，并取得 String 类型数据。 预计该方法只会处理一条数据，如果查询结果存在多条数据或者多列将会引发异常。

返回:

the String value.

抛出:

SQLException

queryForString

String queryForString(String sql,
                      Object[] args)
               throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 String 类型。 所以需要保证查询的结果只有一行一列，否则执行会引发异常。

抛出:

SQLException - if the query fails

queryForString

String queryForString(String sql,
                      SqlParameterSource paramSource)
               throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 String 类型。 所以需要保证查询的结果只有一行一列，否则执行会引发异常。

抛出:

SQLException - if the query fails

queryForString

String queryForString(String sql,
                      Map<String,?> paramMap)
               throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 String 类型。 所以需要保证查询的结果只有一行一列，否则执行会引发异常。

抛出:

SQLException - if the query fails

queryForList

List<Map<String,Object>> queryForList(String sql)
                               throws SQLException

执行一个静态 SQL 语句，结果将被映射到一个列表(一个条目为每一行)的对象， 列表中每一条记录都是Map类型对象。

抛出:

SQLException

queryForList

List<Map<String,Object>> queryForList(String sql,
                                      Object[] args)
                               throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询记录将会使用 Map 保存，并封装到 List 中。

抛出:

SQLException

queryForList

List<Map<String,Object>> queryForList(String sql,
                                      PreparedStatementSetter args)
                               throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询记录将会使用 Map 保存，并封装到 List 中。

抛出:

SQLException

queryForList

List<Map<String,Object>> queryForList(String sql,
                                      SqlParameterSource paramSource)
                               throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询记录将会使用 Map 保存，并封装到 List 中。

抛出:

SQLException

queryForList

List<Map<String,Object>> queryForList(String sql,
                                      Map<String,?> paramMap)
                               throws SQLException

查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询记录将会使用 Map 保存，并封装到 List 中。

抛出:

SQLException

executeUpdate

int executeUpdate(PreparedStatementCreator psc)
           throws SQLException

执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。

抛出:

SQLException

executeUpdate

int executeUpdate(String sql)
           throws SQLException

执行一条 insert 或 update、delete 语句，返回值用于表示受影响的行数。

抛出:

SQLException

executeUpdate

int executeUpdate(String sql,
                  PreparedStatementSetter pss)
           throws SQLException

执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。

抛出:

SQLException

executeUpdate

int executeUpdate(String sql,
                  Object[] args)
           throws SQLException

执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。

抛出:

SQLException

executeUpdate

int executeUpdate(String sql,
                  SqlParameterSource paramSource)
           throws SQLException

执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。

抛出:

SQLException

executeUpdate

int executeUpdate(String sql,
                  Map<String,?> paramMap)
           throws SQLException

执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。

抛出:

SQLException

executeUpdate

int executeUpdate(PreparedStatementCreator psc,
                  PreparedStatementSetter pss)
           throws SQLException

执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。

抛出:

SQLException

executeBatch

int[] executeBatch(String[] sql)
            throws SQLException

批量执行 insert 或 update、delete 语句，返回值用于表示受影响的行数。

抛出:

SQLException

executeBatch

int[] executeBatch(String sql,
                   BatchPreparedStatementSetter pss)
            throws SQLException

批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。

抛出:

SQLException

executeBatch

int[] executeBatch(String sql,
                   Map<String,?>[] batchValues)
            throws SQLException

批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。

抛出:

SQLException

executeBatch

int[] executeBatch(String sql,
                   Object[][] batchValues)
            throws SQLException

批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。

抛出:

SQLException

executeBatch

int[] executeBatch(String sql,
                   SqlParameterSource[] batchArgs)
            throws SQLException

批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。

抛出:

SQLException

call

<T> T call(CallableStatementCreator csc,
           CallableStatementCallback<T> action)
    throws SQLException

抛出:

SQLException

call

<T> T call(String callString,
           CallableStatementCallback<T> action)
    throws SQLException

抛出:

SQLException

call

<T> T call(String callString,
           CallableStatementSetter setter,
           CallableStatementCallback<T> action)
    throws SQLException

抛出:

SQLException

call

Map<String,Object> call(CallableStatementCreator csc,
                        List<SqlParameter> declaredParameters)
                 throws SQLException

抛出:

SQLException

call

Map<String,Object> call(String callString,
                        List<SqlParameter> declaredParameters)
                 throws SQLException

抛出:

SQLException