使用Optional.map.orElse返回不同​​的泛型类型

Question

I use Spring Boot to write a REST service. I need to return a different entity when an operation succeeds and fails accordingly. ResponseEntity in Spring is parametrized by type T . I know I can omit the type and return just ResponseEntity , but that is not enough when trying to create the response with Java 8 Optional 's orElse chain:

public ResponseEntity getDashboard(String user, UUID uuid) {
Optional<Dashboard> dashboard = dashboardService.getDashboard( user, uuid );

// this gives unchecked assignment: 'org.springframework.http.ResponseEntity' 
// to 'org.springframework.http.ResponseEntity<my.package.SomeClass>'
return dashboard
    .map( ResponseEntity::ok )
    .orElse( createNotFoundResponse( uuid, "No such object" ) );
}

public static <T> ResponseEntity createNotFoundResp( T entity, String message ) {
    ResponseMessage<T> responseMessage = new ResponseMessage<>( message, entity );
    return ResponseEntity.status( HttpStatus.NOT_FOUND ).body( responseMessage );
}

Due to Java compiler's type inference orElse clause should return the same type as when the optional is not empty, ie ResponseEntity<Dashboard> and not ResponseEntity<ResponseMessage> . I tried to subvert this problem, by providing different return paths like this:

if ( dashboard.isPresent() ) {
    return ResponseEntity.ok( dashboard.get() );
} else {
    return createNotFoundResponse( uuid, "No such object" );
}

...but then Intellij highlights the dashboard.isPresent() part and shouts that this block can be simplified to the one above (which results in unchecked warning).

Is there a way to write this code cleanly without any compiler warnings and @SuppressUnchecked annotations?

Answer 1

Is there a way to write this code cleanly without any compiler warnings and @SuppressUnchecked annotations?

I don't think you can get rid of compiler warnings in this case. One of possible clean solutions (at least, no compiler warnings) is rejecting the idea of Optional.map in favor of a simple if / else or ?: -driven strategy not available with fluent interfaces though.

static <T, U> ResponseEntity<?> okOrNotFound(final Optional<T> optional, final Supplier<? extends U> orElse) {
    return okOrNotFound(optional, "Not found", orElse);
}

static <T, U> ResponseEntity<?> okOrNotFound(final Optional<T> optional, final String message, final Supplier<? extends U> orElse) {
    return optional.isPresent()
            ? status(OK).body(optional.get())
            : status(NOT_FOUND).body(new NotFound<>(orElse.get(), message));
}

@RequestMapping(method = GET, value = "/")
ResponseEntity<?> get(
        @RequestParam("user") final String user,
        @RequestParam("uuid") final UUID uuid
) {
    final Optional<Dashboard> dashboard = dashboardService.getDashboard(user, uuid);
    return okOrNotFound(dashboard, () -> uuid);
}

Note orElse is not really what you wanted: orElseGet is lazy and only invokes its supplier if the given optional value is not present.

However, Spring features a better way to accomplish what you need and I believe a cleaner way of doing the things like that. Take a look at controller advices that are designed for such purposes.

// I would prefer a checked exception having a super class like ContractException
// However you can superclass this one into your custom super exception to serve various purposes and contain exception-related data to be de-structured below
final class NotFoundException
        extends NoSuchElementException {

    private final Object entity;

    private NotFoundException(final Object entity) {
        this.entity = entity;
    }

    static NotFoundException notFoundException(final Object entity) {
        return new NotFoundException(entity);
    }

    Object getEntity() {
        return entity;
    }

}

Now the REST controller method becomes:

@RequestMapping(method = GET, value = "/")
Dashboard get(
        @RequestParam("user") final String user,
        @RequestParam("uuid") final UUID uuid
) {
    return dashboardService.getDashboard(user, uuid)
            .orElseThrow(() -> notFoundException(uuid));
}

Spring is smart enough to convert objects to status(OK).body(T) itself, so we're just throwing an exception containing a single object we are interested in. Next, a sample controller exception advice might look as follows:

@ControllerAdvice
final class ExceptionControllerAdvice {

    @ExceptionHandler(NotFoundException.class)
    ResponseEntity<NotFound<?>> acceptNotFoundException(final NotFoundException ex) {
        return status(NOT_FOUND).body(notFound(ex));
    }

}

where notFound() method is implemented like this:

static NotFound<?> notFound(final NotFoundException ex) {
    return notFound(ex, "Not found");
}

static NotFound<?> notFound(final NotFoundException ex, final String message) {
    return new NotFound<>(ex.getEntity(), message);
}

For my spike project provides the following results:

• _http://localhost:8080/?user=owner&uuid=00000000-0000-0000-0000-000000000000 - {"description":"dashboard owned by owner"}
• _http://localhost:8080/?user=user&uuid=00000000-0000-0000-0000-000000000000 - {"entity":"00000000-0000-0000-0000-000000000000","message":"Not found"}