-3

我有以下对象：

@Validated
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
@ToString
@Schema(description = "Request")
public final class Request implements Serializable {
    private static final long serialVersionUID = 1L;

    @JsonProperty("date")
    @Schema(description = "Date")
    private OffsetDateTime date;
}

我将此对象作为休息控制器的响应发送：

@RestController
public class RequestController {

    @RequestMapping(
        value = "/requests",
        produces = {"application/json;charset=UTF-8"}, 
        consumes = {"application/json"},
        method = RequestMethod.POST)
    public ResponseEntity<Request> get() {
        LocalDate date = LocalDate.of(2021, Month.OCTOBER, 22);
        OffsetDateTime dateTime = date.atTime(OffsetTime.MAX);
        Request request = new Request(dateTime);
        return ResponseEntity.ok(request);
    }
}

然而我有配置：

@Configuration
public class WebConfiguration implements ServletContextInitializer, WebMvcConfigurer {

    private final List<FilterRegistration> filterRegistrations;
    private final ApplicationContext applicationContext;

    public WebConfiguration(List<RestApplicationInstaller> restApplicationInstallers,
                            List<MonitoringRestApplicationInstaller> monitoringRestApplicationInstallers,
                            List<FilterRegistration> filterRegistrations,
                            ApplicationContext applicationContext) {
        this.filterRegistrations = filterRegistrations;
        this.applicationContext = applicationContext;
    }

    @Override
    public void onStartup(ServletContext servletContext) {
        VersionServletInstaller.installServlets(servletContext, getRegisterAsyncService(servletContext));
        filterRegistrations.forEach(filterRegistration -> filterRegistration.onApplicationEvent(new ContextRefreshedEvent(applicationContext)));
    }

    private RegisterAsyncService getRegisterAsyncService(final ServletContext servletContext) {
        final WebApplicationContext ctx = getWebApplicationContext(servletContext);
        final RegisterAsyncService registerAsyncService = Objects.requireNonNull(ctx).getBean(RegisterAsyncService.class);
        registerAsyncService.exec();
        return registerAsyncService;
    }

    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jsonCustomizer(CustomAnnotationIntrospector customAnnotationIntrospector) {
        return builder -> builder.serializationInclusion(NON_NULL)
            .annotationIntrospector(customAnnotationIntrospector);
    }
}

好的。所以......我得到的date回应是：

2021-10-21T23:59:59.999999999-18:00

当我测试我的控制器时，我尝试获得响应，将其反序列化为Request对象并检查匹配：

