JdbcTemplate (Hasor-DB 3.2.1 API)

java.lang.Object
- net.hasor.db.jdbc.core.JdbcAccessor
- - net.hasor.db.jdbc.core.JdbcConnection
  - - net.hasor.db.jdbc.core.JdbcTemplate

所有已实现的接口:

JdbcOperations
```
public class JdbcTemplate
extends JdbcConnection
implements JdbcOperations
```
数据库操作模板方法。

版本:

: 2013-10-12

作者:

赵永春 (zyc@byshell.org)

嵌套类概要

嵌套类
限定符和类型类和说明

protected static interface JdbcTemplate.SqlProvider
获取SQL

嵌套类
限定符和类型	类和说明
`protected static interface`	`JdbcTemplate.SqlProvider` 获取SQL

字段概要
- 从类继承的字段 net.hasor.db.jdbc.core.JdbcAccessor
  logger

构造器概要

构造器
构造器和说明
`JdbcTemplate()` Construct a new JdbcTemplate for bean usage.
`JdbcTemplate(Connection conn)` Construct a new JdbcTemplate, given a Connection to obtain connections from.
`JdbcTemplate(DataSource dataSource)` Construct a new JdbcTemplate, given a DataSource to obtain connections from.

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`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 接口设置。
`protected Map<String,Object>`	`createResultsMap()` 创建用于保存结果集的数据Map。
`<T> T`	`execute(CallableStatementCreator csc, CallableStatementCallback<T> action)` 执行 JDBC（存储过程、函数）数据访问操作。
`<T> T`	`execute(PreparedStatementCreator psc, PreparedStatementCallback<T> action)` 执行一个 JDBC 操作。
`<T> T`	`execute(StatementCallback<T> action)` 通过回调函数执行一个JDBC数据访问操作。
`boolean`	`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 操作。
`protected <T> RowMapper<T>`	`getBeanPropertyRowMapper(Class<T> requiredType)` Create a new RowMapper for reading columns as Bean pairs.
`protected RowMapper<Map<String,Object>>`	`getColumnMapRowMapper()` Create a new RowMapper for reading columns as key-value pairs.
`protected ParsedSql`	`getParsedSql(String originalSql)`
`protected PreparedStatementCreator`	`getPreparedStatementCreator(String sql, SqlParameterSource paramSource)` Build a PreparedStatementCreator based on the given SQL and named parameters.
`protected <T> RowMapper<T>`	`getSingleColumnRowMapper(Class<T> requiredType)` Create a new RowMapper for reading result objects from a single column.
`boolean`	`isIgnoreWarnings()`
`boolean`	`isResultsCaseInsensitive()`
`void`	`loadSQL(Reader sqlReader)`
`void`	`loadSQL(String sqlResource)`
`void`	`loadSQL(String charsetName, String sqlResource)`
`protected PreparedStatementSetter`	`newArgPreparedStatementSetter(Object[] args)` Create a new PreparedStatementSetter.
`<T> T`	`query(PreparedStatementCreator psc, PreparedStatementSetter pss, ResultSetExtractor<T> rse)`
`<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 语句。
`<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 封装。
`void`	`setIgnoreWarnings(boolean ignoreWarnings)`
`void`	`setResultsCaseInsensitive(boolean resultsCaseInsensitive)`
`int`	`update(PreparedStatementCreator psc)` 执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
`int`	`update(PreparedStatementCreator psc, PreparedStatementSetter pss)`
`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 接口操作。

从类继承的方法 net.hasor.db.jdbc.core.JdbcConnection
applyStatementSettings, execute, getFetchSize, getMaxRows, getQueryTimeout, setFetchSize, setMaxRows, setQueryTimeout

从类继承的方法 net.hasor.db.jdbc.core.JdbcAccessor
getConnection, getDataSource, setConnection, setDataSource

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 net.hasor.db.jdbc.JdbcOperations
execute

- 构造器详细资料
  - JdbcTemplate
```
public JdbcTemplate()
```
    Construct a new JdbcTemplate for bean usage.
    Note: The DataSource has to be set before using the instance.
    
    另请参阅:
    
    JdbcAccessor.setDataSource(javax.sql.DataSource)
  - JdbcTemplate
```
public JdbcTemplate(DataSource dataSource)
```
    Construct a new JdbcTemplate, given a DataSource to obtain connections from.
    Note: This will not trigger initialization of the exception translator.
    
    参数:
    
    dataSource - the JDBC DataSource to obtain connections from
  - JdbcTemplate
```
public JdbcTemplate(Connection conn)
```
    Construct a new JdbcTemplate, given a Connection to obtain connections from.
    Note: This will not trigger initialization of the exception translator.
    
    参数:
    
    conn - the JDBC Connection
- 方法详细资料
  - isIgnoreWarnings
```
public boolean isIgnoreWarnings()
```
  - setIgnoreWarnings
```
public void setIgnoreWarnings(boolean ignoreWarnings)
```
  - isResultsCaseInsensitive
```
public boolean isResultsCaseInsensitive()
```
  - setResultsCaseInsensitive
```
public void setResultsCaseInsensitive(boolean resultsCaseInsensitive)
```
  - loadSQL
```
public void loadSQL(String sqlResource)
             throws IOException,
                    SQLException
