spring-framework / org.springframework.jdbc.core / BeanPropertyRowMapper

BeanPropertyRowMapper

open class BeanPropertyRowMapper<T : Any> : RowMapper<T>

RowMapper implementation that converts a row into a new instance of the specified mapped target class. The mapped target class must be a top-level class and it must have a default or no-arg constructor.

Column values are mapped based on matching the column name as obtained from result set metadata to public setters for the corresponding properties. The names are matched either directly or by transforming a name separating the parts with underscores to the same name using "camel" case.

Mapping is provided for fields in the target class for many common types, e.g.: String, boolean, Boolean, byte, Byte, short, Short, int, Integer, long, Long, float, Float, double, Double, BigDecimal, java.util.Date, etc.

To facilitate mapping between columns and fields that don't have matching names, try using column aliases in the SQL statement like "select fname as first_name from customer".

For 'null' values read from the database, we will attempt to call the setter, but in the case of Java primitives, this causes a TypeMismatchException. This class can be configured (using the primitivesDefaultedForNullValue property) to trap this exception and use the primitives default value. Be aware that if you use the values from the generated bean to update the database the primitive value will have been set to the primitive's default value instead of null.

Please note that this class is designed to provide convenience rather than high performance. For best performance, consider using a custom RowMapper implementation.

Author
Thomas Risberg

Author
Juergen Hoeller

Since
2.5

Constructors

<init>

BeanPropertyRowMapper()

Create a new BeanPropertyRowMapper for bean-style configuration.

BeanPropertyRowMapper(mappedClass: Class<T>)

Create a new BeanPropertyRowMapper, accepting unpopulated properties in the target bean.

Consider using the #newInstance factory method instead, which allows for specifying the mapped type once only.

BeanPropertyRowMapper(mappedClass: Class<T>, checkFullyPopulated: Boolean)

Create a new BeanPropertyRowMapper.

Functions

getConversionService	`open fun getConversionService(): ConversionService` Return a ConversionService for binding JDBC values to bean properties, or `null` if none.
getMappedClass	`fun getMappedClass(): Class<T>` Get the class that we are mapping to.
isCheckFullyPopulated	`open fun isCheckFullyPopulated(): Boolean` Return whether we're strictly validating that all bean properties have been mapped from corresponding database fields.
isPrimitivesDefaultedForNullValue	`open fun isPrimitivesDefaultedForNullValue(): Boolean` Return whether we're defaulting Java primitives in the case of mapping a null value from corresponding database fields.
mapRow	`open fun mapRow(rs: ResultSet, rowNumber: Int): T` Extract the values for all columns in the current row. Utilizes public setters and result set metadata.
newInstance	`open static fun <T : Any> newInstance(mappedClass: Class<T>): BeanPropertyRowMapper<T>` Static factory method to create a new `BeanPropertyRowMapper` (with the mapped class specified only once).
setCheckFullyPopulated	`open fun setCheckFullyPopulated(checkFullyPopulated: Boolean): Unit` Set whether we're strictly validating that all bean properties have been mapped from corresponding database fields. Default is `false`, accepting unpopulated properties in the target bean.
setConversionService	`open fun setConversionService(conversionService: ConversionService): Unit` Set a ConversionService for binding JDBC values to bean properties, or `null` for none. Default is a DefaultConversionService, as of Spring 4.3. This provides support for `java.time` conversion and other special types.
setMappedClass	`open fun setMappedClass(mappedClass: Class<T>): Unit` Set the class that each row should be mapped to.
setPrimitivesDefaultedForNullValue	`open fun setPrimitivesDefaultedForNullValue(primitivesDefaultedForNullValue: Boolean): Unit` Set whether we're defaulting Java primitives in the case of mapping a null value from corresponding database fields. Default is `false`, throwing an exception when nulls are mapped to Java primitives.