Initial support for JDK 8 Date-Time (JSR-310)

This is largely derived from our existing Joda-Time support, with corresponding classes wherever possible.

Issue: SPR-9641

spring-context/src/main/java/org/springframework/format/datetime/standard/DateTimeContext.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.format.datetime.standard;
+
+import java.time.ZoneId;
+import java.time.chrono.Chronology;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * A context that holds user-specific <code>java.time</code> (JSR-310) settings
+ * such as the user's Chronology (calendar system) and time zone.
+ * A {@code null} property value indicate the user has not specified a setting.
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ * @see DateTimeContextHolder
+ */
+public class DateTimeContext {
+
+	private Chronology chronology;
+
+	private ZoneId timeZone;
+
+
+	/**
+	 * Set the user's chronology.
+	 */
+	public void setChronology(Chronology chronology) {
+		this.chronology = chronology;
+	}
+
+	/**
+	 * The user's chronology (calendar system), if any.
+	 */
+	public Chronology getChronology() {
+		return this.chronology;
+	}
+
+	/**
+	 * Set the user's timezone.
+	 */
+	public void setTimeZone(ZoneId timeZone) {
+		this.timeZone = timeZone;
+	}
+
+	/**
+	 * The user's timezone, if any.
+	 */
+	public ZoneId getTimeZone() {
+		return timeZone;
+	}
+
+
+	/**
+	 * Get the DateTimeFormatter with the this context's settings
+	 * applied to the base {@code formatter}.
+	 * @param formatter the base formatter that establishes default
+	 * formatting rules, generally context-independent
+	 * @return the contextual DateTimeFormatter
+	 */
+	public DateTimeFormatter getFormatter(DateTimeFormatter formatter) {
+		if (this.chronology != null) {
+			formatter = formatter.withChronology(this.chronology);
+		}
+		if (this.timeZone != null) {
+			formatter = formatter.withZone(this.timeZone);
+		}
+		return formatter;
+	}
+
+}

spring-context/src/main/java/org/springframework/format/datetime/standard/DateTimeContextHolder.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.format.datetime.standard;
+
+import java.time.format.DateTimeFormatter;
+import java.util.Locale;
+
+import org.springframework.core.NamedThreadLocal;
+
+/**
+ * A holder for a thread-local user {@link DateTimeContext}.
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ */
+public final class DateTimeContextHolder {
+
+	private static final ThreadLocal<DateTimeContext> dateTimeContextHolder =
+			new NamedThreadLocal<DateTimeContext>("DateTime Context");
+
+
+	/**
+	 * Reset the DateTimeContext for the current thread.
+	 */
+	public static void resetDateTimeContext() {
+		dateTimeContextHolder.remove();
+	}
+
+	/**
+	 * Associate the given DateTimeContext with the current thread.
+	 * @param dateTimeContext the current DateTimeContext,
+	 * or {@code null} to reset the thread-bound context
+	 */
+	public static void setDateTimeContext(DateTimeContext dateTimeContext) {
+		if (dateTimeContext == null) {
+			resetDateTimeContext();
+		}
+		else {
+			dateTimeContextHolder.set(dateTimeContext);
+		}
+	}
+
+	/**
+	 * Return the DateTimeContext associated with the current thread, if any.
+	 * @return the current DateTimeContext, or {@code null} if none
+	 */
+	public static DateTimeContext getDateTimeContext() {
+		return dateTimeContextHolder.get();
+	}
+
+
+	/**
+	 * Obtain a DateTimeFormatter with user-specific settings applied to the given base Formatter.
+	 * @param formatter the base formatter that establishes default formatting rules
+	 * (generally user independent)
+	 * @param locale the current user locale (may be {@code null} if not known)
+	 * @return the user-specific DateTimeFormatter
+	 */
+	public static DateTimeFormatter getFormatter(DateTimeFormatter formatter, Locale locale) {
+		DateTimeFormatter formatterToUse = (locale != null ? formatter.withLocale(locale) : formatter);
+		DateTimeContext context = getDateTimeContext();
+		return (context != null ? context.getFormatter(formatterToUse) : formatterToUse);
+	}
+
+}

spring-context/src/main/java/org/springframework/format/datetime/standard/DateTimeFormatterFactory.java

@@ -0,0 +1,211 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.format.datetime.standard;
+
+import java.time.format.DateTimeFormatter;
+import java.time.format.FormatStyle;
+import java.util.TimeZone;
+
+import org.springframework.format.annotation.DateTimeFormat.ISO;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+/**
+ * Factory that creates a JSR-310 {@link java.time.format.DateTimeFormatter}.
+ *
+ * <p>Formatters will be created using the defined {@link #setPattern pattern},
+ * {@link #setIso ISO}, and <code>xxxStyle</code> methods (considered in that order).
+ *
+ * @author Juergen Hoeller
+ * @author Phillip Webb
+ * @since 4.0
+ * @see #createDateTimeFormatter()
+ * @see #createDateTimeFormatter(DateTimeFormatter)
+ * @see #setPattern
+ * @see #setIso
+ * @see #setDateStyle
+ * @see #setTimeStyle
+ * @see #setDateTimeStyle
+ * @see DateTimeFormatterFactoryBean
+ */
+public class DateTimeFormatterFactory {
+
+	private String pattern;
+
+	private ISO iso;
+
+	private FormatStyle dateStyle;
+
+	private FormatStyle timeStyle;
+
+	private TimeZone timeZone;
+
+
+	/**
+	 * Create a new {@code DateTimeFormatterFactory} instance.
+	 */
+	public DateTimeFormatterFactory() {
+	}
+
+	/**
+	 * Create a new {@code DateTimeFormatterFactory} instance.
+	 * @param pattern the pattern to use to format date values
+	 */
+	public DateTimeFormatterFactory(String pattern) {
+		this.pattern = pattern;
+	}
+
+
+	/**
+	 * Set the pattern to use to format date values.
+	 * @param pattern the format pattern
+	 */
+	public void setPattern(String pattern) {
+		this.pattern = pattern;
+	}
+
+	/**
+	 * Set the ISO format used to format date values.
+	 * @param iso the ISO format
+	 */
+	public void setIso(ISO iso) {
+		this.iso = iso;
+	}
+
+	/**
+	 * Set the style to use for date types.
+	 */
+	public void setDateStyle(FormatStyle dateStyle) {
+		this.dateStyle = dateStyle;
+	}
+
+	/**
+	 * Set the style to use for time types.
+	 */
+	public void setTimeStyle(FormatStyle timeStyle) {
+		this.timeStyle = timeStyle;
+	}
+
+	/**
+	 * Set the style to use for date and time types.
+	 */
+	public void setDateTimeStyle(FormatStyle dateTimeStyle) {
+		this.dateStyle = dateTimeStyle;
+		this.timeStyle = dateTimeStyle;
+	}
+
+	/**
+	 * Set the two characters to use to format date values, in Joda-Time style.
+	 * <p>The first character is used for the date style; the second is for
+	 * the time style. Supported characters are:
+	 * <ul>
+	 * <li>'S' = Small</li>
+	 * <li>'M' = Medium</li>
+	 * <li>'L' = Long</li>
+	 * <li>'F' = Full</li>
+	 * <li>'-' = Omitted</li>
+	 * </ul>
+	 * <p>This method mimics the styles supported by Joda-Time. Note that
+	 * JSR-310 natively favors {@link java.time.format.FormatStyle} as used for
+	 * {@link #setDateStyle}, {@link #setTimeStyle} and {@link #setDateTimeStyle}.
+	 * @param style two characters from the set {"S", "M", "L", "F", "-"}
+	 */
+	public void setStylePattern(String style) {
+		Assert.isTrue(style != null && style.length() == 2);
+		this.dateStyle = convertStyleCharacter(style.charAt(0));
+		this.timeStyle = convertStyleCharacter(style.charAt(1));
+	}
+
+	private FormatStyle convertStyleCharacter(char c) {
+		switch (c) {
+			case 'S': return FormatStyle.SHORT;
+			case 'M': return FormatStyle.MEDIUM;
+			case 'L': return FormatStyle.LONG;
+			case 'F': return FormatStyle.FULL;
+			case '-': return null;
+			default: throw new IllegalArgumentException("Invalid style character '" + c + "'");
+		}
+	}
+
+	/**
+	 * Set the {@code TimeZone} to normalize the date values into, if any.
+	 * @param timeZone the time zone
+	 */
+	public void setTimeZone(TimeZone timeZone) {
+		this.timeZone = timeZone;
+	}
+
+
+	/**
+	 * Create a new {@code DateTimeFormatter} using this factory.
+	 * <p>If no specific pattern or style has been defined,
+	 * {@link FormatStyle#MEDIUM medium date time format} will be used.
+	 * @return a new date time formatter
+	 * @see #createDateTimeFormatter(DateTimeFormatter)
+	 */
+	public DateTimeFormatter createDateTimeFormatter() {
+		return createDateTimeFormatter(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
+	}
+
+	/**
+	 * Create a new {@code DateTimeFormatter} using this factory.
+	 * <p>If no specific pattern or style has been defined,
+	 * the supplied {@code fallbackFormatter} will be used.
+	 * @param fallbackFormatter the fall-back formatter to use when no specific
+	 * factory properties have been set (can be {@code null}).
+	 * @return a new date time formatter
+	 */
+	public DateTimeFormatter createDateTimeFormatter(DateTimeFormatter fallbackFormatter) {
+		DateTimeFormatter dateTimeFormatter = null;
+		if (StringUtils.hasLength(this.pattern)) {
+			dateTimeFormatter = DateTimeFormatter.ofPattern(this.pattern);
+		}
+		else if (this.iso != null && this.iso != ISO.NONE) {
+			switch (this.iso) {
+				case DATE:
+					dateTimeFormatter = DateTimeFormatter.ISO_DATE;
+					break;
+				case TIME:
+					dateTimeFormatter = DateTimeFormatter.ISO_TIME;
+					break;
+				case DATE_TIME:
+					dateTimeFormatter = DateTimeFormatter.ISO_DATE_TIME;
+					break;
+				case NONE:
+					/* no-op */
+					break;
+				default:
+					throw new IllegalStateException("Unsupported ISO format: " + this.iso);
+			}
+		}
+		else if (this.dateStyle != null && this.timeStyle != null) {
+			dateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(this.dateStyle, this.timeStyle);
+		}
+		else if (this.dateStyle != null) {
+			dateTimeFormatter = DateTimeFormatter.ofLocalizedDate(this.dateStyle);
+		}
+		else if (this.timeStyle != null) {
+			dateTimeFormatter = DateTimeFormatter.ofLocalizedTime(this.timeStyle);
+		}
+
+		if (dateTimeFormatter != null && this.timeZone != null) {
+			dateTimeFormatter = dateTimeFormatter.withZone(this.timeZone.toZoneId());
+		}
+		return (dateTimeFormatter != null ? dateTimeFormatter : fallbackFormatter);
+	}
+
+}

spring-context/src/main/java/org/springframework/format/datetime/standard/DateTimeFormatterFactoryBean.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.format.datetime.standard;
+
+import java.time.format.DateTimeFormatter;
+
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.InitializingBean;
+
+/**
+ * {@link FactoryBean} that creates a JSR-310 {@link java.time.format.DateTimeFormatter}.
+ * See the {@link DateTimeFormatterFactory base class} for configuration details.
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ * @see #setPattern
+ * @see #setIso
+ * @see #setDateStyle
+ * @see #setTimeStyle
+ * @see DateTimeFormatterFactory
+ */
+public class DateTimeFormatterFactoryBean extends DateTimeFormatterFactory
+		implements FactoryBean<DateTimeFormatter>, InitializingBean {
+
+	private DateTimeFormatter dateTimeFormatter;
+
+
+	public void afterPropertiesSet() {
+		this.dateTimeFormatter = createDateTimeFormatter();
+	}
+
+	public DateTimeFormatter getObject() {
+		return this.dateTimeFormatter;
+	}
+
+	public Class<?> getObjectType() {
+		return DateTimeFormatter.class;
+	}
+
+	public boolean isSingleton() {
+		return true;
+	}
+
+}

spring-context/src/main/java/org/springframework/format/datetime/standard/DateTimeFormatterRegistrar.java

@@ -0,0 +1,201 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.format.datetime.standard;
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.FormatStyle;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.format.FormatterRegistrar;
+import org.springframework.format.FormatterRegistry;
+import org.springframework.format.annotation.DateTimeFormat.ISO;
+
+/**
+ * Configures the JSR-310 <code>java.time</code> formatting system for use with Spring.
+ *
+ * @author Juergen Hoeller
+ * @author Phillip Webb
+ * @since 4.0
+ * @see #setDateStyle
+ * @see #setTimeStyle
+ * @see #setDateTimeStyle
+ * @see #setUseIsoFormat
+ * @see org.springframework.format.FormatterRegistrar#registerFormatters
+ * @see org.springframework.format.datetime.DateFormatterRegistrar
+ * @see org.springframework.format.datetime.joda.DateTimeFormatterFactoryBean
+ */
+public class DateTimeFormatterRegistrar implements FormatterRegistrar {
+
+	private static enum Type {DATE, TIME, DATE_TIME}
+
+
+	/**
+	 * User defined formatters.
+	 */
+	private final Map<Type, DateTimeFormatter> formatters = new HashMap<Type, DateTimeFormatter>();
+
+	/**
+	 * Factories used when specific formatters have not been specified.
+	 */
+	private final Map<Type, DateTimeFormatterFactory> factories;
+
+
+	public DateTimeFormatterRegistrar() {
+		this.factories = new HashMap<Type, DateTimeFormatterFactory>();
+		for (Type type : Type.values()) {
+			this.factories.put(type, new DateTimeFormatterFactory());
+		}
+	}
+
+
+	/**
+	 * Set whether standard ISO formatting should be applied to all date/time types.
+	 * Default is "false" (no).
+	 * <p>If set to "true", the "dateStyle", "timeStyle" and "dateTimeStyle"
+	 * properties are effectively ignored.
+	 */
+	public void setUseIsoFormat(boolean useIsoFormat) {
+		this.factories.get(Type.DATE).setIso(useIsoFormat ? ISO.DATE : null);
+		this.factories.get(Type.TIME).setIso(useIsoFormat ? ISO.TIME : null);
+		this.factories.get(Type.DATE_TIME).setIso(useIsoFormat ? ISO.DATE_TIME : null);
+	}
+
+	/**
+	 * Set the default format style of {@link java.time.LocalDate} objects.
+	 * Default is {@link java.time.format.FormatStyle#SHORT}.
+	 */
+	public void setDateStyle(FormatStyle dateStyle) {
+		this.factories.get(Type.DATE).setDateStyle(dateStyle);
+	}
+
+	/**
+	 * Set the default format style of {@link java.time.LocalTime} objects.
+	 * Default is {@link java.time.format.FormatStyle#SHORT}.
+	 */
+	public void setTimeStyle(FormatStyle timeStyle) {
+		this.factories.get(Type.TIME).setTimeStyle(timeStyle);
+	}
+
+	/**
+	 * Set the default format style of {@link java.time.LocalDateTime} objects.
+	 * Default is {@link java.time.format.FormatStyle#SHORT}.
+	 */
+	public void setDateTimeStyle(FormatStyle dateTimeStyle) {
+		this.factories.get(Type.DATE_TIME).setDateTimeStyle(dateTimeStyle);
+	}
+
+	/**
+	 * Set the formatter that will be used for objects representing date values.
+	 * <p>This formatter will be used for the {@link org.joda.time.LocalDate} type.
+	 * When specified, the {@link #setDateStyle dateStyle} and
+	 * {@link #setUseIsoFormat useIsoFormat} properties will be ignored.
+	 * @param formatter the formatter to use
+	 * @see #setTimeFormatter
+	 * @see #setDateTimeFormatter
+	 */
+	public void setDateFormatter(DateTimeFormatter formatter) {
+		this.formatters.put(Type.DATE, formatter);
+	}
+
+	/**
+	 * Set the formatter that will be used for objects representing time values.
+	 * <p>This formatter will be used for the {@link org.joda.time.LocalTime} type.
+	 * When specified, the {@link #setTimeStyle timeStyle} and
+	 * {@link #setUseIsoFormat useIsoFormat} properties will be ignored.
+	 * @param formatter the formatter to use
+	 * @see #setDateFormatter
+	 * @see #setDateTimeFormatter
+	 */
+	public void setTimeFormatter(DateTimeFormatter formatter) {
+		this.formatters.put(Type.TIME, formatter);
+	}
+
+	/**
+	 * Set the formatter that will be used for objects representing date and time values.
+	 * <p>This formatter will be used for {@link org.joda.time.LocalDateTime}, {@link org.joda.time.ReadableInstant},
+	 * {@link java.util.Date} and {@link java.util.Calendar} types.
+	 * When specified, the {@link #setDateTimeStyle dateTimeStyle} and
+	 * {@link #setUseIsoFormat useIsoFormat} properties will be ignored.
+	 * @param formatter the formatter to use
+	 * @see #setDateFormatter
+	 * @see #setTimeFormatter
+	 */
+	public void setDateTimeFormatter(DateTimeFormatter formatter) {
+		this.formatters.put(Type.DATE_TIME, formatter);
+	}
+
+
+	public void registerFormatters(FormatterRegistry registry) {
+		DateTimeFormatter dateFormatter = getFormatter(Type.DATE);
+		DateTimeFormatter timeFormatter = getFormatter(Type.TIME);
+		DateTimeFormatter dateTimeFormatter = getFormatter(Type.DATE_TIME);
+
+		registry.addFormatterForFieldType(LocalDate.class,
+				new TemporalAccessorPrinter(dateFormatter),
+				new TemporalAccessorParser(LocalDate.class, dateFormatter));
+
+		registry.addFormatterForFieldType(LocalTime.class,
+				new TemporalAccessorPrinter(timeFormatter),
+				new TemporalAccessorParser(LocalTime.class, timeFormatter));
+
+		registry.addFormatterForFieldType(LocalDateTime.class,
+				new TemporalAccessorPrinter(dateTimeFormatter),
+				new TemporalAccessorParser(LocalDateTime.class, dateTimeFormatter));
+
+		registry.addFormatterForFieldType(ZonedDateTime.class,
+				new TemporalAccessorPrinter(dateTimeFormatter),
+				new TemporalAccessorParser(ZonedDateTime.class, dateTimeFormatter));
+
+		registry.addFormatterForFieldType(OffsetDateTime.class,
+				new TemporalAccessorPrinter(dateTimeFormatter),
+				new TemporalAccessorParser(OffsetDateTime.class, dateTimeFormatter));
+
+		registry.addFormatterForFieldType(OffsetTime.class,
+				new TemporalAccessorPrinter(timeFormatter),
+				new TemporalAccessorParser(OffsetTime.class, timeFormatter));
+
+		registry.addFormatterForFieldType(Instant.class, new InstantFormatter());
+
+		registry.addFormatterForFieldAnnotation(new Jsr310DateTimeFormatAnnotationFormatterFactory());
+	}
+
+	private DateTimeFormatter getFormatter(Type type) {
+		DateTimeFormatter formatter = this.formatters.get(type);
+		if (formatter != null) {
+			return formatter;
+		}
+		DateTimeFormatter fallbackFormatter = getFallbackFormatter(type);
+		return this.factories.get(type).createDateTimeFormatter(fallbackFormatter);
+	}
+
+	private DateTimeFormatter getFallbackFormatter(Type type) {
+		switch (type) {
+			case DATE: return DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT);
+			case TIME: return DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT);
+			default: return DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
+		}
+	}
+
+}

spring-context/src/main/java/org/springframework/format/datetime/standard/InstantFormatter.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.format.datetime.standard;
+
+import java.text.ParseException;
+import java.time.Instant;
+import java.util.Locale;
+
+import org.springframework.format.Formatter;
+
+/**
+ * {@link Formatter} implementation for a JSR-310 {@link java.time.Instant},
+ * following JSR-310's parsing rules for an Instant (that is, not using a
+ * configurable {@link java.time.format.DateTimeFormatter}).
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ * @see java.time.Instant#parse
+ */
+public class InstantFormatter implements Formatter<Instant> {
+
+	public Instant parse(String text, Locale locale) throws ParseException {
+		return Instant.parse(text);
+	}
+
+	public String print(Instant object, Locale locale) {
+		return object.toString();
+	}
+
+}

spring-context/src/main/java/org/springframework/format/datetime/standard/Jsr310DateTimeFormatAnnotationFormatterFactory.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.format.datetime.standard;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.TemporalAccessor;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.springframework.context.EmbeddedValueResolverAware;
+import org.springframework.format.AnnotationFormatterFactory;
+import org.springframework.format.Parser;
+import org.springframework.format.Printer;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.util.StringValueResolver;
+
+/**
+ * Formats fields annotated with the {@link DateTimeFormat} annotation using
+ * the JSR-310 <code>java.time</code> package in JDK 8.
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ * @see org.springframework.format.annotation.DateTimeFormat
+ */
+public class Jsr310DateTimeFormatAnnotationFormatterFactory
+		implements AnnotationFormatterFactory<DateTimeFormat>, EmbeddedValueResolverAware {
+
+	private static final Set<Class<?>> FIELD_TYPES;
+	static {
+		// Create the set of field types that may be annotated with @DateTimeFormat.
+		Set<Class<?>> fieldTypes = new HashSet<Class<?>>(8);
+		fieldTypes.add(LocalDate.class);
+		fieldTypes.add(LocalTime.class);
+		fieldTypes.add(LocalDateTime.class);
+		fieldTypes.add(ZonedDateTime.class);
+		fieldTypes.add(OffsetDateTime.class);
+		fieldTypes.add(OffsetTime.class);
+		FIELD_TYPES = Collections.unmodifiableSet(fieldTypes);
+	}
+
+
+	private StringValueResolver embeddedValueResolver;
+
+
+	public void setEmbeddedValueResolver(StringValueResolver resolver) {
+		this.embeddedValueResolver = resolver;
+	}
+
+	protected String resolveEmbeddedValue(String value) {
+		return (this.embeddedValueResolver != null ? this.embeddedValueResolver.resolveStringValue(value) : value);
+	}
+
+
+	public final Set<Class<?>> getFieldTypes() {
+		return FIELD_TYPES;
+	}
+
+	public Printer<?> getPrinter(DateTimeFormat annotation, Class<?> fieldType) {
+		DateTimeFormatter formatter = getFormatter(annotation, fieldType);
+		return new TemporalAccessorPrinter(formatter);
+	}
+
+	@SuppressWarnings("unchecked")
+	public Parser<?> getParser(DateTimeFormat annotation, Class<?> fieldType) {
+		DateTimeFormatter formatter = getFormatter(annotation, fieldType);
+		return new TemporalAccessorParser((Class<? extends TemporalAccessor>) fieldType, formatter);
+	}
+
+	/**
+	 * Factory method used to create a {@link org.joda.time.format.DateTimeFormatter}.
+	 * @param annotation the format annotation for the field
+	 * @param fieldType the type of field
+	 * @return a {@link org.joda.time.format.DateTimeFormatter} instance
+	 */
+	protected DateTimeFormatter getFormatter(DateTimeFormat annotation, Class<?> fieldType) {
+		DateTimeFormatterFactory factory = new DateTimeFormatterFactory();
+		factory.setStylePattern(resolveEmbeddedValue(annotation.style()));
+		factory.setIso(annotation.iso());
+		factory.setPattern(resolveEmbeddedValue(annotation.pattern()));
+		return factory.createDateTimeFormatter();
+	}
+
+}

