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.

For a NULL value read from the database, an attempt will be made to call the corresponding setter method with null, but in the case of Java primitives this will result in a TypeMismatchException by default. To ignore NULL database values for all primitive properties in the target class, set the primitivesDefaultedForNullValue flag to true. See setPrimitivesDefaultedForNullValue(boolean) for details.

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é, Thomas Risberg, Juergen Hoeller, Sam Brannen
See Also:

  • Field Details

    • logger

      protected final Log logger
      Logger available to subclasses.

  • Constructor Details

    • BeanPropertyRowMapper

      public BeanPropertyRowMapper(Class<T> mappedClass)
      Create a new BeanPropertyRowMapper, accepting unpopulated properties in the target bean.
      Parameters:
      mappedClass - the class that each row/outParameters should be mapped to

    • BeanPropertyRowMapper

      public BeanPropertyRowMapper(Class<T> mappedClass, boolean checkFullyPopulated)
      Create a new BeanPropertyRowMapper.
      Parameters:
      mappedClass - the class that each row should be mapped to
      checkFullyPopulated - whether we're strictly validating that all bean properties have been mapped from corresponding database columns or out-parameters

  • Method Details

    • getMappedClass

      @Nullable public final Class<T> getMappedClass()
      Get the class that we are mapping to.

    • setCheckFullyPopulated

      public void setCheckFullyPopulated(boolean checkFullyPopulated)
      Set whether we're strictly validating that all bean properties have been mapped from corresponding database columns or out-parameters.

      Default is false, accepting unpopulated properties in the target bean.

    • isCheckFullyPopulated

      public boolean isCheckFullyPopulated()
      Return whether we're strictly validating that all bean properties have been mapped from corresponding database columns or out-parameters.

    • setPrimitivesDefaultedForNullValue

      public void setPrimitivesDefaultedForNullValue(boolean primitivesDefaultedForNullValue)
      Set whether a NULL database column or out-parameter value should be ignored when mapping to a corresponding primitive property in the target class.

      Default is false, throwing an exception when nulls are mapped to Java primitives.

      If this flag is set to true and you use an ignored primitive property value from the mapped bean to update the database, the value in the database will be changed from NULL to the current value of that primitive property. That value may be the property's initial value (potentially Java's default value for the respective primitive type), or it may be some other value set for the property in the default constructor (or initialization block) or as a side effect of setting some other property in the mapped bean.

    • isPrimitivesDefaultedForNullValue

      public boolean isPrimitivesDefaultedForNullValue()
      Get the value of the primitivesDefaultedForNullValue flag.
      See Also:

    • setConversionService

      public void setConversionService(@Nullable ConversionService conversionService)
      Set a ConversionService for binding R2DBC values to bean properties, or null for none.

      Default is a DefaultConversionService. This provides support for java.time conversion and other special types.

      See Also:

    • getConversionService

      @Nullable public ConversionService getConversionService()
      Return a ConversionService for binding R2DBC values to bean properties, or null if none.

    • initialize

      protected void initialize(Class<T> mappedClass)
      Initialize the mapping meta-data for the given class.
      Parameters:
      mappedClass - the mapped class

    • 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

    • initBeanWrapper

      protected void initBeanWrapper(BeanWrapper bw)
      Initialize the given BeanWrapper to be used for row mapping or outParameters mapping.

      To be called for each Readable.

      The default implementation applies the configured ConversionService, if any. Can be overridden in subclasses.

      Parameters:
      bw - the BeanWrapper to initialize
      See Also:

    • getItemValue

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

      The default implementation delegates to getItemValue(Readable, int, Class).

      Parameters:
      readable - is the Row or OutParameters holding the data
      itemIndex - is the column index or out-parameter index
      pd - the bean property that each result object is expected to match
      Returns:
      the Object value
      See Also:

    • 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:

    • newInstance

      public static <T> BeanPropertyRowMapper<T> newInstance(Class<T> mappedClass)
      Static factory method to create a new BeanPropertyRowMapper.
      Parameters:
      mappedClass - the class that each row should be mapped to
      See Also:

    • newInstance

      public static <T> BeanPropertyRowMapper<T> newInstance(Class<T> mappedClass, @Nullable ConversionService conversionService)
      Static factory method to create a new BeanPropertyRowMapper.
      Parameters:
      mappedClass - the class that each row should be mapped to
      conversionService - the ConversionService for binding R2DBC values to bean properties, or null for none
      See Also: