RdbmsOperation (Spring Framework) - Spring Framework 1.2.9 API 文档英文版

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.springframework.jdbc.object
Class RdbmsOperation

java.lang.Object
  org.springframework.jdbc.object.RdbmsOperation

All Implemented Interfaces:: InitializingBean

Direct Known Subclasses:: SqlCall, SqlOperation

public abstract class RdbmsOperation
extends Object
implements InitializingBean
extends Object
implements InitializingBean

An "RDBMS operation" is a multithreaded, reusable object representing a query, update or stored procedure. An RDBMS operation is not a command, as a command isn't reusable. However, execute methods may take commands as arguments. Subclasses should be Java beans, allowing easy configuration.

Root of the JDBC object hierarchy, as described in Chapter 9 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).

This class and subclasses throw runtime exceptions, defined in the (and as thrown by the org.springframework.jdbc.core package, which the classes in this package use under the hood to perform raw JDBC operations).

Subclasses should set SQL and add parameters before invoking the compile() method. The order in which parameters are added is significant. The appropriate execute or update method can then be invoked.

Author:: Rod Johnson, Juergen Hoeller
See Also:: compile(), org.springframework.dao, org.springframework.jdbc.core

Field Summary

protected Log logger


Constructor Summary

RdbmsOperation()


Method Summary

void afterPropertiesSet()
          Ensures compilation if used in a bean factory.

protected boolean allowsUnusedParameters()
          Return whether this operation accepts additional parameters that are given but not actually used.

protected void checkCompiled()
          Check whether this operation has been compiled already; lazily compile it if not already compiled.

void compile()
          Compile this query.

protected abstract void compileInternal()
          Subclasses must implement to perform their own compilation.

void declareParameter(SqlParameter param)
          Declare a parameter.

protected List getDeclaredParameters()
          Return a list of the declared SqlParameter objects.

String[] getGeneratedKeysColumnNames()
          Return the column names of the auto generated keys.

JdbcTemplate getJdbcTemplate()
          Return the JdbcTemplate object used by this object.

int getResultSetType()
          Return whether statements will return a specific type of ResultSet.

String getSql()
          Subclasses can override this to supply dynamic SQL if they wish, but SQL is normally set by calling the setSql() method or in a subclass constructor.

boolean isCompiled()
          Is this operation "compiled"?

boolean isReturnGeneratedKeys()
          Return whether statements should be capable of returning auto-generated keys.

boolean isUpdatableResults()
          Return whether statements will return updatable ResultSets.

void setDataSource(DataSource dataSource)
          Set the JDBC DataSource to obtain connections from.

void setFetchSize(int fetchSize)
          Set the fetch size for this RDBMS operation.

void setGeneratedKeysColumnNames(String[] names)
          Set the column names of the auto-generated keys.

void setJdbcTemplate(JdbcTemplate jdbcTemplate)
          An alternative to the more commonly used setDataSource() when you want to use the same JdbcTemplate in multiple RdbmsOperations.

void setMaxRows(int maxRows)
          Set the maximum number of rows for this RDBMS operation.

void setResultSetType(int resultSetType)
          Set whether to use statements that return a specific type of ResultSet.

void setReturnGeneratedKeys(boolean returnGeneratedKeys)
          Set whether prepared statements should be capable of returning auto-generated keys.

void setSql(String sql)
          Set the SQL executed by this operation.

void setTypes(int[] types)
          Add anonymous parameters, specifying only their SQL types as defined in the java.sql.Types class.

void setUpdatableResults(boolean updatableResults)
          Set whether to use statements that are capable of returning updatable ResultSets.

protected boolean supportsLobParameters()
          Return whether BLOB or CLOB parameters are supported for this kind of operation.

protected void validateParameters(Object[] parameters)
          Validate the parameters passed to an execute method based on declared parameters.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Summary
`protected Log`	`logger`

Constructor Summary
`RdbmsOperation()`

Method Summary
`void`	`afterPropertiesSet()` Ensures compilation if used in a bean factory.
`protected boolean`	`allowsUnusedParameters()` Return whether this operation accepts additional parameters that are given but not actually used.
`protected void`	`checkCompiled()` Check whether this operation has been compiled already; lazily compile it if not already compiled.
`void`	`compile()` Compile this query.
`protected abstract void`	`compileInternal()` Subclasses must implement to perform their own compilation.
`void`	`declareParameter(SqlParameter param)` Declare a parameter.
`protected List`	`getDeclaredParameters()` Return a list of the declared SqlParameter objects.
`String[]`	`getGeneratedKeysColumnNames()` Return the column names of the auto generated keys.
`JdbcTemplate`	`getJdbcTemplate()` Return the JdbcTemplate object used by this object.
`int`	`getResultSetType()` Return whether statements will return a specific type of ResultSet.
`String`	`getSql()` Subclasses can override this to supply dynamic SQL if they wish, but SQL is normally set by calling the setSql() method or in a subclass constructor.
`boolean`	`isCompiled()` Is this operation "compiled"?
`boolean`	`isReturnGeneratedKeys()` Return whether statements should be capable of returning auto-generated keys.
`boolean`	`isUpdatableResults()` Return whether statements will return updatable ResultSets.
`void`	`setDataSource(DataSource dataSource)` Set the JDBC DataSource to obtain connections from.
`void`	`setFetchSize(int fetchSize)` Set the fetch size for this RDBMS operation.
`void`	`setGeneratedKeysColumnNames(String[] names)` Set the column names of the auto-generated keys.
`void`	`setJdbcTemplate(JdbcTemplate jdbcTemplate)` An alternative to the more commonly used setDataSource() when you want to use the same JdbcTemplate in multiple RdbmsOperations.
`void`	`setMaxRows(int maxRows)` Set the maximum number of rows for this RDBMS operation.
`void`	`setResultSetType(int resultSetType)` Set whether to use statements that return a specific type of ResultSet.
`void`	`setReturnGeneratedKeys(boolean returnGeneratedKeys)` Set whether prepared statements should be capable of returning auto-generated keys.
`void`	`setSql(String sql)` Set the SQL executed by this operation.
`void`	`setTypes(int[] types)` Add anonymous parameters, specifying only their SQL types as defined in the `java.sql.Types` class.
`void`	`setUpdatableResults(boolean updatableResults)` Set whether to use statements that are capable of returning updatable ResultSets.
`protected boolean`	`supportsLobParameters()` Return whether BLOB or CLOB parameters are supported for this kind of operation.
`protected void`	`validateParameters(Object[] parameters)` Validate the parameters passed to an execute method based on declared parameters.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

logger

protected final Log logger

Constructor Detail

RdbmsOperation

public RdbmsOperation()

Method Detail

setJdbcTemplate

public void setJdbcTemplate(JdbcTemplate jdbcTemplate)

An alternative to the more commonly used setDataSource() when you want to use the same JdbcTemplate in multiple RdbmsOperations. This is appropriate if the JdbcTemplate has special configuration such as a SQLExceptionTranslator that should apply to multiple RdbmsOperation objects.

getJdbcTemplate

public JdbcTemplate getJdbcTemplate()

Return the JdbcTemplate object used by this object.

setDataSource

public void setDataSource(DataSource dataSource)

Set the JDBC DataSource to obtain connections from.

See Also:: JdbcAccessor.setDataSource(javax.sql.DataSource)

setFetchSize

public void setFetchSize(int fetchSize)

Set the fetch size for this RDBMS operation. This is important for processing large result sets: Setting this higher than the default value will increase processing speed at the cost of memory consumption; setting this lower can avoid transferring row data that will never be read by the application.

Default is 0, indicating to use the driver's default.

See Also:: JdbcTemplate.setFetchSize(int)

setMaxRows

public void setMaxRows(int maxRows)

Set the maximum number of rows for this RDBMS operation. This is important for processing subsets of large result sets, avoiding to read and hold the entire result set in the database or in the JDBC driver.

Default is 0, indicating to use the driver's default.

See Also:: JdbcTemplate.setMaxRows(int)

setResultSetType

public void setResultSetType(int resultSetType)

Set whether to use statements that return a specific type of ResultSet.

Parameters:: resultSetType - the ResultSet type
See Also:: ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.TYPE_SCROLL_SENSITIVE, Connection.prepareStatement(String, int, int)

getResultSetType

public int getResultSetType()

Return whether statements will return a specific type of ResultSet.

setUpdatableResults

public void setUpdatableResults(boolean updatableResults)

Set whether to use statements that are capable of returning updatable ResultSets.

See Also:: Connection.prepareStatement(String, int, int)

isUpdatableResults

public boolean isUpdatableResults()

Return whether statements will return updatable ResultSets.

setReturnGeneratedKeys

public void setReturnGeneratedKeys(boolean returnGeneratedKeys)

Set whether prepared statements should be capable of returning auto-generated keys.

See Also:: Connection.prepareStatement(String, int)

isReturnGeneratedKeys

public boolean isReturnGeneratedKeys()

Return whether statements should be capable of returning auto-generated keys.

setGeneratedKeysColumnNames

public void setGeneratedKeysColumnNames(String[] names)

Set the column names of the auto-generated keys.

See Also:: Connection.prepareStatement(String, String[])

getGeneratedKeysColumnNames

public String[] getGeneratedKeysColumnNames()

Return the column names of the auto generated keys.

setSql

public void setSql(String sql)

Set the SQL executed by this operation.

getSql

public String getSql()

Subclasses can override this to supply dynamic SQL if they wish, but SQL is normally set by calling the setSql() method or in a subclass constructor.

setTypes

public void setTypes(int[] types)
              throws InvalidDataAccessApiUsageException

Add anonymous parameters, specifying only their SQL types as defined in the java.sql.Types class.

Parameter ordering is significant. This method is an alternative to the declareParameter() method, which should normally be preferred.

Parameters:: types - array of SQL types as defined in the java.sql.Types class
Throws:: InvalidDataAccessApiUsageException - if the operation is already compiled

declareParameter

public void declareParameter(SqlParameter param)
                      throws InvalidDataAccessApiUsageException

Declare a parameter. The order in which this method is called is significant.

Parameters:: param - SqlParameter to add. This will specify SQL type and (optionally) the parameter's name.
Throws:: InvalidDataAccessApiUsageException - if the operation is already compiled, and hence cannot be configured further

getDeclaredParameters

protected List getDeclaredParameters()

Return a list of the declared SqlParameter objects.

afterPropertiesSet

public void afterPropertiesSet()

Ensures compilation if used in a bean factory.

Specified by:: afterPropertiesSet in interface InitializingBean

compile

public final void compile()
                   throws InvalidDataAccessApiUsageException

Compile this query. Ignores subsequent attempts to compile.

Throws:: InvalidDataAccessApiUsageException - if the object hasn't been correctly initialized, for example if no DataSource has been provided

compileInternal

protected abstract void compileInternal()
                                 throws InvalidDataAccessApiUsageException

Subclasses must implement to perform their own compilation. Invoked after this class's compilation is complete.

Subclasses can assume that SQL has been supplied and that a DataSource has been supplied.

Throws:: InvalidDataAccessApiUsageException - if the subclass hasn't been properly configured.

isCompiled

public boolean isCompiled()

Is this operation "compiled"? Compilation, as in JDO, means that the operation is fully configured, and ready to use. The exact meaning of compilation will vary between subclasses.

Returns:: whether this operation is compiled, and ready to use.

checkCompiled

protected void checkCompiled()

Check whether this operation has been compiled already; lazily compile it if not already compiled.

Automatically called by validateParameters.

See Also:: validateParameters(java.lang.Object[])

validateParameters

protected void validateParameters(Object[] parameters)
                           throws InvalidDataAccessApiUsageException

Validate the parameters passed to an execute method based on declared parameters. Subclasses should invoke this method before every executeQuery() or update() method.

Parameters:: parameters - parameters supplied (may be null)
Throws:: InvalidDataAccessApiUsageException - if the parameters are invalid

supportsLobParameters

protected boolean supportsLobParameters()

Return whether BLOB or CLOB parameters are supported for this kind of operation. Default is "true".

allowsUnusedParameters

protected boolean allowsUnusedParameters()

Return whether this operation accepts additional parameters that are given but not actually used. Applies in particular to parameter Maps.

See Also:: StoredProcedure