Package org.springframework.r2dbc.core

Class BeanPropertyRowMapper<T>

java.lang.Object
org.springframework.r2dbc.core.BeanPropertyRowMapper<T>
Type Parameters:
T - the result type
All Implemented Interfaces:
Function<Readable,T>
Direct Known Subclasses:
DataClassRowMapper
public class BeanPropertyRowMapper<T> extends Object implements Function<Readable,T>
Mapping Function implementation that converts an R2DBC Readable (a Row or OutParameters) into a new instance of the specified mapped target class. The mapped target class must be a top-level class or static nested class, and it must have a default or no-arg constructor.

Readable component values are mapped based on matching the column name (as obtained from R2DBC meta-data) to public setters in the target class 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 properties in the target class for many common types — for example: 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 properties that don't have matching names, try using column aliases in the SQL statement like "select fname as first_name from customer", where first_name can be mapped to a setFirstName(String) method in the target class.

If you need to map to a target class which has a data class constructor — for example, a Java record or a Kotlin data class — use DataClassRowMapper instead.

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

Since:
6.1
Author:
Simon Baslé, Juergen Hoeller, Sam Brannen
See Also:

  • Constructor Details

    • BeanPropertyRowMapper

      public BeanPropertyRowMapper(Class<T> mappedClass)
      Create a new BeanPropertyRowMapper.
      Parameters:
      mappedClass - the class that each row should be mapped to

    • BeanPropertyRowMapper

      public BeanPropertyRowMapper(Class<T> mappedClass, ConversionService conversionService)
      Create a new BeanPropertyRowMapper.
      Parameters:
      mappedClass - the class that each row should be mapped to
      conversionService - a ConversionService for binding result values to bean properties

  • Method Details

    • suppressProperty

      protected void suppressProperty(String propertyName)
      Remove the specified property from the mapped properties.
      Parameters:
      propertyName - the property name (as used by property descriptors)

    • lowerCaseName

      protected String lowerCaseName(String name)
      Convert the given name to lower case.

      By default, conversions will happen within the US locale.

      Parameters:
      name - the original name
      Returns:
      the converted name

    • underscoreName

      protected String underscoreName(String name)
      Convert a name in camelCase to an underscored name in lower case.

      Any upper case letters are converted to lower case with a preceding underscore.

      Parameters:
      name - the original name
      Returns:
      the converted name
      See Also:

    • apply

      public T apply(Readable readable)
      Extract the values for the current Readable: all columns in case of a Row or all parameters in case of an OutParameters.

      Utilizes public setters and derives meta-data from the concrete type.

      Specified by:
      apply in interface Function<Readable,T>
      Throws:
      IllegalArgumentException - in case the concrete type is neither Row nor OutParameters
      See Also:

    • constructMappedInstance

      protected T constructMappedInstance(Readable readable, List<? extends ReadableMetadata> itemMetadatas, TypeConverter tc)
      Construct an instance of the mapped class for the current Readable.

      The default implementation simply instantiates the mapped class. Can be overridden in subclasses.

      Parameters:
      readable - the Readable being mapped (a Row or OutParameters)
      itemMetadatas - the list of item ReadableMetadata (either ColumnMetadata or OutParameterMetadata)
      tc - a TypeConverter with this row mapper's conversion service
      Returns:
      a corresponding instance of the mapped class

    • getItemValue

      @Nullable protected Object getItemValue(Readable readable, int itemIndex, Class<?> paramType)
      Retrieve an R2DBC object value for the specified item index (a column or an out-parameter).

      The default implementation calls Readable.get(int, Class) then falls back to Readable.get(int) in case of an exception. Subclasses may override this to check specific value types upfront, or to post-process values returned from get.

      Parameters:
      readable - is the Row or OutParameters holding the data
      itemIndex - is the column index or out-parameter index
      paramType - the target parameter type
      Returns:
      the Object value
      See Also: