API функциональной карты Infinispan: работа с отдельными записями

В этом примере демонстрируются некоторые ключевые аспекты работы с отдельными записями с использованием API-интерфейса Functional Map:

• Методы с одной записью — это асинхронные возвращающие   экземпляры CompletableFuture, которые предоставляют методы для компоновки и цепочки операций, чтобы можно было чувствовать, что они выполняются последовательно. К сожалению, в Java нет  нотации do Haskell  или  Scala для понимания,  чтобы сделать его более приемлемым, но это хорошая новость, что Java наконец-то предлагает механизмы для работы с CompletableFutures неблокирующим способом, даже если они немного более многословны, чем предложено на других языках.
• All data-handling methods for WriteOnlyMap return CompletableFuture<Void>, meaning that the user can find out when the operation has completed but nothing else, because there’s nothing the function can provide that could not be computed in advance or outside the function.
• The return type for most of the data handling methods in ReadOnlyMap (and ReadWriteMap) are quite flexible. So, a function can decide to return value information, or metadata, or for convenience, it can also return the ReadEntryView it receives as parameter. This can be useful for users wanting to return both value and metadata parameter information.
• The read-write operation demonstrated above showed how to remove an entry and return the previously associated value. In this particular case, we know there’s a value associated with the entry and hence we called ReadEntryView.get() directly, but if we were not sure if the value is present or not, ReadEntryView.find() should be called and return the Optional instance instead.
• In the example, Lifespan metadata parameter is constructed using the new Java Time API available in Java 8, but it could have been done equally with java.util.concurrent.TimeUnit as long as the conversion was done to number of milliseconds during which the entry should be accessible.
• Lifespan-based expiration works just as it does with other Infinispan APIs, so you can easily modify the example to lower the lifespan, wait for duration to pass and then verify that the value is not present any more.

If storing a constant value, WriteOnlyMap.eval(K, Consumer) could be used instead of WriteOnlyMap.eval(K, V, Consumer), making the code clearer, but if the value is variable, WriteOnlyMap.eval(K, V, Consumer)should be used to avoid, as much as possible, functions capturing external variables. Clearly, operations exposed by functional map can’t cover all scenarios and there might be situations where external variables are captured by functions, but these should in general, should be a minority. Here is as example showing how to implement ConcurrentMap.replace(K, V, V) where external variable capturing is required:

import org.infinispan.commons.api.functional.FunctionalMap.ReadWriteMap;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;

ReadWriteMap<String, String> readWriteMap = ...

// First, do a put-if-absent like operation
CompletableFuture<Boolean> putIfAbsentFuture = readWriteMap.eval("key1", readWriteView -> {
   Optional<String> opt = readWriteView.find();
   boolean isAbsent = !opt.isPresent();
   if (isAbsent) readWriteView.set("value1");
   return isAbsent;
});

// Chain the put if absent with an operation to log whether the put-if-absent was successful
CompletableFuture<Void> logPutIfAbsentFuture = putIfAbsentFuture.thenAccept(
   success -> System.out.printf("Put if absent successful? %s%n", success));

// Next, chain a replace operation comparing a captured value via equals
String oldValue = "value1";
CompletableFuture<Boolean> replaceFuture = logPutIfAbsentFuture.thenCompose(x ->
   readWriteMap.eval("key1", "value2", (v, readWriteView) ->
      readWriteView.find().map(prev -> {
         if (prev.equals(oldValue)) {
            readWriteView.set(v);
            return true; // Old value matches so set new value and return success
         }
         return false; // Old value does not match
      }).orElse(false) // No value found in the map
));

// Finally, log the result of replace
CompletableFuture<Void> logReplaceFuture = replaceFuture.thenAccept(
   replaced -> System.out.printf("Replace successful? %s%n", replaced));

// Wait for the chain of operations to complete
logReplaceFuture.get();