```
    抛出:
    
    IOException
    
    SQLException
  - loadSQL
```
public void loadSQL(String charsetName,
                    String sqlResource)
             throws IOException,
                    SQLException
```
    抛出:
    
    IOException
    
    SQLException
  - loadSQL
```
public void loadSQL(Reader sqlReader)
             throws IOException,
                    SQLException
```
    抛出:
    
    IOException
    
    SQLException
  - execute
```
public <T> T execute(StatementCallback<T> action)
              throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    通过回调函数执行一个JDBC数据访问操作。
    
    指定者:
    
    execute 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - execute
```
public <T> T execute(PreparedStatementCreator psc,
                     PreparedStatementCallback<T> action)
              throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个 JDBC 操作。这个 JDBC 调用操作将会使用 PreparedStatement 接口执行。
    
    指定者:
    
    execute 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - execute
```
public <T> T execute(CallableStatementCreator csc,
                     CallableStatementCallback<T> action)
              throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行 JDBC（存储过程、函数）数据访问操作。
    CallableStatementCreator 接口或者 CallableStatementCallback 接口对象需要对存储过程的传入参数进行设置。
    
    指定者:
    
    execute 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - execute
```
public <T> T execute(String sql,
                     PreparedStatementCallback<T> action)
              throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个动态 SQL 语句。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 PreparedStatementCallback 执行。
    
    指定者:
    
    execute 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - execute
```
public <T> T execute(String callString,
                     CallableStatementCallback<T> action)
              throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行 JDBC（存储过程、函数）数据访问操作。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 CallableStatementCallback 执行。
    
    指定者:
    
    execute 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - execute
```
public <T> T execute(String sql,
                     SqlParameterSource paramSource,
                     PreparedStatementCallback<T> action)
              throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个 JDBC 操作。这个 JDBC 调用操作将会使用 PreparedStatement 接口执行。
    
    指定者:
    
    execute 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - execute
```
public <T> T execute(String sql,
                     Map<String,?> paramMap,
                     PreparedStatementCallback<T> action)
              throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个动态 SQL 语句。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 PreparedStatementCallback 执行。
    
    指定者:
    
    execute 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - execute
```
public boolean execute(String sql)
                throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个 SQL语句，通常是一个 DDL 语句.
    
    指定者:
    
    execute 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> T query(PreparedStatementCreator psc,
                   PreparedStatementSetter pss,
                   ResultSetExtractor<T> rse)
            throws SQLException
```
    抛出:
    
    SQLException
  - query
