[Java] Threetenbp dates support (#4029)

* [feign] add threetenbp support for feign clients * [okhttp] add threetenbp support for okhttp clients * [jersey] add threetenbp support for jersey clients * [retrofit2] add threetenbp support for retrofit2 clients * [spring] add threetenbp support for spring generators * add a workaround in tests for a bug in the petstore The petstore doesn't manage fractional digits of dates correctly when there are less than 3
2016-11-04 10:55:16 +01:00
parent c1e6f00242
commit 70d93883cf
336 changed files with 6397 additions and 1821 deletions
--- a/modules/swagger-codegen/src/main/resources/JavaSpring/customInstantDeserializer.mustache
+++ b/modules/swagger-codegen/src/main/resources/JavaSpring/customInstantDeserializer.mustache
@@ -0,0 +1,232 @@
+package {{configPackage}};
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonTokenId;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.datatype.threetenbp.DateTimeUtils;
+import com.fasterxml.jackson.datatype.threetenbp.DecimalUtils;
+import com.fasterxml.jackson.datatype.threetenbp.deser.ThreeTenDateTimeDeserializerBase;
+import com.fasterxml.jackson.datatype.threetenbp.function.BiFunction;
+import com.fasterxml.jackson.datatype.threetenbp.function.Function;
+import org.threeten.bp.DateTimeException;
+import org.threeten.bp.Instant;
+import org.threeten.bp.OffsetDateTime;
+import org.threeten.bp.ZoneId;
+import org.threeten.bp.ZonedDateTime;
+import org.threeten.bp.format.DateTimeFormatter;
+import org.threeten.bp.temporal.Temporal;
+import org.threeten.bp.temporal.TemporalAccessor;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+
+/**
+ * Deserializer for ThreeTen temporal {@link Instant}s, {@link OffsetDateTime}, and {@link ZonedDateTime}s.
+ * Adapted from the jackson threetenbp InstantDeserializer to add support for deserializing rfc822 format.
+ *
+ * @author Nick Williams
+ */
+public class CustomInstantDeserializer<T extends Temporal>
+    extends ThreeTenDateTimeDeserializerBase<T> {
+  private static final long serialVersionUID = 1L;
+
+  public static final CustomInstantDeserializer<Instant> INSTANT = new CustomInstantDeserializer<Instant>(
+      Instant.class, DateTimeFormatter.ISO_INSTANT,
+      new Function<TemporalAccessor, Instant>() {
+        @Override
+        public Instant apply(TemporalAccessor temporalAccessor) {
+          return Instant.from(temporalAccessor);
+        }
+      },
+      new Function<FromIntegerArguments, Instant>() {
+        @Override
+        public Instant apply(FromIntegerArguments a) {
+          return Instant.ofEpochMilli(a.value);
+        }
+      },
+      new Function<FromDecimalArguments, Instant>() {
+        @Override
+        public Instant apply(FromDecimalArguments a) {
+          return Instant.ofEpochSecond(a.integer, a.fraction);
+        }
+      },
+      null
+  );
+
+  public static final CustomInstantDeserializer<OffsetDateTime> OFFSET_DATE_TIME = new CustomInstantDeserializer<OffsetDateTime>(
+      OffsetDateTime.class, DateTimeFormatter.ISO_OFFSET_DATE_TIME,
+      new Function<TemporalAccessor, OffsetDateTime>() {
+        @Override
+        public OffsetDateTime apply(TemporalAccessor temporalAccessor) {
+          return OffsetDateTime.from(temporalAccessor);
+        }
+      },
+      new Function<FromIntegerArguments, OffsetDateTime>() {
+        @Override
+        public OffsetDateTime apply(FromIntegerArguments a) {
+          return OffsetDateTime.ofInstant(Instant.ofEpochMilli(a.value), a.zoneId);
+        }
+      },
+      new Function<FromDecimalArguments, OffsetDateTime>() {
+        @Override
+        public OffsetDateTime apply(FromDecimalArguments a) {
+          return OffsetDateTime.ofInstant(Instant.ofEpochSecond(a.integer, a.fraction), a.zoneId);
+        }
+      },
+      new BiFunction<OffsetDateTime, ZoneId, OffsetDateTime>() {
+        @Override
+        public OffsetDateTime apply(OffsetDateTime d, ZoneId z) {
+          return d.withOffsetSameInstant(z.getRules().getOffset(d.toLocalDateTime()));
+        }
+      }
+  );
+
+  public static final CustomInstantDeserializer<ZonedDateTime> ZONED_DATE_TIME = new CustomInstantDeserializer<ZonedDateTime>(
+      ZonedDateTime.class, DateTimeFormatter.ISO_ZONED_DATE_TIME,
+      new Function<TemporalAccessor, ZonedDateTime>() {
+        @Override
+        public ZonedDateTime apply(TemporalAccessor temporalAccessor) {
+          return ZonedDateTime.from(temporalAccessor);
+        }
+      },
+      new Function<FromIntegerArguments, ZonedDateTime>() {
+        @Override
+        public ZonedDateTime apply(FromIntegerArguments a) {
+          return ZonedDateTime.ofInstant(Instant.ofEpochMilli(a.value), a.zoneId);
+        }
+      },
+      new Function<FromDecimalArguments, ZonedDateTime>() {
+        @Override
+        public ZonedDateTime apply(FromDecimalArguments a) {
+          return ZonedDateTime.ofInstant(Instant.ofEpochSecond(a.integer, a.fraction), a.zoneId);
+        }
+      },
+      new BiFunction<ZonedDateTime, ZoneId, ZonedDateTime>() {
+        @Override
+        public ZonedDateTime apply(ZonedDateTime zonedDateTime, ZoneId zoneId) {
+          return zonedDateTime.withZoneSameInstant(zoneId);
+        }
+      }
+  );
+
+  protected final Function<FromIntegerArguments, T> fromMilliseconds;
+
+  protected final Function<FromDecimalArguments, T> fromNanoseconds;
+
+  protected final Function<TemporalAccessor, T> parsedToValue;
+
+  protected final BiFunction<T, ZoneId, T> adjust;
+
+  protected CustomInstantDeserializer(Class<T> supportedType,
+                    DateTimeFormatter parser,
+                    Function<TemporalAccessor, T> parsedToValue,
+                    Function<FromIntegerArguments, T> fromMilliseconds,
+                    Function<FromDecimalArguments, T> fromNanoseconds,
+                    BiFunction<T, ZoneId, T> adjust) {
+    super(supportedType, parser);
+    this.parsedToValue = parsedToValue;
+    this.fromMilliseconds = fromMilliseconds;
+    this.fromNanoseconds = fromNanoseconds;
+    this.adjust = adjust == null ? new BiFunction<T, ZoneId, T>() {
+      @Override
+      public T apply(T t, ZoneId zoneId) {
+        return t;
+      }
+    } : adjust;
+  }
+
+  @SuppressWarnings("unchecked")
+  protected CustomInstantDeserializer(CustomInstantDeserializer<T> base, DateTimeFormatter f) {
+    super((Class<T>) base.handledType(), f);
+    parsedToValue = base.parsedToValue;
+    fromMilliseconds = base.fromMilliseconds;
+    fromNanoseconds = base.fromNanoseconds;
+    adjust = base.adjust;
+  }
+
+  @Override
+  protected JsonDeserializer<T> withDateFormat(DateTimeFormatter dtf) {
+    if (dtf == _formatter) {
+      return this;
+    }
+    return new CustomInstantDeserializer<T>(this, dtf);
+  }
+
+  @Override
+  public T deserialize(JsonParser parser, DeserializationContext context) throws IOException {
+    //NOTE: Timestamps contain no timezone info, and are always in configured TZ. Only
+    //string values have to be adjusted to the configured TZ.
+    switch (parser.getCurrentTokenId()) {
+      case JsonTokenId.ID_NUMBER_FLOAT: {
+        BigDecimal value = parser.getDecimalValue();
+        long seconds = value.longValue();
+        int nanoseconds = DecimalUtils.extractNanosecondDecimal(value, seconds);
+        return fromNanoseconds.apply(new FromDecimalArguments(
+            seconds, nanoseconds, getZone(context)));
+      }
+
+      case JsonTokenId.ID_NUMBER_INT: {
+        long timestamp = parser.getLongValue();
+        if (context.isEnabled(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS)) {
+          return this.fromNanoseconds.apply(new FromDecimalArguments(
+              timestamp, 0, this.getZone(context)
+          ));
+        }
+        return this.fromMilliseconds.apply(new FromIntegerArguments(
+            timestamp, this.getZone(context)
+        ));
+      }
+
+      case JsonTokenId.ID_STRING: {
+        String string = parser.getText().trim();
+        if (string.length() == 0) {
+          return null;
+        }
+        if (string.endsWith("+0000")) {
+          string = string.substring(0, string.length() - 5) + "Z";
+        }
+        T value;
+        try {
+          TemporalAccessor acc = _formatter.parse(string);
+          value = parsedToValue.apply(acc);
+          if (context.isEnabled(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE)) {
+            return adjust.apply(value, this.getZone(context));
+          }
+        } catch (DateTimeException e) {
+          throw _peelDTE(e);
+        }
+        return value;
+      }
+    }
+    throw context.mappingException("Expected type float, integer, or string.");
+  }
+
+  private ZoneId getZone(DeserializationContext context) {
+    // Instants are always in UTC, so don't waste compute cycles
+    return (_valueClass == Instant.class) ? null : DateTimeUtils.timeZoneToZoneId(context.getTimeZone());
+  }
+
+  private static class FromIntegerArguments {
+    public final long value;
+    public final ZoneId zoneId;
+
+    private FromIntegerArguments(long value, ZoneId zoneId) {
+      this.value = value;
+      this.zoneId = zoneId;
+    }
+  }
+
+  private static class FromDecimalArguments {
+    public final long integer;
+    public final int fraction;
+    public final ZoneId zoneId;
+
+    private FromDecimalArguments(long integer, int fraction, ZoneId zoneId) {
+      this.integer = integer;
+      this.fraction = fraction;
+      this.zoneId = zoneId;
+    }
+  }
+}
--- a/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-boot/jacksonConfiguration.mustache
+++ b/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-boot/jacksonConfiguration.mustache
@@ -0,0 +1,23 @@
+package {{configPackage}};
+
+import com.fasterxml.jackson.datatype.threetenbp.ThreeTenModule;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.threeten.bp.Instant;
+import org.threeten.bp.OffsetDateTime;
+import org.threeten.bp.ZonedDateTime;
+
+@Configuration
+public class JacksonConfiguration {
+
+  @Bean
+  @ConditionalOnMissingBean(ThreeTenModule.class)
+  ThreeTenModule threeTenModule() {
+    ThreeTenModule module = new ThreeTenModule();
+    module.addDeserializer(Instant.class, CustomInstantDeserializer.INSTANT);
+    module.addDeserializer(OffsetDateTime.class, CustomInstantDeserializer.OFFSET_DATE_TIME);
+    module.addDeserializer(ZonedDateTime.class, CustomInstantDeserializer.ZONED_DATE_TIME);
+    return module;
+  }
+}
--- a/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-boot/pom.mustache
+++ b/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-boot/pom.mustache
@@ -62,16 +62,20 @@
            <artifactId>jackson-datatype-jsr310</artifactId>
        </dependency>
        {{/java8}}
-        {{^java8}}
+        {{#joda}}

        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-joda</artifactId>
        </dependency>
+        {{/joda}}
+        {{#threetenbp}}
+
        <dependency>
-            <groupId>joda-time</groupId>
-            <artifactId>joda-time</artifactId>
+            <groupId>com.github.joschi.jackson</groupId>
+            <artifactId>jackson-datatype-threetenbp</artifactId>
+            <version>2.6.4</version>
        </dependency>
-        {{/java8}}
+        {{/threetenbp}}
    </dependencies>
 </project>
--- a/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-cloud/jacksonConfiguration.mustache
+++ b/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-cloud/jacksonConfiguration.mustache
@@ -0,0 +1,23 @@
+package {{configPackage}};
+
+import com.fasterxml.jackson.datatype.threetenbp.ThreeTenModule;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.threeten.bp.Instant;
+import org.threeten.bp.OffsetDateTime;
+import org.threeten.bp.ZonedDateTime;
+
+@Configuration
+public class JacksonConfiguration {
+
+  @Bean
+  @ConditionalOnMissingBean(ThreeTenModule.class)
+  ThreeTenModule threeTenModule() {
+    ThreeTenModule module = new ThreeTenModule();
+    module.addDeserializer(Instant.class, CustomInstantDeserializer.INSTANT);
+    module.addDeserializer(OffsetDateTime.class, CustomInstantDeserializer.OFFSET_DATE_TIME);
+    module.addDeserializer(ZonedDateTime.class, CustomInstantDeserializer.ZONED_DATE_TIME);
+    return module;
+  }
+}
--- a/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-cloud/pom.mustache
+++ b/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-cloud/pom.mustache
@@ -57,17 +57,21 @@
            <artifactId>jackson-datatype-jsr310</artifactId>
        </dependency>
        {{/java8}}
-        {{^java8}}
+        {{#joda}}

        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-joda</artifactId>
        </dependency>
+        {{/joda}}
+        {{#threetenbp}}
+
        <dependency>
-            <groupId>joda-time</groupId>
-            <artifactId>joda-time</artifactId>
+            <groupId>com.github.joschi.jackson</groupId>
+            <artifactId>jackson-datatype-threetenbp</artifactId>
+            <version>2.6.4</version>
        </dependency>
-        {{/java8}}
+        {{/threetenbp}}
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
--- a/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-mvc/pom.mustache
+++ b/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-mvc/pom.mustache
@@ -93,32 +93,42 @@
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${springfox-version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.fasterxml.jackson.core</groupId>
+                    <artifactId>jackson-annotations</artifactId>
+                </exclusion>
+            </exclusions>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${springfox-version}</version>
        </dependency>
-
        {{#java8}}
+
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
            <version>${jackson-version}</version>
        </dependency>
        {{/java8}}
-        {{^java8}}
+        {{#joda}}
+
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-joda</artifactId>
            <version>${jackson-version}</version>
        </dependency>
+        {{/joda}}
+        {{#threetenbp}}
+
        <dependency>
-            <groupId>joda-time</groupId>
-            <artifactId>joda-time</artifactId>
-            <version>2.9.4</version>
+            <groupId>com.github.joschi.jackson</groupId>
+            <artifactId>jackson-datatype-threetenbp</artifactId>
+            <version>${jackson-version}</version>
        </dependency>
-        {{/java8}}
+        {{/threetenbp}}

        <dependency>
            <groupId>junit</groupId>
@@ -140,8 +150,8 @@
        <slf4j-version>1.7.21</slf4j-version>
        <junit-version>4.12</junit-version>
        <servlet-api-version>2.5</servlet-api-version>
-        <springfox-version>2.4.0</springfox-version>
-        <jackson-version>2.4.5</jackson-version>
+        <springfox-version>2.6.0</springfox-version>
+        <jackson-version>2.6.4</jackson-version>
        <spring-version>4.2.5.RELEASE</spring-version>
    </properties>
 </project>
--- a/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-mvc/swaggerUiConfiguration.mustache
+++ b/modules/swagger-codegen/src/main/resources/JavaSpring/libraries/spring-mvc/swaggerUiConfiguration.mustache
@@ -2,6 +2,9 @@ package {{configPackage}};

 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
+{{#threetenbp}}
+import com.fasterxml.jackson.datatype.threetenbp.ThreeTenModule;
+{{/threetenbp}}
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.PropertySource;
@@ -12,6 +15,11 @@ import org.springframework.http.converter.json.MappingJackson2HttpMessageConvert
 import org.springframework.web.servlet.config.annotation.EnableWebMvc;
 import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
+{{#threetenbp}}
+import org.threeten.bp.Instant;
+import org.threeten.bp.OffsetDateTime;
+import org.threeten.bp.ZonedDateTime;
+{{/threetenbp}}
 import springfox.documentation.swagger2.annotations.EnableSwagger2;

 import java.util.List;
@@ -62,8 +70,15 @@ public class SwaggerUiConfiguration extends WebMvcConfigurerAdapter {
  public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json()
        .featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
-        .dateFormat( new RFC3339DateFormat())
+        .dateFormat(new RFC3339DateFormat())
        .build();
+    {{#threetenbp}}
+    ThreeTenModule module = new ThreeTenModule();
+    module.addDeserializer(Instant.class, CustomInstantDeserializer.INSTANT);
+    module.addDeserializer(OffsetDateTime.class, CustomInstantDeserializer.OFFSET_DATE_TIME);
+    module.addDeserializer(ZonedDateTime.class, CustomInstantDeserializer.ZONED_DATE_TIME);
+    objectMapper.registerModule(module);
+    {{/threetenbp}}
    converters.add(new MappingJackson2HttpMessageConverter(objectMapper));
    super.configureMessageConverters(converters);
  }
--- a/modules/swagger-codegen/src/main/resources/JavaSpring/swaggerDocumentationConfig.mustache
+++ b/modules/swagger-codegen/src/main/resources/JavaSpring/swaggerDocumentationConfig.mustache
@@ -36,10 +36,14 @@ public class SwaggerDocumentationConfig {
                .directModelSubstitute(java.time.LocalDate.class, java.sql.Date.class)
                .directModelSubstitute(java.time.OffsetDateTime.class, java.util.Date.class)
                {{/java8}}
-                {{^java8}}
+                {{#joda}}
                .directModelSubstitute(org.joda.time.LocalDate.class, java.sql.Date.class)
                .directModelSubstitute(org.joda.time.DateTime.class, java.util.Date.class)
-                {{/java8}}
+                {{/joda}}
+                {{#threetenbp}}
+                .directModelSubstitute(org.threeten.bp.LocalDate.class, java.sql.Date.class)
+                .directModelSubstitute(org.threeten.bp.OffsetDateTime.class, java.util.Date.class)
+                {{/threetenbp}}
                .apiInfo(apiInfo());
    }