Java 在spring data rest webmvc中更改Jackson日期格式设置

Lightadmin用于时间戳字段，例如：

@Temporal(TemporalType.TIMESTAMP)
@Column(name="started_at")
Date startedAt;

不格式化它们，但将它们显示为自历元以来的毫秒数，例如，

1398940456150

当您进入Lightadmin编辑页面时，例如

http://localhost:8080/admin/domain/user/1/edit

表单实际填充的值将在另一个请求中收到-

http://localhost:8080/admin/rest/user/1/unit/formView?_=1401699535260

，返回带有以下内容的JSON：

...
"startedAt" : {
    "name" : "startedAt",
    "title" : "started at timestamp",
    "value" : 1398940456150,
    "type" : "DATE",
    "persistable" : true,
    "primaryKey" : false
}
...

任务是将

1398940456150

更改为例如

01.05.2014 10:34:16

根据我的调查，

org.lightadmin.core.rest.DynamicRepositoryRestController.entity（）

是此类请求的入口点，负责生成JSON的代码位于：

org.springframework.data.rest.webmvc.repositoryawaremappingtMessageConverter.writeInternal（）

：

mapper

是

org.codehaus.jackson.map.ObjectMapper.ObjectMapper

的一个实例，使用默认值初始化。如果可以添加这两行：

SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
mapper.getSerializationConfig().setDateFormat(df);

---

它可以完成这项工作，问题是如何做到这一点？

我不清楚此数据rest webmvc，但您可以尝试注册cusotm转换器，如下所示：

@Component
public class DateConverter implements Converter<String, Date> {


    @Override
    public Date convert(String source) {
        return // do the conversion
    }
}

 <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.myapp.DateConverter"/>
            </set>
        </property>
    </bean>

@组件
公共类DateConverter实现转换器{
@凌驾
公共日期转换（字符串源）{
return//进行转换
}
}

并登记如下：

@Component
public class DateConverter implements Converter<String, Date> {


    @Override
    public Date convert(String source) {
        return // do the conversion
    }
}

 <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.myapp.DateConverter"/>
            </set>
        </property>
    </bean>

---

我不清楚此数据rest webmvc，但您可以尝试注册cusotm转换器，如下所示：

@Component
public class DateConverter implements Converter<String, Date> {


    @Override
    public Date convert(String source) {
        return // do the conversion
    }
}

 <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.myapp.DateConverter"/>
            </set>
        </property>
    </bean>

@组件
公共类DateConverter实现转换器{
@凌驾
公共日期转换（字符串源）{
return//进行转换
}
}

并登记如下：

@Component
public class DateConverter implements Converter<String, Date> {


    @Override
    public Date convert(String source) {
        return // do the conversion
    }
}

 <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.myapp.DateConverter"/>
            </set>
        </property>
    </bean>

---

我不清楚此数据rest webmvc，但您可以尝试注册cusotm转换器，如下所示：

@Component
public class DateConverter implements Converter<String, Date> {


    @Override
    public Date convert(String source) {
        return // do the conversion
    }
}

 <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.myapp.DateConverter"/>
            </set>
        </property>
    </bean>

@组件
公共类DateConverter实现转换器{
@凌驾
公共日期转换（字符串源）{
return//进行转换
}
}

并登记如下：

@Component
public class DateConverter implements Converter<String, Date> {


    @Override
    public Date convert(String source) {
        return // do the conversion
    }
}

 <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.myapp.DateConverter"/>
            </set>
        </property>
    </bean>

---

我不清楚此数据rest webmvc，但您可以尝试注册cusotm转换器，如下所示：

@Component
public class DateConverter implements Converter<String, Date> {


    @Override
    public Date convert(String source) {
        return // do the conversion
    }
}

 <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.myapp.DateConverter"/>
            </set>
        </property>
    </bean>

@组件
公共类DateConverter实现转换器{
@凌驾
公共日期转换（字符串源）{
return//进行转换
}
}

并登记如下：

@Component
public class DateConverter implements Converter<String, Date> {


    @Override
    public Date convert(String source) {
        return // do the conversion
    }
}

 <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.myapp.DateConverter"/>
            </set>
        </property>
    </bean>

---

我在Github上发布了此修复程序-但它是：

我通过更改lightadmin代码中的类修复了这个问题。下面是该类的更新源代码。也许有更好的方法来修复它——但这是侵入性最小的方法，它同时涵盖了序列化和反序列化

package org.lightadmin.core.rest;

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.Version;
import org.codehaus.jackson.map.DeserializationContext;
import org.codehaus.jackson.map.SerializerProvider;
import org.codehaus.jackson.map.deser.std.StdDeserializer;
import org.codehaus.jackson.map.module.SimpleDeserializers;
import org.codehaus.jackson.map.module.SimpleModule;
import org.codehaus.jackson.map.module.SimpleSerializers;
import org.codehaus.jackson.map.ser.std.SerializerBase;
import org.springframework.hateoas.Resource;

public class DomainTypeResourceModule extends SimpleModule {

    private final DomainTypeToResourceConverter domainTypeToResourceConverter;