```
public <T> T query(PreparedStatementCreator psc,
                   ResultSetExtractor<T> rse)
            throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个动态查询 SQL 语句。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 PreparedStatementCallback 执行。返回的结果集使用 ResultSetExtractor 转换。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> T query(String sql,
                   ResultSetExtractor<T> rse)
            throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句。并通过 ResultSetExtractor 转换结果集。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> T query(String sql,
                   PreparedStatementSetter pss,
                   ResultSetExtractor<T> rse)
            throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个动态查询 SQL 语句。SQL 语句会被编译成 PreparedStatement 类型通过回调接口 PreparedStatementSetter 为动态 SQL 设置属性。返回的结果集使用 ResultSetExtractor 转换。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> T query(String sql,
                   ResultSetExtractor<T> rse,
                   Object... args)
            throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> T query(String sql,
                   Object[] args,
                   ResultSetExtractor<T> rse)
            throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> T query(String sql,
                   SqlParameterSource paramSource,
                   ResultSetExtractor<T> rse)
            throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> T query(String sql,
                   Map<String,?> paramMap,
                   ResultSetExtractor<T> rse)
            throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且将 SQL 查询结果集使用 ResultSetExtractor 转换。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public void query(PreparedStatementCreator psc,
                  RowCallbackHandler rch)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    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.
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    参数:
    
    psc - object that can create a PreparedStatement given a Connection
    
    rch - object that will extract results, one row at a time
    
    抛出:
    
    SQLException
  - query
```
public void query(String sql,
                  RowCallbackHandler rch)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句。并通过 RowCallbackHandler 处理结果集。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public void query(String sql,
                  PreparedStatementSetter pss,
                  RowCallbackHandler rch)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public void query(String sql,
                  RowCallbackHandler rch,
                  Object... args)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public void query(String sql,
                  Object[] args,
                  RowCallbackHandler rch)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public void query(String sql,
                  SqlParameterSource paramSource,
                  RowCallbackHandler rch)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public void query(String sql,
                  Map<String,?> paramMap,
                  RowCallbackHandler rch)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作，并且结果集行处理使用 RowCallbackHandler 接口处理。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> List<T> query(PreparedStatementCreator psc,
                         RowMapper<T> rowMapper)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    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.
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    参数:
    
    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
```
public <T> List<T> query(String sql,
                         PreparedStatementSetter pss,
                         RowMapper<T> rowMapper)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将返回一个 List，每一行将通过 RowMapper 映射。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> List<T> query(String sql,
                         RowMapper<T> rowMapper,
                         Object... args)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将返回一个 List，每一行将通过 RowMapper 映射。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> List<T> query(String sql,
                         Object[] args,
                         RowMapper<T> rowMapper)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将返回一个 List，每一行将通过 RowMapper 映射。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> List<T> query(String sql,
                         RowMapper<T> rowMapper)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句，并使用 RowMapper 处理结果集。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> List<T> query(String sql,
                         SqlParameterSource paramSource,
                         RowMapper<T> rowMapper)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将返回一个 List，每一行将通过 RowMapper 映射。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - query
```
public <T> List<T> query(String sql,
                         Map<String,?> paramMap,
                         RowMapper<T> rowMapper)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将返回一个 List，每一行将通过 RowMapper 映射。
    
    指定者:
    
    query 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - queryForList
```
public <T> List<T> queryForList(String sql,
                                Class<T> elementType)
                         throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句，结果将被映射到一个列表(一个条目为每一行)的对象，列表中每一条记录都是elementType参数指定的类型对象。
    
    指定者:
    
    queryForList 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - queryForList
```
public <T> List<T> queryForList(String sql,
                                Class<T> elementType,
                                Object... args)
                         throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 elementType 参数所表示的类型。
    
    指定者:
    
    queryForList 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForList
