net.hasor.db.jdbc

接口 JdbcOperations

所有已知实现类:

JdbcTemplate

public interface JdbcOperations

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

版本:

: 2013-10-9

作者:

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

方法概要

方法

限定符和类型	方法和说明
int[]	batchUpdate(String[] sql) 批量执行 insert 或 update、delete 语句，返回值用于表示受影响的行数。
int[]	batchUpdate(String sql, BatchPreparedStatementSetter pss) 批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
int[]	batchUpdate(String sql, Map<String,?>[] batchValues) 批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
int[]	batchUpdate(String sql, SqlParameterSource[] batchArgs) 批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
<T> T	execute(CallableStatementCreator csc, CallableStatementCallback<T> action) 执行 JDBC（存储过程、函数）数据访问操作。
<T> T	execute(ConnectionCallback<T> action) 通过回调函数执行一个JDBC数据访问操作。
<T> T	execute(PreparedStatementCreator psc, PreparedStatementCallback<T> action) 执行一个 JDBC 操作。
<T> T	execute(StatementCallback<T> action) 通过回调函数执行一个JDBC数据访问操作。
void	execute(String sql) 执行一个 SQL语句，通常是一个 DDL 语句.
<T> T	execute(String callString, CallableStatementCallback<T> action) 执行 JDBC（存储过程、函数）数据访问操作。
<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 操作。
<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[] arg, ResultSetExtractor<T> rses) 查询一个 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 语句。
<T> T	query(String sql, ResultSetExtractor<T> rse, Object... args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。
void	query(String sql, RowCallbackHandler rch) 执行一个静态 SQL 语句。
void	query(String sql, RowCallbackHandler rch, Object... args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
<T> List<T>	query(String sql, RowMapper<T> rowMapper) 执行一个静态 SQL 语句，并使用 RowMapper 处理结果集。
<T> List<T>	query(String sql, RowMapper<T> rowMapper, Object... args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<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参数指定的类型对象。
<T> List<T>	queryForList(String sql, Class<T> elementType, Object... args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
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, 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, Class<T> requiredType, Object... args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<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, RowMapper<T> rowMapper, Object... args) 查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。
<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 封装。
int	update(PreparedStatementCreator psc) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
int	update(String sql) 执行一条 insert 或 update、delete 语句，返回值用于表示受影响的行数。
int	update(String sql, Map<String,?> paramMap) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
int	update(String sql, Object... args) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
int	update(String sql, PreparedStatementSetter pss) 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
int	update(String sql, SqlParameterSource paramSource) 执行一个更新语句（insert、update、delete），这个查询将会使用 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(CallableStatementCreator csc,
            CallableStatementCallback<T> action)
          throws SQLException

执行 JDBC（存储过程、函数）数据访问操作。

CallableStatementCreator 接口或者 CallableStatementCallback 接口 对象需要对存储过程的传入参数进行设置。

抛出:

SQLException

execute

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

执行 JDBC（存储过程、函数）数据访问操作。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 CallableStatementCallback 执行。

抛出:

SQLException

execute

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

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

抛出:

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

void execute(String sql)
             throws SQLException

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

抛出:

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,
          ResultSetExtractor<T> rse,
          Object... args)
        throws SQLException

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

抛出:

SQLException

query

<T> T query(String sql,
          Object[] arg,
          ResultSetExtractor<T> rses)
        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,
         RowCallbackHandler rch,
         Object... args)
           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,
                RowMapper<T> rowMapper,
                Object... args)
              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,
                       Class<T> elementType,
                       Object... args)
                     throws SQLException

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

抛出:

SQLException - if the query fails

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,
                   RowMapper<T> rowMapper,
                   Object... args)
                 throws SQLException

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

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

抛出:

SQLException - if the query fails

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,
                   Class<T> requiredType,
                   Object... args)
                 throws SQLException

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

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

抛出:

SQLException - if the query fails

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

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,
                                    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

update

int update(PreparedStatementCreator psc)
           throws SQLException

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

抛出:

SQLException

update

int update(String sql)
           throws SQLException

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

抛出:

SQLException

update

int update(String sql,
         PreparedStatementSetter pss)
           throws SQLException

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

抛出:

SQLException

update

int update(String sql,
         Object... args)
           throws SQLException

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

抛出:

SQLException

update

int update(String sql,
         SqlParameterSource paramSource)
           throws SQLException

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

抛出:

SQLException

update

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

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

抛出:

SQLException

batchUpdate

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

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

抛出:

SQLException

batchUpdate

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

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

抛出:

SQLException

batchUpdate

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

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

抛出:

SQLException

batchUpdate

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

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

抛出:

SQLException