Collegamento per l'uso facoltativo di Guava con eccezioni?

Question

Continuo a scrivere specifici lanciatori di eccezioni nel caso in cui l'opzionale sia assente.

Per esempio:

Optional<?> optional = ...; 
if (!optional.isPresent()) { 
    throw new MyException(); 
} 
Object result = optional.get(); 

Trovo che questo codice non molto fluente, in particolare l'uso del punto esclamativo (!). Preferirei come scrivere qualcosa di simile a:

Optional<?> optional = ...; 
Object result = optional.orThrow(MyException.class); 

Esiste un collegamento nella Guava che non ho ancora trovato?

Answer 1

Parlando come sviluppatore Guava, vorrei provare a decomprimere la logica qui. Rispondendo sia alla domanda originale, sia alla discussione del commento direttamente sulla domanda:

È assolutamente il caso che cerchiamo di costringere gli utenti di Guava a rispettare i nostri standard di buone abitudini di programmazione. (I nostri standard sono fortemente influenzato da esempio Effective Java.)

Detto questo, sono d'accordo che ci sono perfettamente buoni casi di utilizzo per il comportamento ti riferisci in questa particolare domanda: "se assente, un'eccezione ". Forse stai implementando una classe a cui è possibile accedere in entrambi i modi: un metodo con un valore di ritorno Opzionale e un metodo che presuppone che il valore sarà sempre presente, generando altrimenti un'eccezione. L'interfaccia di Deque, ad esempio, fornisce versioni a valore speciale e di eccezione per peek, poll e offerte.

Tutto ciò che ha detto, al meglio della mia comprensione, il Vero Guava modo per farlo è ...

if (value.isPresent()) { 
    return value.get(); 
} else { 
    throw new MyException(); 
} 

Il metodo "orThrow" proponi richiede una riflessione (!!), non lo fa ti consente di personalizzare l'eccezione con un messaggio utile, ecc. Il "modo normale" è perfettamente leggibile e più efficiente.

A volte Guava non fornisce supporto esplicito per le cose, perché per quei casi d'uso, pensiamo che sia meglio fare solo il "modo normale". Penso che questo sia il caso qui.

Answer 2

Non penso che questo appartenga alla biblioteca. Trovo molto raro trovare una libreria che riceva un'istanza di un'eccezione da gettare nel caso in cui qualcosa non vada come previsto, soprattutto perché in molti casi un'eccezione deve avere un messaggio che indica cosa è andato storto.

Detto questo, è possibile creare la propria classe opzionale che fa ciò di cui si ha bisogno. Oppure si può creare la propria classe OptionalHelper in cui si dispone di un metodo che fa quello che si vuole:

public class OptionalHelper { 
    public <T> T valueOrThrow(final Optional<T> optional) throws MyException { 
     if (optional.isPresent()) { 
      return optional.get(); 
     } else { 
      throw new MyException(); 
     } 
    } 
} 

EDIT:

Supponiamo di avere una classe personalizzata che riceve un nome di parametro/campo che è necessario controllare , si potrebbe avere un approccio migliore simile a quello che fa Presupposti:

public class OptionalHelper { 
    public <T> T valueOrFail(final Optional<T> optional, final String fieldName) throws OptionalNotPresentError { 
     if (optional.isPresent()) { 
      return optional.get(); 
     } else { 
      throw new OptionalNotPresentError(fieldName); 
     } 
    } 
} 

Answer 3

Ecco un altro modo per farlo senza aggiunte di Guava:

Object result = optional.or(new Supplier() { 
    public Object get() { 
     throw new MyException(); 
    } 
}); 

MyException deve essere deselezionato, ma ciò consente di passare argomenti al suo costruttore. E, naturalmente, se lo fai molto, puoi conservare il Fornitore da qualche parte e usarlo in ogni posto che ti serve.

Object result = optional.or(SomethingIsMissing.INSTANCE); 

Answer 4

questo funziona per me (nessuna riflessione, basta digitare l'inferenza):

public class ExceptionSupplier<T, E extends RuntimeException> implements Supplier<T> { 

    private final E exception; 

    private ExceptionSupplier(E exception) { 
     this.exception = exception; 
    } 

    public static <T, E extends RuntimeException> ExceptionSupplier<T, E> throwA(E exception) { 
     return new ExceptionSupplier<T, E>(exception); 
    }  

    public static <T, E extends RuntimeException> ExceptionSupplier<T, E> throwA(@SuppressWarnings("UnusedParameters") Class<T> class_, E exception) { 
     return new ExceptionSupplier<T, E>(exception); 
    } 

    @Override 
    public T get() { 
     throw exception; 
    } 
} 

Usage:

Something something = optionalSomething.or(throwA(Something.class, new SomeException())); 

Questo probabilmente può essere esteso ancora di più, ma per i miei casi d'uso è sufficiente e facile capire.

Answer 5

Non vale nulla che Java 8 di Optional abbia un metodo orElseThrow che consente il comportamento richiesto.

Answer 6

Vedi official issue here

Decisione: NO - troppo costoso, non un modello comune, può semplicemente utilizzare isPresent(), gettare

Dal optional.orThrow(new Exception()) non è buono per le prestazioni, preferisco importazione statica, che è simile a @timk 's answer.

Result result = optional.or(throwException()); 

Uguale a

Result result = optional.or(SomeSupplier.throwException()); 

Metodo statico

public static Supplier<Result> throwException() { 
    return new Supplier<Result>() { 
     @Override 
     public Result get() { 
      throw new RuntimeException(); 
     } 

    }; 
} 

===========

L'analisi dello stack si presenta come

Exception ... RuntimeException 
at SomeSupplier$1.get(SomeSupplier.java:line where throw RuntimeException) 
at SomeSupplier$1.get(SomeSupplier.java:1) 
at com.google.common.base.Absent.or(Absent.java:60) 
at line where call optional.or(throwException());