json Jackson 将 Joda DateTime 自动格式化为 ISO 8601 格式

Hymanson automatic formatting of Joda DateTime to ISO 8601 format

提问by Jeff M

According to http://wiki.fasterxml.com/HymansonFAQDateHandling, “DateTime can be automaticallyserialized/deserialized similar to how java.util.Date is handled.” However, I am not able to accomplish this automaticfunctionality. There are StackOverflow discussions related to this topic yet most involve a code-based solution, but based upon the quote above I should be able to accomplish this via simple configuration.

根据http://wiki.fasterxml.com/HymansonFAQDateHandling，“DateTime 可以自动序列化/反序列化，类似于 java.util.Date 的处理方式。” 但是，我无法完成此自动功能。有与此主题相关的 StackOverflow 讨论，但大多数都涉及基于代码的解决方案，但根据上面的引用，我应该能够通过简单的配置来完成此操作。

Per http://wiki.fasterxml.com/HymansonFAQDateHandlingI have my configuration set so that writing dates as timestamps is false. The result is that java.util.Date types are serialized to ISO 8601 format, but org.joda.time.DateTime types are serialized to a long object representation.

根据http://wiki.fasterxml.com/HymansonFAQDateHandling我设置了我的配置，以便将日期写为时间戳是错误的。结果是 java.util.Date 类型被序列化为 ISO 8601 格式，但 org.joda.time.DateTime 类型被序列化为长对象表示。

My environment is this:

我的环境是这样的：

Hymanson 2.1
Joda time 2.1
Spring 3.2
Java 1.6

Hymanson 2.1
Joda 时间 2.1
Spring 3.2
Java 1.6

My Spring configuration for the jsonMapper bean is

我的 jsonMapper bean 的 Spring 配置是

@Bean
public ObjectMapper jsonMapper() {
    ObjectMapper objectMapper = new ObjectMapper();

    //Fully qualified path shows I am using latest enum
    ObjectMapper.configure(com.fasterxml.Hymanson.databind.SerializationFeature.
        WRITE_DATES_AS_TIMESTAMPS , false);

    return objectMapper;
}

My test code snippet is this

我的测试代码片段是这样的

Date d = new Date();
DateTime dt = new DateTime(d); //Joda time 
Map<String, Object> link = new LinkedHashMap<String, Object>();
link.put("date", d);
link.put("createdDateTime", dt);

The resulting snippet of JSON output is this:

JSON 输出的结果片段是这样的：

{"date":"2012-12-24T21:20:47.668+0000"}

{"createdDateTime": {"year":2012,"dayOfMonth":24,"dayOfWeek":1,"era":1,"dayOfYear":359,"centuryOfEra":20,"yearOfEra":2012,"yearOfCentury":12,"weekyear":2012,"monthOfYear":12 *... remainder snipped for brevity*}}

My expectation is that the DateTime object should matche that of the Date object based upon the configuration. What am I doing wrong, or what am I misunderstanding? Am I reading too much into the word automaticallyfrom the Hymanson documentation and the fact that a string representation was produced, albeit not ISO 8601, is producing the advertised automatic functionality?

我的期望是 DateTime 对象应该与基于配置的 Date 对象相匹配。我做错了什么，或者我误解了什么？我是否从 Hymanson 文档中自动阅读了太多单词，并且生成了字符串表示（尽管不是 ISO 8601）这一事实是否正在生成广告中的自动功能？

回答by Jeff M

I was able to get the answer to this from the Hymanson user mailing list, and wanted to share with you since it is a newbie issue. From reading the Hymanson Date FAQ, I did not realize that extra dependencies and registration are required, but that is the case. It is documented at the git hub project page here https://github.com/FasterXML/Hymanson-datatype-joda

我能够从 Hymanson 用户邮件列表中得到答案，并想与您分享，因为这是一个新手问题。通过阅读 Hymanson Date FAQ，我没有意识到需要额外的依赖项和注册，但事实就是如此。它记录在此处的 git hub 项目页面https://github.com/FasterXML/Hymanson-datatype-joda

Essentially, I had to add another dependency to a Hymanson jar specific to the Joda data type, and then I had to register the use of that module on the object mapper. The code snippets are below.

本质上，我必须向特定于 Joda 数据类型的 Hymanson jar 添加另一个依赖项，然后我必须在对象映射器上注册该模块的使用。代码片段如下。

