Wie führe ich Logik auf Optional aus, wenn sie nicht vorhanden ist?

Ich möchte den folgenden Code mit java8 ersetzen Optional:

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

    return obj;
}

Der folgende Pseudocode funktioniert nicht, da es keine orElseRunMethode gibt, aber er veranschaulicht trotzdem meinen Zweck:

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

Mit Java 9 oder höher ifPresentOrElseist höchstwahrscheinlich das, was Sie wollen:

Optional<> opt = dao.find();

opt.ifPresentOrElse(obj -> obj.setAvailable(true),
                    () -> logger.error("…"));

Currying mit vavr oder ähnlichem könnte noch ordentlicheren Code erhalten, aber ich habe es noch nicht versucht.

Ich glaube nicht, dass Sie es in einer einzigen Aussage schaffen können. Besser machen:

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

Für Java 8 bietet Spring ifPresentOrElse"Utility-Methoden zum Arbeiten mit Optionals" an, um das zu erreichen, was Sie wollen. Beispiel wäre:

import static org.springframework.data.util.Optionals.ifPresentOrElse;    

ifPresentOrElse(dao.find(), obj -> obj.setAvailable(true), () -> logger.fatal("Object not available"));

Sie müssen dies in mehrere Anweisungen aufteilen. Hier ist eine Möglichkeit, dies zu tun:

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

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

Ein anderer (möglicherweise überentwickelter) Weg ist die Verwendung von map:

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

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

Wenn Sie obj.setAvailablebequem zurückkehren obj, können Sie einfach das zweite Beispiel zu:

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

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

Zuallererst dao.find()sollten Sie entweder eine zurückgeben Optional<Obj>oder Sie müssen eine erstellen.

z.B

Optional<Obj> = dao.find();

oder du kannst es selbst machen wie:

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

Dieser wird zurückkehren, Optional<Obj>wenn vorhanden oder Optional.empty()nicht vorhanden.

Kommen wir nun zur Lösung:

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;
        });
    }

Dies ist der Liner, den Sie suchen :)

Es gibt eine .orElseRunMethode, die aber aufgerufen wird .orElseGet.

Das Hauptproblem mit Ihrem Pseudocode ist, dass .isPresentkein zurückgegeben wird Optional<>. Aber .mapgibt eine , Optional<>die das hat orElseRunMethode.

Wenn Sie dies wirklich in einer Anweisung tun möchten, ist dies möglich:

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

Aber das ist noch klobiger als das, was Sie vorher hatten.

Ich konnte ein paar "One Line" -Lösungen entwickeln, zum Beispiel:

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

oder

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

oder

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

Es sieht nicht sehr gut aus, so etwas orElseRunwäre viel besser, aber ich denke, diese Option mit Runnable ist akzeptabel, wenn Sie wirklich eine einzeilige Lösung wollen.

Mit Java 8 Optionalist Folgendes möglich:

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

    obj.map(obj.setAvailable(true)).orElseGet(() -> {
        logger.fatal("Object not available");
        return null;
    });

Für diejenigen unter Ihnen, die einen Nebeneffekt nur ausführen möchten, wenn ein optionales fehlt

dh ein Äquivalent von ifAbsent()oder ifNotPresent()hier ist eine geringfügige Änderung der bereits gegebenen großartigen Antworten.

myOptional.ifPresentOrElse(x -> {}, () -> {
  // logic goes here
})

Sie benötigen Optional.isPresent () und orElse () . Ihr Snippet funktioniert nicht, weil es nichts zurückgibt, wenn es nicht vorhanden ist.

Der Punkt von Optional besteht darin, es von der Methode zurückzugeben.

ifPresentOrElse kann auch Fälle von Nullzeigern behandeln. Einfacher Ansatz.

   Optional.ofNullable(null)
            .ifPresentOrElse(name -> System.out.println("my name is "+ name),
                    ()->System.out.println("no name or was a null pointer"));

Ich nehme an, Sie können die dao.find()Methode zur Rückgabe einer Instanz von nicht ändern Optional<Obj>, daher müssen Sie die entsprechende Methode selbst erstellen.

Der folgende Code soll Ihnen helfen. Ich habe die Klasse erstellt OptionalAction, die den If-else-Mechanismus für Sie bereitstellt.

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);
      }
    }
  }
}