How to use LocalDateTime RequestParam in Spring? I get "Failed to convert String to LocalDateTime"

小开

最佳答案

TL;DR - you can capture it as a string with just @RequestParam, or you can have Spring additionally parse the string into a java date / time class via @DateTimeFormat on the parameter as well.

the @RequestParam is enough to grab the date you supply after the = sign, however, it comes into the method as a String. That is why it is throwing the cast exception.

There are a few ways to achieve this:

parse the date yourself, grabbing the value as a string.

@GetMapping("/test")
public Page<User> get(@RequestParam(value="start", required = false) String start){


//Create a DateTimeFormatter with your required format:
DateTimeFormatter dateTimeFormat =
new DateTimeFormatter(DateTimeFormatter.BASIC_ISO_DATE);


//Next parse the date from the @RequestParam, specifying the TO type as
a TemporalQuery:
LocalDateTime date = dateTimeFormat.parse(start, LocalDateTime::from);


//Do the rest of your code...
}

Leverage Spring's ability to automatically parse and expect date formats:

@GetMapping("/test")
public void processDateTime(@RequestParam("start")
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
LocalDateTime date) {
// The rest of your code (Spring already parsed the date).
}

小开

I ran into the same problem and found my solution here (without using Annotations)

...you must at least properly register a string to [LocalDateTime] Converter in your context, so that Spring can use it to automatically do this for you every time you give a String as input and expect a [LocalDateTime]. (A big number of converters are already implemented by Spring and contained in the core.convert.support package, but none involves a [LocalDateTime] conversion)

So in your case you would do this:

public class StringToLocalDateTimeConverter implements Converter<String, LocalDateTime> {
public LocalDateTime convert(String source) {
DateTimeFormatter formatter = DateTimeFormatter.BASIC_ISO_DATE;
return LocalDateTime.parse(source, formatter);
}
}

and then just register your bean:

<bean class="com.mycompany.mypackage.StringToLocalDateTimeConverter"/>

With Annotations

add it to your ConversionService:

@Component
public class SomeAmazingConversionService extends GenericConversionService {


public SomeAmazingConversionService() {
addConverter(new StringToLocalDateTimeConverter());
}


}

and finally you would then @Autowire in your ConversionService:

@Autowired
private SomeAmazingConversionService someAmazingConversionService;

You can read more about conversions with spring (and formatting) on this site. Be forewarned it has a ton of ads, but I definitely found it to be a useful site and a good intro to the topic.

小开

You did everything correct :) . Here is an example that shows exactly what you are doing. Just Annotate your RequestParam with @DateTimeFormat. There is no need for special GenericConversionService or manual conversion in the controller. This blog post writes about it.

@RestController
@RequestMapping("/api/datetime/")
final class DateTimeController {


@RequestMapping(value = "datetime", method = RequestMethod.POST)
public void processDateTime(@RequestParam("datetime")
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime dateAndTime) {
//Do stuff
}
}

I guess you had an issue with the format. On my setup everything works well.

小开

Like I put in the comment, you could also use this solution in the signature method: @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime start

小开

I found workaround here.

Spring/Spring Boot only supports the date/date-time format in BODY parameters.

The following configuration class adds support for date/date-time in QUERY STRING (request parameters):

// Since Spring Framwork 5.0 & Java 8+
@Configuration
public class DateTimeFormatConfiguration implements WebMvcConfigurer {


@Override
public void addFormatters(FormatterRegistry registry) {
DateTimeFormatterRegistrar registrar = new DateTimeFormatterRegistrar();
registrar.setUseIsoFormat(true);
registrar.registerFormatters(registry);
}
}

respectively:

// Until Spring Framwork 4.+
@Configuration
public class DateTimeFormatConfiguration extends WebMvcConfigurerAdapter {


@Override
public void addFormatters(FormatterRegistry registry) {
DateTimeFormatterRegistrar registrar = new DateTimeFormatterRegistrar();
registrar.setUseIsoFormat(true);
registrar.registerFormatters(registry);
}
}

It works even if you bind multiple request parameters to some class (@DateTimeFormat annotation helpless in this case):