For my Hymanson Joda data type Maven dependency setup I used this:

对于我的 Hymanson Joda 数据类型 Maven 依赖项设置，我使用了这个：

<dependency>
    <groupId>com.fasterxml.Hymanson.datatype</groupId>
    <artifactId>Hymanson-datatype-joda</artifactId>
    <version>${Hymanson.version}</version>
</dependency>

To register the Joda serialization/deserialization feature I used this:

要注册 Joda 序列化/反序列化功能，我使用了这个：

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new JodaModule());
objectMapper.configure(com.fasterxml.Hymanson.databind.SerializationFeature.
    WRITE_DATES_AS_TIMESTAMPS , false);

回答by kervin

Using Spring Boot.

使用 Spring Boot。

Add to your Maven configuration...

添加到您的 Maven 配置...

<dependency>
  <groupId>com.fasterxml.Hymanson.datatype</groupId>
  <artifactId>Hymanson-datatype-joda</artifactId>
  <version>2.7.5</version>
</dependency>

Then to your WebConfiguration...

然后到您的 WebConfiguration...

@Configuration
public class WebConfiguration extends WebMvcConfigurerAdapter
{
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters)
    {
      final MappingHymanson2HttpMessageConverter converter = new MappingHymanson2HttpMessageConverter();
      final ObjectMapper objectMapper = new ObjectMapper();

      //configure Joda serialization
      objectMapper.registerModule(new JodaModule());
      objectMapper.configure(
          com.fasterxml.Hymanson.databind.SerializationFeature.
            WRITE_DATES_AS_TIMESTAMPS , false);

      // Other options such as how to deal with nulls or identing...
      objectMapper.setSerializationInclusion (
         JsonInclude.Include.NON_NULL);
      objectMapper.enable(SerializationFeature.INDENT_OUTPUT);

      converter.setObjectMapper(objectMapper);
      converters.add(converter);
      super.configureMessageConverters(converters);
    }
}

回答by Igor Bljahhin

In Spring Boot the configuration is even simpler. You just declare Maven dependency

在 Spring Boot 中，配置更简单。您只需声明 Maven 依赖项

    <dependency>
        <groupId>com.fasterxml.Hymanson.datatype</groupId>
        <artifactId>Hymanson-datatype-joda</artifactId>
    </dependency>

and then add configuration parameter to your application.yml/properties file:

然后将配置参数添加到您的 application.yml/properties 文件中：

spring.Hymanson.serialization.write-dates-as-timestamps: false

回答by Michael Taylor

I thought I'd post an updated working example using: Spring 4.2.0.RELEASE, Hymanson 2.6.1, Joda 2.8.2

我想我会发布一个更新的工作示例：Spring 4.2.0.RELEASE, Hymanson 2.6.1, Joda 2.8.2

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/util  http://www.springframework.org/schema/util/spring-util.xsd
        ">

    <!-- DispatcherServlet Context: defines this servlet's request-processing 
        infrastructure -->

    <!-- Enables the Spring MVC @Controller programming model -->
    <annotation-driven>
        <message-converters>
            <beans:bean
                class="org.springframework.http.converter.json.MappingHymanson2HttpMessageConverter">
                <beans:property name="objectMapper" ref="objectMapper" />
            </beans:bean>
        </message-converters>
    </annotation-driven>

    <!-- Handles HTTP GET requests for /resources/** by efficiently serving 
        up static resources in the ${webappRoot}/resources directory -->
    <resources mapping="/resources/**" location="/resources/" />

    <!-- Resolves views selected for rendering by @Controllers to .jsp resources 
        in the /WEB-INF/views directory -->
    <beans:bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <beans:property name="prefix" value="/WEB-INF/views/" />
        <beans:property name="suffix" value=".jsp" />
    </beans:bean>

    <beans:bean id="objectMapper"
        class="org.springframework.http.converter.json.Hymanson2ObjectMapperFactoryBean">
        <beans:property name="featuresToDisable">
            <beans:array>
                <util:constant
                    static-field="com.fasterxml.Hymanson.databind.SerializationFeature.WRITE_DATES_AS_TIMESTAMPS" />
            </beans:array>
        </beans:property>
        <beans:property name="modulesToInstall"
            value="com.fasterxml.Hymanson.datatype.joda.JodaModule" />
    </beans:bean>

    <beans:bean id="localeResolver"
        class="org.springframework.web.servlet.i18n.SessionLocaleResolver">
        <beans:property name="defaultLocale" value="en" />
    </beans:bean>

    <!-- Configure the Message Locale Resources -->
    <beans:bean id="messageSource"
        class="org.springframework.context.support.ResourceBundleMessageSource">
        <beans:property name="basename" value="errors" />
    </beans:bean>

    <beans:bean id="versionSource"
        class="org.springframework.context.support.ResourceBundleMessageSource">
        <beans:property name="basename" value="version" />
    </beans:bean>


    <!-- DataSource -->
    <beans:bean id="dataSource"
        class="org.springframework.jndi.JndiObjectFactoryBean">
        <beans:property name="jndiName" value="java:comp/env/jdbc/TestDB" />
    </beans:bean>


    <!-- POJO: Configure the DAO Implementation -->
    <beans:bean id="publicationsDAO"
        class="com.test.api.publication.PublicationsDAOJdbcImpl">
        <beans:property name="dataSource" ref="dataSource" />
    </beans:bean>


    <!-- Things to auto-load -->
    <context:component-scan base-package="com.test.api" />
    <context:component-scan base-package="com.test.rest" />

</beans:beans>

API Code

接口代码

package com.test.api.publication;

import java.util.Map;

import com.fasterxml.Hymanson.annotation.JsonIgnoreProperties;
import com.fasterxml.Hymanson.annotation.JsonProperty;
import com.fasterxml.Hymanson.annotation.JsonRootName;

@JsonRootName("event")
@JsonIgnoreProperties(ignoreUnknown=true)
public class Publication {

    private Map<String, Object> tokens;
    private String href;
    private String policy_path;

    @JsonProperty("tokens")
    public Map<String, Object> getTokens() {
        return tokens;
    }

    @JsonProperty("tokens")
    public void setTokens(Map<String, Object> tokens) {
        this.tokens = tokens;
    }

    @JsonProperty("href")
    public String getHref() {
        return href;
    }

    @JsonProperty("href")
    public void setHref(String href) {
        this.href = href;
    }

    @JsonProperty("policyPath")
    public String getPolicyPath() {
        return policy_path;
    }

    @JsonProperty("policyPath")
    public void setPolicyPath(String policy_path) {
        this.policy_path = policy_path;
    }


}


package com.test.api.publication;

import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PublicationsDAOJdbcImpl implements PublicationsDAO{

    static final Logger logger = LoggerFactory.getLogger(PublicationsDAOJdbcImpl.class.getName());
    private DataSource _dataSource;

    @Override
    public void setDataSource(DataSource ds) {
        // TODO Auto-generated method stub

    }

    @Override
    public void close() {
        // TODO Auto-generated method stub

    }

    @Override
    public Publication getPublication(String policyPath) {
        Publication ret = new Publication();
        //TODO: do something
        return ret;
    }

}



package com.test.rest.publication;

import java.util.HashMap;

import org.joda.time.DateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.test.api.publication.Publication;
import com.test.api.publication.PublicationsDAO;
import com.test.rest.error.UnknownResourceException;

@RestController
@RequestMapping("/pub")
public class PublicationController {

        private static final Logger logger = LoggerFactory.getLogger(PublicationController.class);

        @Autowired
        @Qualifier("publicationsDAO")
        private PublicationsDAO publicationsDAO;

        /**********************************************************************************************************************
         * 
         * @param policyPath
         * @return
         * @throws UnknownResourceException
         */
        @RequestMapping(value = "/{policyPath}", method = RequestMethod.GET)
        public Publication getByPolicyPath(@PathVariable String policyPath) throws UnknownResourceException{
            logger.debug("policyPath=" + policyPath);

            Publication ret = publicationsDAO.getPublication(policyPath);

            HashMap<String, Object> map = new HashMap<String, Object>();
            map.put("TEST1", null);
            map.put("TEST2", new Integer(101));
            map.put("TEST3", "QuinnZilla");
            map.put("TEST4", new DateTime());
            ret.setTokens(map);
            return ret;

        }

}

And I get the output result

我得到了输出结果

{
  "tokens": {
    "TEST2": 101,
    "TEST3": "QuinnZilla",
    "TEST4": "2015-10-06T16:59:35.120Z",
    "TEST1": null
  },
  "href": null,
  "policyPath": null
}