抛出由参数传递给 function - java 的异常

Question

im currently working in a complete generic scenario in which i map a json as string to a dto class. That works fine with my function mapJsonToDto but im trying to make it more generic so that the developer who uses this function can also specify what exception to be thrown. So they can catch as they like. With this i avoid catching an IOException. Letting the function handle everything.

public class MapperUtils {
    public <T extends Throwable> Object mapJsonToDto(Class<?> dtoClass, String jsonDto, T exceptionToThrow) throws IOException {
        Object dto = null;
        try {
            dto = new ObjectMapper().readValue(jsonDto, dtoClass);
        } catch (IOException e) {
            throw new exceptionToThrow();
        }
        return dto;
    }
}

I cannot understand how to pass an exception class instance to a function and throwing that specific as well.

Answer 1

Instead of passing the exception to throw (which would then have a completely wrong stack trace), I think you'd want a function that converts an exception from one type to another:

public <T extends Throwable, D> D mapJsonToDto(Class<D> dtoClass, String json, Function<IOException, T> exceptionMapper) throws T {
    try {
        return new ObjectMapper().readValue(json, dtoClass);
        // if readValue doesn't do the casting right, try:
        return dtoClass.cast(new ObjectMapper().readValue(json, dtoClass);
    } catch (IOException e) {
        throw exceptionMapper.apply(e);
    }
}

And an example:

Person p = mapJsonToDto(Person.class, "{name: \"Joe\"}",
  e -> new IllegalArgumentException("malformed JSON", e));

As a general rule, though, this seems like boneheaded design. If you find the IOException overly general, then you can't handwave the problem away by allowing the caller to provide a no doubt similarly overly general mapper. The only way out for a caller is to do a deep dive on the exception and write, I dunno, an if/elseif block with a ton of levels to it to try to ascertain the real problem eg via analysing the message, which is all sorts of ugly.

Either you don't care about that level of detail and you should therefore just stick with IOException (what point is there adding code and pointless layers of indirection?), or you do care and this isn't good enough; you'd want to design a better error system. Except, that's not your job, that'd be ObjectMapper.readValue 's job. Which is why the IOException it throws should probably just be sent on unmolested.

Answer 2

Your example is nearly done. I changed only the throws Type to T and throw the given exception.

public <T extends Throwable> Object mapJsonToDto(Class<?> dtoClass, String jsonDto, T exceptionToThrow) throws T {
    Object dto = null;
    try {
        dto = new ObjectMapper().readValue(jsonDto, dtoClass);
    } catch (IOException e) {
        throw exceptionToThrow;
    }
    return dto;
}

Call: mapJsonToDto(String.class, "helo", new IllegalStateException());