```
public <T> List<T> queryForList(String sql,
                                Object[] args,
                                Class<T> elementType)
                         throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 elementType 参数所表示的类型。
    
    指定者:
    
    queryForList 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForList
```
public <T> List<T> queryForList(String sql,
                                SqlParameterSource paramSource,
                                Class<T> elementType)
                         throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 elementType 参数所表示的类型。
    
    指定者:
    
    queryForList 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForList
```
public <T> List<T> queryForList(String sql,
                                Map<String,?> paramMap,
                                Class<T> elementType)
                         throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 elementType 参数所表示的类型。
    
    指定者:
    
    queryForList 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForObject
```
public <T> T queryForObject(String sql,
                            RowMapper<T> rowMapper)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句，并使用 RowMapper 处理结果集。预计该方法只会处理一条数据，如果查询结果存在多条数据将取第一条记录作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    返回:
    
    当不存在记录时返回null。
    
    抛出:
    
    SQLException
  - queryForObject
```
public <T> T queryForObject(String sql,
                            RowMapper<T> rowMapper,
                            Object... args)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将通过 RowMapper 映射转换并返回。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForObject
```
public <T> T queryForObject(String sql,
                            Object[] args,
                            RowMapper<T> rowMapper)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将通过 RowMapper 映射转换并返回。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForObject
```
public <T> T queryForObject(String sql,
                            SqlParameterSource paramSource,
                            RowMapper<T> rowMapper)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，查询参数使用 SqlParameterSource 封装。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForObject
```
public <T> T queryForObject(String sql,
                            Map<String,?> paramMap,
                            RowMapper<T> rowMapper)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，查询参数使用 Map 封装。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForObject
```
public <T> T queryForObject(String sql,
                            Class<T> requiredType)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句，并将结果集数据转换成requiredType参数指定的类型对象。预计该方法只会处理一条数据，如果查询结果存在多条数据将取第一条记录作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    返回:
    
    当不存在记录时返回null。
    
    抛出:
    
    SQLException
  - queryForObject
```
public <T> T queryForObject(String sql,
                            Class<T> requiredType,
                            Object... args)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将通过 requiredType 参数所表示的类型封装。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForObject
```
public <T> T queryForObject(String sql,
                            Object[] args,
                            Class<T> requiredType)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将通过 requiredType 参数所表示的类型封装。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForObject
```
public <T> T queryForObject(String sql,
                            SqlParameterSource paramSource,
                            Class<T> requiredType)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，查询参数使用 SqlParameterSource 封装，并将查询结果使用 requiredType 参数表示的类型返回。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForObject
```
public <T> T queryForObject(String sql,
                            Map<String,?> paramMap,
                            Class<T> requiredType)
                     throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，查询参数使用 Map 封装，并将查询结果使用 requiredType 参数表示的类型返回。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForObject 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForLong
```
public long queryForLong(String sql)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句，并取得 long 类型数据。预计该方法只会处理一条数据，如果查询结果存在多条数据或者多列将会引发异常。
    
    指定者:
    
    queryForLong 在接口中 JdbcOperations
    
    返回:
    
    the long value, or 0 in case of SQL NULL
    
    抛出:
    
    SQLException
  - queryForLong
```
public long queryForLong(String sql,
                         Object... args)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 long 类型。所以需要保证查询的结果只有一行一列，否则执行会引发异常。
    
    指定者:
    
    queryForLong 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForLong
```
public long queryForLong(String sql,
                         SqlParameterSource paramSource)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，sql 参数通过 SqlParameterSource 封装。查询结果将转换成 long 类型。所以需要保证查询的结果只有一行一列，否则执行会引发异常。
    
    指定者:
    
    queryForLong 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForLong
