Support for java.time

[nicoschl]

@bjansen

I can donate some of my existing code for handling some of the java.time classes. I don't have too many TypeHandlers implemented but the basic ones should be there to handle java.time.LocalDate, java.time.LocalTime and java.time.LocalDateTime. It could perhaps be the starting point for the other java.time classes.

[bjansen]

That would be great! I think I also have similar type handlers somewhere in a previous project. I wonder if we have to use a different type handler for each class (and also ZonedDateTime, OffsetDateTime et al.), or if it would be possible to reuse code across all types?

Also, this means that BeanIO 3 will have a minimal requirement of Java 8 instead of Java 7 currently.

[nicoschl]

I think we would probably need a class per TypeHandler, but they could all potentially extend some abstract implementation that handles all the necessary stuff and the concrete implementations would probably only require overriding 1 or 2 small methods, like org.beanio.types.TypeHandler#getType()

Also, this means that BeanIO 3 will have a minimal requirement of Java 8 instead of Java 7 currently.

True, but I don't think bumping the min to Java 8 would be a problem, The code base could probably use a lot of the new Java 8 features elsewhere as well.

[bjansen]

Here's what I used:

import org.beanio.types.ConfigurableTypeHandler;
import org.beanio.types.TypeHandler;

import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
import java.util.Properties;

public class TemporalAccessorTypeHandler implements ConfigurableTypeHandler {

    private DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME;
    private Class<?> type = TemporalAccessor.class;

    @Override
    public TypeHandler newInstance(Properties properties) {
        String pattern = properties.getProperty(FORMAT_SETTING);
        if (pattern == null || "".equals(pattern)) {
            return this;
        }

        DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern(pattern);

        if (newFormatter.equals(this.formatter)) {
            return this;
        }

        TemporalAccessorTypeHandler clone = new TemporalAccessorTypeHandler();
        clone.type = type;
        clone.formatter = newFormatter;
        return clone;
    }

    @Override
    public Object parse(String text) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String format(Object value) {
        if (value == null) {
            return null;
        }
        TemporalAccessor temporalAccessor = (TemporalAccessor) value;
        return formatter.format(temporalAccessor);
    }

    public void setTypeName(String typeName) throws ClassNotFoundException {
        type = Class.forName(typeName);
    }

    @Override
    public Class<?> getType() {
        return type;
    }
}

I only had to format values, that's why parse() throws an exception at the moment. I registered this type handler multiple times using a different typeName. I guess we could do something similar in TypeHandlerFactory (even using Class directly instead of String!).

The code base could probably use a lot of the new Java 8 features elsewhere as well.

Yep, I think it's worth it. People stuck with Java 1.7 probably have created their own fixes anyway :)

[bjansen]

Here's what I have so far: https://github.com/beanio/beanio/blob/33e3461b28c1b7be14edd5c5fddd3b219cc9ada9/src/org/beanio/types/TemporalAccessorTypeHandler.java

It's a single class that's registered multiple times in the TypeHandlerFactory with different configurations:

        defaultFactory.registerHandlerFor(
            LocalDate.class,
            new TemporalAccessorTypeHandler(LocalDate.class, DateTimeFormatter.ISO_LOCAL_DATE)
        );
        defaultFactory.registerHandlerFor(
            LocalTime.class,
            new TemporalAccessorTypeHandler(LocalTime.class, DateTimeFormatter.ISO_LOCAL_TIME)
        );
...

It uses ISO formats by default, but users can define their own formats like this:

    <record name="rec" class="org.beanio.beans.JavaTime" occurs="1">
      <field name="localDateTime" length="17" format="dd/MM/yy HH:mm:ss"/>
    </record>

And for subclasses of java.time.temporal.TemporalAccessor that are not supported natively by BeanIO, subclassing the type handler and doing something like this should be enough I suppose:

    @Override
    public TemporalAccessor parse(String text) throws TypeConversionException {
        return DayOfWeek.from(super.parse(text));
    }

[nicoschl]

Yes, that looks good. I agree that the default handlers should make use of the ISO patterns

[willsoto]

Hey @bjansen - it looks like this was merged in as part of #144 but has it been released? I am using 3.0.0.M1 and it doesn't seem liked any of the java.time.* classes are working. I get the following when attempting to use LocalDate or ZonedDateTime:

Type handler not found for type 'java.time.LocalDate'
Type handler not found for type 'java.time.ZonedDateTime'

Thanks for all the great work on this project!

[Manfred73]

I'm also getting Type handler not found for type 'java.time.LocalDate'
When having a field defined as:

@Field(at = 28, length = 8, format = "yyyyMMdd")
private LocalDate date;

[bjansen]

@willsoto @Manfred73 sorry for the (very) late reply. Support for java.time hasn't been released yet: 3.0.0.M1...main

I'll release a new milestone.

[bjansen]

3.0.0.M2 is now available on Central!

[Manfred73]

Great, this is working now.