Jak wykonać logikę na Opcjonalne, jeśli nie występuje?

Question

Chcę zastąpić następujący kod przy użyciu java8 Optional:

public Obj getObjectFromDB() { 
    Obj obj = dao.find(); 
    if (obj != null) { 
     obj.setAvailable(true); 
    } else { 
     logger.fatal("Object not available"); 
    } 

    return obj; 
} 

Poniższy pseudokod nie działa, gdyż nie ma orElseRun metoda, ale tak czy inaczej to ilustruje mój cel:

public Optional<Obj> getObjectFromDB() { 
    Optional<Obj> obj = dao.find(); 
    return obj.ifPresent(obj.setAvailable(true)).orElseRun(logger.fatal("Object not available")); 
} 

Answer 1

I don” Sądzę, że możesz to zrobić w jednym komunikacie. Lepiej zrób:

if (!obj.isPresent()) { 
    logger.fatal(...); 
} else { 
    obj.get().setAvailable(true); 
} 
return obj; 

Answer 2

Trzeba Optional.isPresent() i orElse(). Twój snippet wygrał, t działa, ponieważ nie zwraca niczego, jeśli nie jest obecny.

Punkt Opcjonalny to zwrócenie go z metody.

Answer 3

Będziesz musiał podzielić to na wiele instrukcji. Oto jeden ze sposobów, aby to zrobić:

if (!obj.isPresent()) { 
    logger.fatal("Object not available"); 
} 

obj.ifPresent(o -> o.setAvailable(true)); 
return obj; 

Innym sposobem (prawdopodobnie ponad inżynierii) jest użycie map:

if (!obj.isPresent()) { 
    logger.fatal("Object not available"); 
} 

return obj.map(o -> {o.setAvailable(true); return o;}); 

Jeśli obj.setAvailable dogodnie zwraca obj, wtedy można po prostu drugi przykład do:

if (!obj.isPresent()) { 
    logger.fatal("Object not available"); 
} 

return obj.map(o -> o.setAvailable(true)); 

Answer 4

Przypuszczam, że nie można zmienić metodę dao.find() powrócić instancję Optional<Obj>, więc musisz sam utworzyć odpowiedni.

Poniższy kod powinien ci pomóc. Stworzyłem klasę OptionalAction, , która zapewnia mechanizm if-else dla ciebie.

public class OptionalTest 
{ 
    public static Optional<DbObject> getObjectFromDb() 
    { 
    // doa.find() 
    DbObject v = find(); 

    // create appropriate Optional 
    Optional<DbObject> object = Optional.ofNullable(v); 

    // @formatter:off 
    OptionalAction. 
    ifPresent(object) 
    .then(o -> o.setAvailable(true)) 
    .elseDo(o -> System.out.println("Fatal! Object not available!")); 
    // @formatter:on 
    return object; 
    } 

    public static void main(String[] args) 
    { 
    Optional<DbObject> object = getObjectFromDb(); 
    if (object.isPresent()) 
     System.out.println(object.get()); 
    else 
     System.out.println("There is no object!"); 
    } 

    // find may return null 
    public static DbObject find() 
    { 
    return (Math.random() > 0.5) ? null : new DbObject(); 
    } 

    static class DbObject 
    { 
    private boolean available = false; 

    public boolean isAvailable() 
    { 
     return available; 
    } 

    public void setAvailable(boolean available) 
    { 
     this.available = available; 
    } 

    @Override 
    public String toString() 
    { 
     return "DbObject [available=" + available + "]"; 
    } 
    } 

    static class OptionalAction 
    { 
    public static <T> IfAction<T> ifPresent(Optional<T> optional) 
    { 
     return new IfAction<>(optional); 
    } 

    private static class IfAction<T> 
    { 
     private final Optional<T> optional; 

     public IfAction(Optional<T> optional) 
     { 
     this.optional = optional; 
     } 

     public ElseAction<T> then(Consumer<? super T> consumer) 
     { 
     if (optional.isPresent()) 
      consumer.accept(optional.get()); 
     return new ElseAction<>(optional); 
     } 
    } 

    private static class ElseAction<T> 
    { 
     private final Optional<T> optional; 

     public ElseAction(Optional<T> optional) 
     { 
     this.optional = optional; 
     } 

     public void elseDo(Consumer<? super T> consumer) 
     { 
     if (!optional.isPresent()) 
      consumer.accept(null); 
     } 
    } 
    } 
} 

Answer 5

byłem w stanie wymyślił kilka rozwiązań "pierwsza linia", na przykład:

obj.map(o -> (Runnable)() -> o.setAvailable(true)) 
     .orElse(() -> logger.fatal("Object not available")) 
     .run(); 

lub

obj.map(o -> (Consumer<Object>) c -> o.setAvailable(true)) 
     .orElse(o -> logger.fatal("Object not available")) 
     .accept(null); 

lub

obj.map(o -> (Supplier<Object>)() -> { 
      o.setAvailable(true); 
      return null; 
    }).orElse(()() -> { 
      logger.fatal("Object not available") 
      return null; 
    }).get(); 

It nie wygląda ładnie, coś w stylu orElseRun byłby znacznie lepszy, ale myślę, że opcja z Runnable jest akceptowalna, jeśli naprawdę chcesz jedno rozwiązanie liniowe.

Answer 6

Nie jest metoda .orElseRun, ale to się nazywa .orElseGet, problemem jest to, że w przeciwieństwie .map, .isPresent nie zwraca Optional<Obj>.

Jeśli naprawdę chcesz to zrobić w jednej instrukcji jest to możliwe:

public Obj getObjectFromDB() { 
    return dao.find() 
     .map(obj -> { 
      obj.setAvailable(true); 
      return Optional.of(obj); 
     }) 
     .orElseGet(() -> { 
      logger.fatal("Object not available"); 
      return Optional.empty(); 
    }); 
} 

Ale to nawet clunkier niż to, co przedtem.

Answer 7

Po pierwsze, Twój dao.find() powinien albo zwrócić wartość Optional<Obj>, albo trzeba ją utworzyć.

np.

Optional<Obj> = dao.find(); 

lub możesz zrobić to sam lubię:

Optional<Obj> = Optional.ofNullable(dao.find()); 

ten powróci Optional<Obj> jeśli obecna lub Optional.empty() jeśli nie występuje.

Więc teraz przejdźmy do roztworu

public Obj getObjectFromDB() { 
    return Optional.ofNullable(dao.find()).flatMap(ob -> { 
      ob.setAvailable(true); 
      return Optional.of(ob);  
     }).orElseGet(() -> { 
      logger.fatal("Object not available"); 
      return null; 
     }); 
    } 

Jest to jeden liner szukasz :)