```
public long queryForLong(String sql,
                         Map<String,?> paramMap)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，sql 参数通过 Map 封装。查询结果将转换成 long 类型。所以需要保证查询的结果只有一行一列，否则执行会引发异常。
    
    指定者:
    
    queryForLong 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForInt
```
public int queryForInt(String sql)
                throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句，并取得 int 类型数据。预计该方法只会处理一条数据，如果查询结果存在多条数据或者多列将会引发异常。
    
    指定者:
    
    queryForInt 在接口中 JdbcOperations
    
    返回:
    
    the int value, or 0 in case of SQL NULL
    
    抛出:
    
    SQLException
  - queryForInt
```
public int queryForInt(String sql,
                       Object... args)
                throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 int 类型。所以需要保证查询的结果只有一行一列，否则执行会引发异常。
    
    指定者:
    
    queryForInt 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForInt
```
public int queryForInt(String sql,
                       SqlParameterSource paramSource)
                throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 int 类型。所以需要保证查询的结果只有一行一列，否则执行会引发异常。
    
    指定者:
    
    queryForInt 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForInt
```
public int queryForInt(String sql,
                       Map<String,?> paramMap)
                throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将转换成 int 类型。所以需要保证查询的结果只有一行一列，否则执行会引发异常。
    
    指定者:
    
    queryForInt 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForMap
```
public Map<String,Object> queryForMap(String sql)
                               throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句，并将结果集数据转换成Map。预计该方法只会处理一条数据，如果查询结果存在多条数据将取第一条记录作为结果。
    
    指定者:
    
    queryForMap 在接口中 JdbcOperations
    
    返回:
    
    当不存在记录时返回null。
    
    抛出:
    
    SQLException
  - queryForMap
```
public Map<String,Object> queryForMap(String sql,
                                      Object... args)
                               throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将使用 Map 封装。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForMap 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForMap
```
public Map<String,Object> queryForMap(String sql,
                                      SqlParameterSource paramSource)
                               throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将使用 Map 封装。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForMap 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForMap
```
public Map<String,Object> queryForMap(String sql,
                                      Map<String,?> paramMap)
                               throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询结果将使用 Map 封装。
    预计该方法只会处理一条数据，如果查询结果存在多条数据将会取得第一条数据作为结果。
    
    指定者:
    
    queryForMap 在接口中 JdbcOperations
    
    抛出:
    
    SQLException - if the query fails
  - queryForList
```
public List<Map<String,Object>> queryForList(String sql)
                                      throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个静态 SQL 语句，结果将被映射到一个列表(一个条目为每一行)的对象，列表中每一条记录都是Map类型对象。
    
    指定者:
    
    queryForList 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - queryForList
```
public List<Map<String,Object>> queryForList(String sql,
                                             Object... args)
                                      throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询记录将会使用 Map 保存，并封装到 List 中。
    
    指定者:
    
    queryForList 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - queryForList
```
public List<Map<String,Object>> queryForList(String sql,
                                             SqlParameterSource paramSource)
                                      throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询记录将会使用 Map 保存，并封装到 List 中。
    
    指定者:
    
    queryForList 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - queryForList
```
public List<Map<String,Object>> queryForList(String sql,
                                             Map<String,?> paramMap)
                                      throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    查询一个 SQL 语句，使用这个查询将会使用 PreparedStatement 接口操作。查询记录将会使用 Map 保存，并封装到 List 中。
    
    指定者:
    
    queryForList 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - update
```
public int update(PreparedStatementCreator psc,
                  PreparedStatementSetter pss)
           throws SQLException
```
    抛出:
    
    SQLException
  - update
```
public int update(PreparedStatementCreator psc)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
    
    指定者:
    
    update 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - update
```
public int update(String sql)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一条 insert 或 update、delete 语句，返回值用于表示受影响的行数。
    
    指定者:
    
    update 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - update
```
public int update(String sql,
                  PreparedStatementSetter pss)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
    
    指定者:
    
    update 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - update
```
public int update(String sql,
                  Object... args)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
    
    指定者:
    
    update 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - update
```
public int update(String sql,
                  SqlParameterSource paramSource)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
    
    指定者:
    
    update 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - update
