org.jooq.impl

Class DefaultRecordMapper<R extends Record,E>

java.lang.Object

org.jooq.impl.DefaultRecordMapper<R,E>

All Implemented Interfaces:

RecordMapper<R,E>

public class DefaultRecordMapper<R extends Record,E>
extends Object
implements RecordMapper<R,E>

This is the default implementation for RecordMapper types.

The mapping algorithm is this:

If <E> is an array type:

The resulting array is of the nature described in Record.intoArray(). Arrays more specific than Object[] can be specified as well, e.g. String[]. If conversion to the element type of more specific arrays fails, a MappingException is thrown, wrapping conversion exceptions.

If a default constructor is available and any JPA Column annotations are found on the provided <E>, only those are used:

• If <E> contains public single-argument instance methods annotated with Column, those methods are invoked
• If <E> contains public no-argument instance methods starting with getXXX or isXXX, annotated with Column, then matching public setXXX() instance methods are invoked
• If <E> contains public instance member fields annotated with Column, those members are set

Additional rules:

• The same annotation can be re-used for several methods/members
• Column.name() must match Field.getName(). All other annotation attributes are ignored
• Static methods / member fields are ignored
• Final member fields are ignored

If a default constructor is available and if there are no JPA Column annotations, or jOOQ can't find the javax.persistence API on the classpath, jOOQ will map Record values by naming convention:

If Field.getName() is MY_field (case-sensitive!), then this field's value will be set on all of these:

• Public single-argument instance method MY_field(...)
• Public single-argument instance method myField(...)
• Public single-argument instance method setMY_field(...)
• Public single-argument instance method setMyField(...)
• Public non-final instance member field MY_field
• Public non-final instance member field myField

If no default constructor is available, but at least one constructor annotated with ConstructorProperties is available, that one is used

• The standard JavaBeans ConstructorProperties annotation is used to match constructor arguments against POJO members or getters.
• If those POJO members or getters have JPA annotations, those will be used according to the aforementioned rules, in order to map Record values onto constructor arguments.
• If those POJO members or getters don't have JPA annotations, the aforementioned naming conventions will be used, in order to map Record values onto constructor arguments.
• When several annotated constructors are found, the first one is chosen (as reported by Class.getDeclaredConstructors()
• When invoking the annotated constructor, values are converted onto constructor argument types

If no default constructor is available, but at least one "matching" constructor is available, that one is used

• A "matching" constructor is one with exactly as many arguments as this record holds fields
• When several "matching" constructors are found, the first one is chosen (as reported by Class.getDeclaredConstructors()
• When invoking the "matching" constructor, values are converted onto constructor argument types

If the supplied type is an interface or an abstract class

Abstract types are instanciated using Java reflection Proxy mechanisms. The returned proxy will wrap a HashMap containing properties mapped by getters and setters of the supplied type. Methods (even JPA-annotated ones) other than standard POJO getters and setters are not supported. Details can be seen in Reflect.as(Class).

Other restrictions

• <E> must provide a default or a "matching" constructor. Non-public default constructors are made accessible using AccessibleObject.setAccessible(boolean)
• primitive types are supported. If a value is null, this will result in setting the primitive type's default value (zero for numbers, or false for booleans). Hence, there is no way of distinguishing null and 0 in that case.

This mapper is returned by the DefaultRecordMapperProvider. You can override this behaviour by specifying your own custom RecordMapperProvider in Configuration.recordMapperProvider()

Author:

Lukas Eder

See Also:

RecordMapper, DefaultRecordMapperProvider, Configuration

Constructor Summary

Constructors

Constructor and Description
DefaultRecordMapper(RecordType<R> rowType, Class<? extends E> type)

Method Summary

Modifier and Type	Method and Description
E	map(R record) A callback method indicating that the next record has been fetched.

Methods inherited from class java.lang.Object

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

Constructor Detail

DefaultRecordMapper

public DefaultRecordMapper(RecordType<R> rowType,
                           Class<? extends E> type)

Method Detail

map

public final E map(R record)

Description copied from interface: RecordMapper

A callback method indicating that the next record has been fetched.

Specified by:

map in interface RecordMapper<R extends Record,E>