public class ReportRequest {
private LocalDate from;
private LocalDate to;


public LocalDate getFrom() {
return from;
}


public void setFrom(LocalDate from) {
this.from = from;
}


public LocalDate getTo() {
return to;
}


public void setTo(LocalDate to) {
this.to = to;
}
}


// ...


@GetMapping("/api/report")
public void getReport(ReportRequest request) {
// ...

小开

Following works well with Spring Boot 2.1.6:

Controller

@Slf4j
@RestController
public class RequestController {


@GetMapping
public String test(RequestParameter param) {
log.info("Called services with parameter: " + param);
LocalDateTime dateTime = param.getCreated().plus(10, ChronoUnit.YEARS);
LocalDate date = param.getCreatedDate().plus(10, ChronoUnit.YEARS);


String result = "DATE_TIME: " + dateTime + "<br /> DATE: " + date;
return result;
}


@PostMapping
public LocalDate post(@RequestBody PostBody body) {
log.info("Posted body: " + body);
return body.getDate().plus(10, ChronoUnit.YEARS);
}
}

Dto classes:

@Value
public class RequestParameter {
@DateTimeFormat(iso = DATE_TIME)
LocalDateTime created;


@DateTimeFormat(iso = DATE)
LocalDate createdDate;
}


@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PostBody {
LocalDate date;
}

Test class:

@RunWith(SpringRunner.class)
@WebMvcTest(RequestController.class)
public class RequestControllerTest {


@Autowired MockMvc mvc;
@Autowired ObjectMapper mapper;


@Test
public void testWsCall() throws Exception {
String pDate        = "2019-05-01";
String pDateTime    = pDate + "T23:10:01";
String eDateTime = "2029-05-01T23:10:01";


MvcResult result = mvc.perform(MockMvcRequestBuilders.get("")
.param("created", pDateTime)
.param("createdDate", pDate))
.andExpect(status().isOk())
.andReturn();


String payload = result.getResponse().getContentAsString();
assertThat(payload).contains(eDateTime);
}


@Test
public void testMapper() throws Exception {
String pDate        = "2019-05-01";
String eDate        = "2029-05-01";
String pDateTime    = pDate + "T23:10:01";
String eDateTime    = eDate + "T23:10:01";


MvcResult result = mvc.perform(MockMvcRequestBuilders.get("")
.param("created", pDateTime)
.param("createdDate", pDate)
)
.andExpect(status().isOk())
.andReturn();


String payload = result.getResponse().getContentAsString();
assertThat(payload).contains(eDate).contains(eDateTime);
}




@Test
public void testPost() throws Exception {
LocalDate testDate = LocalDate.of(2015, Month.JANUARY, 1);


PostBody body = PostBody.builder().date(testDate).build();
String request = mapper.writeValueAsString(body);


MvcResult result = mvc.perform(MockMvcRequestBuilders.post("")
.content(request).contentType(APPLICATION_JSON_VALUE)
)
.andExpect(status().isOk())
.andReturn();


ObjectReader reader = mapper.reader().forType(LocalDate.class);
LocalDate payload = reader.readValue(result.getResponse().getContentAsString());
assertThat(payload).isEqualTo(testDate.plus(10, ChronoUnit.YEARS));
}


}

小开

The answers above didn't work for me, but I blundered on to one which did here: https://blog.codecentric.de/en/2017/08/parsing-of-localdate-query-parameters-in-spring-boot/ The winning snippet was the ControllerAdvice annotation, which has the advantage of applying this fix across all your controllers:

@ControllerAdvice
public class LocalDateTimeControllerAdvice
{


@InitBinder
public void initBinder( WebDataBinder binder )
{
binder.registerCustomEditor( LocalDateTime.class, new PropertyEditorSupport()
{
@Override
public void setAsText( String text ) throws IllegalArgumentException
{
LocalDateTime.parse( text, DateTimeFormatter.ISO_DATE_TIME );
}
} );
}
}

小开

You can add to config, this solution does work with optional as well as with non-optional parameters.

@Bean
public Formatter<LocalDate> localDateFormatter() {
return new Formatter<>() {
@Override
public LocalDate parse(String text, Locale locale) {
return LocalDate.parse(text, DateTimeFormatter.ISO_DATE);
}


@Override
public String print(LocalDate object, Locale locale) {
return DateTimeFormatter.ISO_DATE.format(object);
}
};
}




@Bean
public Formatter<LocalDateTime> localDateTimeFormatter() {
return new Formatter<>() {
@Override
public LocalDateTime parse(String text, Locale locale) {
return LocalDateTime.parse(text, DateTimeFormatter.ISO_DATE_TIME);
}


@Override
public String print(LocalDateTime object, Locale locale) {
return DateTimeFormatter.ISO_DATE_TIME.format(object);
}
};
}

小开

For global configuration :

public class LocalDateTimePropertyEditor extends PropertyEditorSupport {


@Override
public void setAsText(String text) throws IllegalArgumentException {
setValue(LocalDateTime.parse(text, DateTimeFormatter.ISO_LOCAL_DATE_TIME));
}


}

And then

@ControllerAdvice
public class InitBinderHandler {


@InitBinder
public void initBinder(WebDataBinder binder) {
binder.registerCustomEditor(OffsetDateTime.class, new OffsetDateTimePropertyEditor());
}


}

小开

SpringBoot 2.X.X and newer

If you use the dependency spring-boot-starter-web version 2.0.0.RELEASE or higher, there is no longer needed to explicitely include jackson-datatype-jsr310 dependency, which is already provided with spring-boot-starter-web through spring-boot-starter-json.

This was resolved as Spring Boot issue #9297 and the answer is still valid and relevant:

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.0.0.RELEASE</version>
</dependency>

@RequestMapping(value = "datetime", method = RequestMethod.POST)
public void foo(
@RequestParam("dateTime")
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime ldt) {


// IMPLEMENTATION
}

小开

Here is another general solution with parameter converter:

import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
import ru.diasoft.micro.msamiddleoffice.ftcaa.customerprofile.config.JacksonConfig;


import java.time.DateTimeException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


@Component
public class LocalDateTimeConverter implements Converter<String, LocalDateTime>{


private static final List<String> SUPPORTED_FORMATS = Arrays.asList("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", "[another date time format ...]");
private static final List<DateTimeFormatter> DATE_TIME_FORMATTERS = SUPPORTED_FORMATS
.stream()
.map(DateTimeFormatter::ofPattern)
.collect(Collectors.toList());


@Override
public LocalDateTime convert(String s) {


for (DateTimeFormatter dateTimeFormatter : DATE_TIME_FORMATTERS) {
try {
return LocalDateTime.parse(s, dateTimeFormatter);
} catch (DateTimeParseException ex) {
// deliberate empty block so that all parsers run
}
}


throw new DateTimeException(String.format("unable to parse (%s) supported formats are %s",
s, String.join(", ", SUPPORTED_FORMATS)));
}
}

小开

You can global configure datetime format in application properties. Like:

spring.mvc.format.date=yyyy-MM-dd

spring.mvc.format.date-time=yyyy-MM-dd HH:mm:ss

spring.mvc.format.time=HH:mm:ss

Check in mavern: org.springframework.boot:spring-boot-autoconfigure:2.5.3

小开

I had a similar problem in a related context

I am using WebRequestDataBinder to map the request params to a model dynamically.

Object domainObject = ModelManager.getEntity(entityName).newInstance();
WebRequestDataBinder binder = new WebRequestDataBinder(domainObject);
binder.bind(request);

This piece of code is working for primitives but did not work for LocalDateTime type attributes

To fix the problem, before calling binder.bind, I registered a custom editor before calling bind()

binder.registerCustomEditor(LocalDateTime.class, new PropertyEditorSupport()
{
@Override
public void setAsText(String text) throws IllegalArgumentException
{
setValue(LocalDateTime.parse(text, DateTimeFormatter.ISO_DATE_TIME));
}


@Override
public String getAsText() {
return DateTimeFormatter.ISO_DATE_TIME.format((LocalDateTime) getValue());
}


}
);

This solved the problem.