```
public int update(String sql,
                  Map<String,?> paramMap)
           throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    执行一个更新语句（insert、update、delete），这个查询将会使用 PreparedStatement 接口操作。
    
    指定者:
    
    update 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - batchUpdate
```
public int[] batchUpdate(String[] sql)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    批量执行 insert 或 update、delete 语句，返回值用于表示受影响的行数。
    
    指定者:
    
    batchUpdate 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - batchUpdate
```
public int[] batchUpdate(String sql,
                         Map<String,?>[] batchValues)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
    
    指定者:
    
    batchUpdate 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - batchUpdate
```
public int[] batchUpdate(String sql,
                         SqlParameterSource[] batchArgs)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
    
    指定者:
    
    batchUpdate 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - batchUpdate
```
public int[] batchUpdate(String sql,
                         BatchPreparedStatementSetter pss)
                  throws SQLException
```
    从接口复制的说明: JdbcOperations
    
    批量执行 insert 或 update、delete 语句，这一批次中的SQL 参数使用 BatchPreparedStatementSetter 接口设置。
    
    指定者:
    
    batchUpdate 在接口中 JdbcOperations
    
    抛出:
    
    SQLException
  - getColumnMapRowMapper
```
protected RowMapper<Map<String,Object>> getColumnMapRowMapper()
```
    Create a new RowMapper for reading columns as key-value pairs.
  - getBeanPropertyRowMapper
```
protected <T> RowMapper<T> getBeanPropertyRowMapper(Class<T> requiredType)
```
    Create a new RowMapper for reading columns as Bean pairs.
  - getSingleColumnRowMapper
```
protected <T> RowMapper<T> getSingleColumnRowMapper(Class<T> requiredType)
```
    Create a new RowMapper for reading result objects from a single column.
  - createResultsMap
```
protected Map<String,Object> createResultsMap()
```
    创建用于保存结果集的数据Map。
  - newArgPreparedStatementSetter
```
protected PreparedStatementSetter newArgPreparedStatementSetter(Object[] args)
                                                         throws SQLException
```
    Create a new PreparedStatementSetter.
    
    抛出:
    
    SQLException
  - getPreparedStatementCreator
```
protected PreparedStatementCreator getPreparedStatementCreator(String sql,
                                                               SqlParameterSource paramSource)
```
    Build a PreparedStatementCreator based on the given SQL and named parameters.
    Note: Not used for the update variant with generated key handling.
  - getParsedSql
```
protected ParsedSql getParsedSql(String originalSql)
```

类 JdbcTemplate

嵌套类概要

字段概要

从类继承的字段 net.hasor.db.jdbc.core.JdbcAccessor

构造器概要

方法概要

从类继承的方法 net.hasor.db.jdbc.core.JdbcConnection

从类继承的方法 net.hasor.db.jdbc.core.JdbcAccessor

从类继承的方法 java.lang.Object

从接口继承的方法 net.hasor.db.jdbc.JdbcOperations

构造器详细资料

JdbcTemplate

JdbcTemplate

JdbcTemplate

方法详细资料

isIgnoreWarnings

setIgnoreWarnings

isResultsCaseInsensitive

setResultsCaseInsensitive

loadSQL

loadSQL

loadSQL

execute

execute

execute

execute

execute

execute

execute

execute

query

query

query

query

query

query

query

query

query

query

query

query

query

query

query

query

query

query

query

query

query

query

queryForList

queryForList

queryForList

queryForList

queryForList

queryForObject

queryForObject

queryForObject

queryForObject

queryForObject

queryForObject

queryForObject

queryForObject

queryForObject

queryForObject

queryForLong

queryForLong

queryForLong

queryForLong

queryForInt

queryForInt

queryForInt

queryForInt

queryForMap

queryForMap

queryForMap

queryForMap

queryForList