当我们实际开发中，时间类型的字段，接收和返回时，如果需要得到自己想要的格式，一般常用的就是在实体类时间类型的字段加注解，设置格式，这样的话比较麻烦，繁琐，以后每个类都得加就比较麻烦，所以推荐以下方式，亲测没问题。

直接上代码：

1. 封装的时间实体类

import lombok.Data;

@Data
public class DateParam {

    /**
     * 年
     */
    private int year;
    /**
     * 月
     */
    private int month;
    /**
     * 日
     */
    private int day;
    /**
     * 时
     */
    private int hour;
    /**
     * 分
     */
    private int minute;
    /**
     * 秒
     */
    private int second;
}

2. 时间转换工具

import com.ruoyi.common.core.domain.entity.DateParam;
import com.ruoyi.common.utils.DateUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.convert.converter.Converter;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 日期转换类
 * 将标准日期、标准日期时间、时间戳转换成Date类型
 */
public class DateConverter implements Converter<String, Date> {
    private Logger logger = LoggerFactory.getLogger(DateConverter.class);
    private static final String dateFormat = "yyyy-MM-dd HH:mm:ss";
    private static final String shortDateFormat = "yyyy-MM-dd";
    private static final String timeStampFormat = "^\\d+$";

    @Override
    public Date convert(String value) {
        logger.info("转换日期：" + value);
        if (value == null || value.trim().equals("") || value.equalsIgnoreCase("null")) {
            return null;
        }
        value = value.trim();
        try {
            if (value.contains("-")) {
                SimpleDateFormat formatter;
                if (value.contains(":")) {
                    formatter = new SimpleDateFormat(dateFormat);
                } else {
                    formatter = new SimpleDateFormat(shortDateFormat);
                }
                return formatter.parse(value);
            } else if (value.matches(timeStampFormat)) {
                Long lDate = new Long(value);
                return new Date(lDate);
            }
        } catch (Exception e) {
            throw new RuntimeException(String.format("parser %s to Date fail", value));
        }
        throw new RuntimeException(String.format("parser %s to Date fail", value));
    }

    public static String convertDateToStr(Date date) {
        DateParam dateParam = DateUtils.getDateDetail(date);
        SimpleDateFormat formatter;
        if (0 == dateParam.getHour() && 0 == dateParam.getMinute() && 0 == dateParam.getSecond()) {
            formatter = new SimpleDateFormat(DateUtils.YYYY_MM_DD);
        } else {
            formatter = new SimpleDateFormat(DateUtils.YYYY_MM_DD_HH_MM_SS);
        }

        String formattedDate = formatter.format(date);
        return formattedDate;
    }
}

3. Json序列化和反序列化转换器，用于转换Post请求体中的json以及将我们的对象序列化为返回响应的json

1.使用@RequestBody注解的对象中的Date类型将从这里被转换

2.支持后端Long类型的返回给前端为string, 用于解决过长的Long类型返回前端后，精度丢失的问题，注释部分放开后，可支持根据条件转换部分的Long类型的字段（根据实际开发需要改动）

@Configuration

public class ResourcesConfig implements WebMvcConfigurer { 
 /**
     * 添加消息转化类
     *
     * @param list
     */
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> list) {
        MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
        ObjectMapper objectMapper = this.objectMapper();
        //序列换成json时,将所有的long变成string
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
        //支持部分Long转换
//        simpleModule.addSerializer(Long.class, new JsonSerializer<Long>() {
//            @Override
//            public void serialize(Long data, JsonGenerator jsonGenerator, SerializerProvider
//                    serializerProvider) throws IOException {
//                if (ObjectUtil.isNotEmpty(data) && data.toString().length() > 17) {
//                    jsonGenerator.writeString(data.toString());
//                } else {
//                    jsonGenerator.writeNumber(data);
//                }
//
//            }
//        });
        objectMapper.registerModule(simpleModule);
        jsonConverter.setObjectMapper(objectMapper);
        list.add(0, jsonConverter);
    }
 @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        //Date序列化和反序列化
        javaTimeModule.addSerializer(Date.class, new JsonSerializer<Date>() {
            @Override
            public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider
                    serializerProvider) throws IOException {
                //将Date类型的转化为字符串
                jsonGenerator.writeString(DateConverter.convertDateToStr(date));
            }
        });
        javaTimeModule.addDeserializer(Date.class, new JsonDeserializer<Date>() {
            @Override
            public Date deserialize(JsonParser jsonParser, DeserializationContext
                    deserializationContext) throws IOException {
                return new DateConverter().convert(jsonParser.getText());
            }

        });
        objectMapper.registerModule(javaTimeModule);
        return objectMapper;
    }
  }

注意：后端返回尽量用实体类返回，用map的话，时间类得的字段需要sql里面进行格式转换.