spring-context/src/main/java/org/springframework/format/datetime/standard/TemporalAccessorParser.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.format.datetime.standard;
+
+import java.text.ParseException;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.TemporalAccessor;
+import java.util.Locale;
+
+import org.springframework.format.Parser;
+
+/**
+ * {@link Parser} implementation for a JSR-310 {@link java.time.temporal.TemporalAccessor},
+ * using a {@link java.time.format.DateTimeFormatter}) (the contextual one, if available).
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ * @see DateTimeContextHolder#getFormatter
+ * @see java.time.LocalDate#parse(CharSequence, java.time.format.DateTimeFormatter)
+ * @see java.time.LocalTime#parse(CharSequence, java.time.format.DateTimeFormatter)
+ * @see java.time.LocalDateTime#parse(CharSequence, java.time.format.DateTimeFormatter)
+ * @see java.time.ZonedDateTime#parse(CharSequence, java.time.format.DateTimeFormatter)
+ * @see java.time.OffsetDateTime#parse(CharSequence, java.time.format.DateTimeFormatter)
+ * @see java.time.OffsetTime#parse(CharSequence, java.time.format.DateTimeFormatter)
+ */
+public final class TemporalAccessorParser implements Parser<TemporalAccessor> {
+
+	private final Class<? extends TemporalAccessor> temporalAccessorType;
+
+	private final DateTimeFormatter formatter;
+
+
+	/**
+	 * Create a new TemporalAccessorParser for the given TemporalAccessor type.
+	 * @param temporalAccessorType the specific TemporalAccessor class
+	 * (LocalDate, LocalTime, LocalDateTime, ZonedDateTime, OffsetDateTime, OffsetTime)
+	 * @param formatter the base DateTimeFormatter instance
+	 */
+	public TemporalAccessorParser(Class<? extends TemporalAccessor> temporalAccessorType, DateTimeFormatter formatter) {
+		this.temporalAccessorType = temporalAccessorType;
+		this.formatter = formatter;
+	}
+
+
+	public TemporalAccessor parse(String text, Locale locale) throws ParseException {
+		DateTimeFormatter formatterToUse = DateTimeContextHolder.getFormatter(this.formatter, locale);
+		if (LocalDate.class.equals(this.temporalAccessorType)) {
+			return LocalDate.parse(text, formatterToUse);
+		}
+		else if (LocalTime.class.equals(this.temporalAccessorType)) {
+			return LocalTime.parse(text, formatterToUse);
+		}
+		else if (LocalDateTime.class.equals(this.temporalAccessorType)) {
+			return LocalDateTime.parse(text, formatterToUse);
+		}
+		else if (ZonedDateTime.class.equals(this.temporalAccessorType)) {
+			return ZonedDateTime.parse(text, formatterToUse);
+		}
+		else if (OffsetDateTime.class.equals(this.temporalAccessorType)) {
+			return OffsetDateTime.parse(text, formatterToUse);
+		}
+		else if (OffsetTime.class.equals(this.temporalAccessorType)) {
+			return OffsetTime.parse(text, formatterToUse);
+		}
+		else {
+			throw new IllegalStateException("Unsupported TemporalAccessor type: " + this.temporalAccessorType);
+		}
+	}
+
+}