    public DomainTypeResourceModule(final DomainTypeToResourceConverter domainTypeToResourceConverter) {
        super("DomainTypeResourceModule", Version.unknownVersion());

        this.domainTypeToResourceConverter = domainTypeToResourceConverter;
    }

    @Override
    public void setupModule(final SetupContext context) {
        SimpleSerializers serializers = new SimpleSerializers();
        serializers.addSerializer(DomainTypeResource.class, new DomainTypeResourceSerializer());
        serializers.addSerializer(Date.class, new JsonDateSerializer());

        SimpleDeserializers deserializers = new SimpleDeserializers();
        deserializers.addDeserializer(Date.class, new JsonDateDeserializer());

        context.addDeserializers(deserializers);
        context.addSerializers(serializers);
    }

    private class DomainTypeResourceSerializer extends SerializerBase<DomainTypeResource> {

        protected DomainTypeResourceSerializer() {
            super(DomainTypeResource.class);
        }

        @Override
        public void serialize(DomainTypeResource value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
            if (null == value) {
                provider.defaultSerializeNull(jgen);
                return;
            }

            final Resource resource = domainTypeToResourceConverter.convert(value.getResource(), value.getConfigurationUnitType(), value.getFieldMetadatas());

            jgen.writeObject(resource);
        }
    }

    private class JsonDateSerializer extends SerializerBase<Date> {

        protected JsonDateSerializer() {
            super(Date.class);
        }

        @Override
        public void serialize(Date date, JsonGenerator gen, SerializerProvider provider) throws IOException, JsonProcessingException {

            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            String formattedDate = date == null ? "" : dateFormat.format(date);

            gen.writeString(formattedDate);
        }

    }

    private class JsonDateDeserializer extends StdDeserializer<Date> {

        protected JsonDateDeserializer() {
            super(Date.class);
        }

        @Override
        public Date deserialize(JsonParser json, DeserializationContext context) throws IOException, JsonProcessingException {

            try {
                if(json.getText() != null && !"".equals(json.getText().trim())) {
                    try {
                        return new Date(Long.parseLong(json.getText()));
                    }
                    catch(NumberFormatException nex){
                        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
                        return dateFormat.parse(json.getText());
                    }
                }
                else return null;
            }
            catch (ParseException e){
                return null;
            }
        }

    }

}

package org.lightadmin.core.rest；
导入java.io.IOException；
导入java.text.ParseException；
导入java.text.simpleDataFormat；
导入java.util.Date；
导入org.codehaus.jackson.jsonggenerator；
导入org.codehaus.jackson.JsonParser；
导入org.codehaus.jackson.JsonProcessingException；
导入org.codehaus.jackson.Version；
导入org.codehaus.jackson.map.DeserializationContext；
导入org.codehaus.jackson.map.SerializerProvider；
导入org.codehaus.jackson.map.desr.std.StdDeserializer；
导入org.codehaus.jackson.map.module.simpledSerializers；
导入org.codehaus.jackson.map.module.SimpleModule；
导入org.codehaus.jackson.map.module.SimpleSerializers；
导入org.codehaus.jackson.map.ser.std.rbase；
导入org.springframework.hateoas.Resource；
公共类DomainTypeResourceModule扩展SimpleModule{
私有最终域TypeToResourceConverter域TypeToResourceConverter；
公共域TypeResourceModule（最终域TypeToResourceConverter域TypeToResourceConverter）{
超级（“DomainTypeResourceModule”，Version.unknownVersion（））；
this.domainTypeToResourceConverter=domainTypeToResourceConverter；
}
@凌驾
公共无效设置模块（最终设置上下文）{
SimpleSerializers序列化程序=新的SimpleSerializers（）；
serializers.addSerializer（DomainTypeResource.class，新的DomainTypeResourceSerializer（））；
addSerializer（Date.class，新的JsonDateSerializer（））；
SimpleDeserializers反序列化程序=新的SimpleDeserializers（）；
addDeserializer（Date.class，新的JsonDateDeserializer（））；
addDeserializers（反序列化程序）；
addSerializers（序列化程序）；
}
私有类DomainTypeResourceSerializer扩展SerializerBase{
受保护的DomainTypeResourceSerializer（）{
super（DomainTypeResource.class）；
}
@凌驾
public void serialize（DomainTypeResource值、JsonGenerator jgen、SerializerProvider提供程序）引发IOException{
if（null==值）{
provider.defaultSerializeNull（jgen）；
返回；
}
最终资源资源=DomainTypeStoreSourceConverter.convert（value.getResource（），value.getConfigurationUnitType（），value.getFieldMetadatas（））；
jgen.writeObject（资源）；
}
}
私有类JsonDateSerializer扩展SerializerBase{
受保护的JsonDateSerializer（）{
超级（日期类）；
}
@凌驾
public void serialize（日期、JsonGenerator gen、SerializerProvider提供程序）引发IOException、JsonProcessingException{
SimpleDataFormat dateFormat=新SimpleDataFormat（“yyyy-MM-dd”）；
字符串formattedDate=date==null？”：dateFormat.format（日期）；
一般书面记录（格式日期）；
}
}
私有类JsonDa