There is only one change, but it is a big one.

All conversion methods now allow you to pass tags. These tags can be used when defining the mapping. Once a field has a @MapOnly annotation on it, the conversion will only occur if the annotation contains that tag. To allow different behaviour for different tags, you can put several MapOnly annotation on a field by combining them in a @MapOnlies annotation.

By default, the “*” tag is always prepended to the list of tags, so using a field declaration like

@MapOnlies({
        @MapOnly("create"),
        @MapOnly(value =  "*", readOnly = true)
})
private String somefield;

makes sure that the field is always read-only except when the “create” tag is passed, in which case the value will also be copied back to the domain object.

The MapOnly annotation can include readOnly and typeConverter parameters. If no type converter is specified on the MapOnly, then the type converter from the MappedBy annotation (if any- is used.

Read it here.

This release is the result of some features which were useful for a real world integration for Flemish Government.

The following features were added:

• List type converters should be able to reuse existing lists on target fields. This is important for Hibernate integration. This is done by default but can be switched off.
• Do not require an actual field on the domain object, accessors should be enough.
• Allow polymorphism on transfer object.
• Add option on ListTypeConverter whether null should be kept or converted to empty list.
• Add convertList() which converts a list of objects.
• Allow sorting in ListTypeConverter.

You can view the full list of issues on github.

The focus for this release was improved integration with Hibernate and adding a demo.

The following features were added:

• A demo module was added which uses Hibernate and Lombok.
• Conversion now uses getters and setters on the domain objects as this is needed to avoid problems with Hibernate lazy loading.
• Collections need special handling, add base type converter which accepts the type of the transfer objects.
• Add type converter which does update linked objects but does not update objects in the domain. Very practical to control links between objects without allowing the objects themselves to be modified.

Additionally a few bugs were fixed.

You can view the full list of issues on github.

Release early, release often.

Only a day after the previous release, time for an extra feature. You can now specify a path on the @MappedBy annotation. This allows you to map fields which are found in a linked object in the domain object. Note that the linked object needs to exist to be able to convert from the transfer object to the domain object. When the dependency is several levels deep, then separate the names using a dot in the path parameter.

The artefacts are available on maven central.

<dependency>
    <groupId>org.jtransfo</groupId>
    <artifactId>jtransfo-core</artifactId>
    <version>0.4</version>
</dependency>

<dependency>
    <groupId>org.jtransfo</groupId>
    <artifactId>jtransfo-spring</artifactId>
    <version>0.4</version>
</dependency>
<dependency>
    <groupId>org.jtransfo</groupId>
    <artifactId>jtransfo-joda-time</artifactId>
    <version>0.4</version>
</dependency>

Registration of object finders has changed to make it more thread safe and consistent with registration of type converters. You now have to call updateObjectFinders after changing the object finders list.

Spring integration module added

• Object finders and type converters which are available in the application context are automatically added in the jTransfo bean.
• Looks for additional bean definitions in META-INF/jTransfoContext.xml in all jars.

joda-time integration module added

• This currently supports conversion between Date (transfer object side) and either DateTime or DateMidnight at domain object side.
• The converters are automatically added when spring integration is used.

This release adds support for object finders and type conversion.

You can register object finders which allow you to specify how base domain objects need to be obtained for a transfer object. The default (fall-back) is still to use the no-arguments constructor., but you could for example plug-in a database search based on the object id.

You can also register type converters. These allow you to define how types can be converted.

The artefacts are available through maven central using the following GAV:

<dependency>
    <groupId>org.jtransfo</groupId>
    <artifactId>jtransfo-core<artifactId>
    <version>0.1<version>
</depencendy>

The source is available on github: https://github.com/joachimvda/jtransfo.