spring-context/src/main/java/org/springframework/format/datetime/standard/TemporalAccessorPrinter.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.format.datetime.standard;
+
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.TemporalAccessor;
+import java.util.Locale;
+
+import org.springframework.format.Printer;
+
+/**
+ * {@link Printer} implementation for a JSR-310 {@link java.time.temporal.TemporalAccessor},
+ * using a {@link java.time.format.DateTimeFormatter}) (the contextual one, if available).
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ * @see DateTimeContextHolder#getFormatter
+ * @see java.time.format.DateTimeFormatter#format(java.time.temporal.TemporalAccessor)
+ */
+public final class TemporalAccessorPrinter implements Printer<TemporalAccessor> {
+
+	private final DateTimeFormatter formatter;
+
+
+	/**
+	 * Create a new TemporalAccessorPrinter.
+	 * @param formatter the base DateTimeFormatter instance
+	 */
+	public TemporalAccessorPrinter(DateTimeFormatter formatter) {
+		this.formatter = formatter;
+	}
+
+
+	public String print(TemporalAccessor partial, Locale locale) {
+		return DateTimeContextHolder.getFormatter(this.formatter, locale).format(partial);
+	}
+
+}

spring-context/src/main/java/org/springframework/format/datetime/standard/package-info.java

@@ -0,0 +1,4 @@
+/**
+ * Integration with the JSR-310 <code>java.time</code> package in JDK 8.
+ */
+package org.springframework.format.datetime.standard;