@DirtiesContext
@SpringBootTest(
    classes = {WebConfiguration.class, JacksonAutoConfiguration.class},
    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ExtendWith(SpringExtension.class)
@EnableWebMvc
class RequestControllerTest {

    private static final CharacterEncodingFilter 
    CHARACTER_ENCODING_FILTER = new CharacterEncodingFilter();

    static {
        CHARACTER_ENCODING_FILTER.setEncoding(DEFAULT_ENCODING);
        CHARACTER_ENCODING_FILTER.setForceEncoding(true);
    }

    protected MockMvc mockMvc;

    @Autowired
    protected ObjectMapper objectMapper;

    @Autowired
    private WebApplicationContext context;

    @PostConstruct
    private void postConstruct() {
        this.mockMvc =
            MockMvcBuilders
                .webAppContextSetup(this.context)
                .addFilters(CHARACTER_ENCODING_FILTER)
                .build();
    }

    @Test
    void requestByIdTest() throws Exception {
        mockMvc.perform(
            MockMvcRequestBuilders.post("/requests")
                .characterEncoding(CHARACTER_ENCODING_FILTER)
                .contentType(MediaType.APPLICATION_JSON))
            .andDo(print())
            .andExpect(status().isOk())
            .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
            .andExpect(
                result -> Assertions.assertEquals(mapToObject(result.getResponse().getContentAsString(Charset.forName(CHARACTER_ENCODING_FILTER)), Request.class), getExpectedRequest()));
    }

    private WebComplianceRequest getExpectedRequest() {
        LocalDate date = LocalDate.of(2021, Month.OCTOBER, 22);
        OffsetDateTime dateTime = date.atTime(OffsetTime.MAX);
        Request request = new Request(dateTime);
    }

    private <T> T mapToObject(String json, Class<T> targetClass) {
        try {
            return getReaderForClass(targetClass).readValue(json);
        } catch (IOException e) {
            throw new RuntimeExsception(e);
        }
    }

    private <T> ObjectReader getReaderForClass(Class<T> targetClass) {
        return objectMapper.readerFor(targetClass);
    }
}

但我得到一个例外，因为date预期对象和得到对象中的字段不同：

Date in response: 2021-10-22T17:59:59.999999999Z
Expected date:    2021-10-21T23:59:59.999999999-18:00

为什么会这样？

为什么Z出现而不是时区？为什么日期从 更改2021-10-21为2021-10-22？我该如何解决？

我没有得到任何异常，我匹配失败，因为当我匹配响应和预期对象时日期不同。我只是用标准反序列化对象ObjectMapper并检查与equals().

4

1 回答 1

2

到目前为止我们所知道的

  1. 您正在创建一个OffsetDateTime从LocalDate添加可用的最大偏移量（恰好是-18:00小时）
  2. 这OffsetDateTime被正确序列化为 JSON 值2021-10-21T23:59:59.999999999-18:00
  3. 反序列化时，值 (as String) 为2021-10-22T17:59:59.999999999Z

到目前为止还没有包括关键部分：在 2. 和 3. 之间会发生什么？
请考虑用您所知道的一切更新您的问题。

我们可以得出什么

Instant出现不一致的值基本上是同一时刻-18:00（由于这些时刻之间有 18 小时的差异，并且由于您创建了一个with （即，一天中的最大时间偏移为）。+00:00ZOffsetDateTimeOffsetTime.MAX23:59:59.999999999-18:00-18:00

这就是为什么反序列化后得到的结果没有错，但它的表示可能不是你想要的。

我的猜测是，Instant在 2. 和 3. 之间的子步骤中使用了 an，并且反序列化仅提供 UTC 格式的日期和时间。

如果没有明确要求，我不会将最大偏移量传递给任何 API。是你的情况吗？考虑添加有关此的信息。

我们可以做些什么来使时间String相等

OffsetDateTime您可以使用从中创建的另一种可能性LocalDate，即使用一天中的最大时间，而在 UTC 处没有明确的偏移量：

OffsetDateTime dateTime = OffsetDateTime.of(date, LocalTime.MAX, ZoneOffset.UTC);

这将序列化为2021-10-21T23:59:59.999999999Z，您也可以将其表示为2021-10-21T23:59:59.999999999+00:00或类似（我会坚持Z）并且反序列化应该返回相同的值。

如果您收到StringUTC 格式的表示并且您对它没有任何影响，您将不得不解析它并通过应用最小偏移量 ( -18:00) 来更改表示，可能像这样：

String atMinOffset = OffsetDateTime.parse("2021-10-22T17:59:59.999999999Z")
                                   .withOffsetSameInstant(ZoneOffset.MIN)
                                   .format(DateTimeFormatter.ISO_OFFSET_DATE_TIME);
System.out.println(atMinOffset);

输出：

2021-10-21T23:59:59.999999999-18:00

如果您收到OffsetDateTime响应并且只想检查它是否是同一时间点，请考虑以下问题：

public static void main(String[] args) throws IOException {
    OffsetDateTime utcOdt = OffsetDateTime.parse("2021-10-22T17:59:59.999999999Z");
    OffsetDateTime minOffsetOdt = OffsetDateTime.parse("2021-10-21T23:59:59.999999999-18:00");
    
    System.out.println("OffsetDateTimes equal? --> " + utcOdt.equals(minOffsetOdt));
    System.out.println("Instants equal? --> " + utcOdt.toInstant().equals(minOffsetOdt.toInstant()));
}

它的输出是

OffsetDateTimes equal? --> false
Instants equal? --> true

为什么？
AnOffsetDateTime是某个时刻的表示Instant，而 an实际上是那个时刻。
这意味着您应该及时比较真实的时刻，而不是基于上下文的表示。

于 2021-11-30T16:30:31.937 回答