如何创建扩展 RuntimeException 的抽象泛型 class

Question

I want to create some generic abstract class:

public abstract class SomeDomainValidationException<E extends Enum<E>> extends ValidationException {

    private final E hint;

    public SomeDomainValidationException(String message, E hint) {
        super(message);
        this.hint = hint;
    }
}

where:

@ResponseStatus(value = HttpStatus.BAD_REQUEST)
public class ValidationException extends RuntimeException {
    public ValidationException(String message) {
        super(message);
    }
}

I want to group different types of exceptions in my code, eg I want to create different types of exceptions like:

WarehouseMatchingException 
               extends SomeDomainValidationException<WarehouseWrongDatesEnum>

but of course I can't because generic class may not extend 'java.lang.Throwable'

How to create generic class that represents different types of exceptions included in some enums like WarehouseWrongDatesEnum ?

Answer 1

You could use some interfaces to achieve something like this but this feels a little hacky. I'll post it anyway to let you decide for yourself.

First, we'll create 3 interfaces: one to return the "raw" hin, one to return the "generic" hint and one to do a cast:

//return the raw hint - this is an internal interface
interface RawxceptionHint {
    Object getRawHint();
}

//return the generic hint - this is a public interface
interface ExceptionHint<T>{
    T getHint();
}

//adapter to cast the raw hint to the generic one
interface ExceptionHintAdapter<T> extends ExceptionHint<T>, RawxceptionHint {
    default T getHint() {
        return (T)getRawHint();
    }               
}

Now you can implement your exceptions:

public abstract class SomeDomainValidationException extends ValidationException implements RawxceptionHint {

  private final Object  hint;

  public SomeDomainValidationException(String message, Object hint) {
      super(message);
      this.hint = hint;
  }

  public Object getRawHint() {
    return hint;
  }
}

class WarehouseMatchingException 
           extends SomeDomainValidationException 
           implements ExceptionHintAdapter<WarehouseWrongDatesEnum> {
  WarehouseMatchingException (String message, WarehouseWrongDatesEnum hint) {
     super(message, hint);
  }
}

Now you can access the hint via Object getRawHint() or WarehouseWrongDatesEnum getHint() . If you want to restrict access to getRawHint() you could cast the exception to ExceptionHint<WarehouseWrongDatesEnum> .

Note : as stated initially this feels somewhat hacky and I'm not sure this would even provide any benefit. Maybe there's a better solution that I can't think of right now and which supports what you need/want. However, not using that generic "middle class" SomeDomainValidationException and putting the hint and its methods directly into WarehouseMatchingException would be the safer and less hacky option.