spring-context/src/main/java/org/springframework/format/support/DefaultFormattingConversionService.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@ import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.format.FormatterRegistry;
 import org.springframework.format.datetime.DateFormatterRegistrar;
 import org.springframework.format.datetime.joda.JodaTimeFormatterRegistrar;
+import org.springframework.format.datetime.standard.DateTimeFormatterRegistrar;
 import org.springframework.format.number.NumberFormatAnnotationFormatterFactory;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringValueResolver;
@@ -34,13 +35,18 @@ import org.springframework.util.StringValueResolver;
  * {@link DefaultConversionService#addDefaultConverters addDefaultConverters} method.
  *
  * @author Chris Beams
+ * @author Juergen Hoeller
  * @since 3.1
  */
 public class DefaultFormattingConversionService extends FormattingConversionService {
 
+	private static final boolean jsr310Present = ClassUtils.isPresent(
+			"java.time.LocalDate", DefaultFormattingConversionService.class.getClassLoader());
+
 	private static final boolean jodaTimePresent = ClassUtils.isPresent(
 			"org.joda.time.LocalDate", DefaultFormattingConversionService.class.getClassLoader());
 
+
 	/**
 	 * Create a new {@code DefaultFormattingConversionService} with the set of
 	 * {@linkplain DefaultConversionService#addDefaultConverters default converters} and
@@ -71,13 +77,14 @@ public class DefaultFormattingConversionService extends FormattingConversionServ
 	 * @param registerDefaultFormatters whether to register default formatters
 	 */
 	public DefaultFormattingConversionService(StringValueResolver embeddedValueResolver, boolean registerDefaultFormatters) {
-		this.setEmbeddedValueResolver(embeddedValueResolver);
+		setEmbeddedValueResolver(embeddedValueResolver);
 		DefaultConversionService.addDefaultConverters(this);
 		if (registerDefaultFormatters) {
 			addDefaultFormatters(this);
 		}
 	}
 
+
 	/**
 	 * Add formatters appropriate for most environments, including number formatters and a Joda-Time
 	 * date formatter if Joda-Time is present on the classpath.
@@ -85,10 +92,16 @@ public class DefaultFormattingConversionService extends FormattingConversionServ
 	 */
 	public static void addDefaultFormatters(FormatterRegistry formatterRegistry) {
 		formatterRegistry.addFormatterForFieldAnnotation(new NumberFormatAnnotationFormatterFactory());
+		if (jsr310Present) {
+			// just handling JSR-310 specific date and time types
+			new DateTimeFormatterRegistrar().registerFormatters(formatterRegistry);
+		}
 		if (jodaTimePresent) {
+			// handles Joda-specific types as well as Date, Calendar, Long
 			new JodaTimeFormatterRegistrar().registerFormatters(formatterRegistry);
 		}
 		else {
+			// regular DateFormat-based Date, Calendar, Long converters
 			new DateFormatterRegistrar().registerFormatters(formatterRegistry);
 		}
 	}