feat(spring): implement optional cache methods (#207)

* feat(spring-jdk17): implement optional cache retrieve methods

* feat(spring): implement evictIfPresent method

* fix(spring): ensure putIfAbsent is atomic

Author: iProdigy

spring-java17/src/main/java/io/github/xanthic/cache/springjdk17/XanthicSpringCache.java

@@ -5,6 +5,8 @@
 import org.springframework.cache.support.AbstractValueAdaptingCache;
 
 import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Supplier;
 
 public class XanthicSpringCache extends AbstractValueAdaptingCache {
 	private final String name;
@@ -54,11 +56,21 @@ public void put(@NotNull Object key, Object value) {
 		cache.put(key, toStoreValue(value));
 	}
 
+	@Override
+	public ValueWrapper putIfAbsent(@NotNull Object key, Object value) {
+		return toValueWrapper(cache.putIfAbsent(key, toStoreValue(value)));
+	}
+
 	@Override
 	public void evict(@NotNull Object key) {
 		cache.remove(key);
 	}
 
+	@Override
+	public boolean evictIfPresent(@NotNull Object key) {
+		return cache.remove(key) != null;
+	}
+
 	@Override
 	public void clear() {
 		cache.clear();
@@ -68,6 +80,22 @@ public void clear() {
 	protected Object lookup(@NotNull Object key) {
 		return cache.get(key);
 	}
-}
 
+	@Override
+	public CompletableFuture<?> retrieve(@NotNull Object key) {
+		Object value = lookup(key);
+		if (value == null) return null;
+		return CompletableFuture.completedFuture(toValueWrapper(value));
+	}
 
+	@NotNull
+	@Override
+	@SuppressWarnings("unchecked")
+	public <T> CompletableFuture<T> retrieve(@NotNull Object key, @NotNull Supplier<CompletableFuture<T>> valueLoader) {
+		return CompletableFuture.supplyAsync(
+			() -> (T) fromStoreValue(
+				cache.computeIfAbsent(key, k -> toStoreValue(valueLoader.get().join()))
+			)
+		);
+	}
+}

spring-java17/src/test/java/io/github/xanthic/cache/springjdk17/SpringCacheTest.java

@@ -13,6 +13,7 @@
 
 import java.util.Objects;
 import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -28,7 +29,7 @@ public class SpringCacheTest {
 	CacheManager cacheManager;
 
 	@Test
-	@DisplayName("Tests cache get, put, putIfAbsent, clear")
+	@DisplayName("Tests cache get, put, putIfAbsent, retrieve, clear")
 	public void putGetClearTest() {
 		Cache cache = Objects.requireNonNull(cacheManager.getCache("dev"));
 
@@ -43,6 +44,18 @@ public void putGetClearTest() {
 		Assertions.assertEquals(420, Objects.requireNonNull(cache.putIfAbsent("4/20", 69)).get());
 		Assertions.assertEquals(420, Objects.requireNonNull(cache.get("4/20")).get());
 
+		// Test retrieve
+		Assertions.assertEquals(420, unwrapValue(Objects.requireNonNull(cache.retrieve("4/20")).join()));
+		CompletableFuture<?> missing = cache.retrieve("8/21");
+		Assertions.assertTrue(missing == null || missing.join() == null);
+		cache.put("5/11", null);
+		Object wrappedMissing = Objects.requireNonNull(cache.retrieve("5/11")).join();
+		Assertions.assertTrue(wrappedMissing instanceof Cache.ValueWrapper);
+		Assertions.assertNull(unwrapValue(wrappedMissing));
+		Assertions.assertNull(Objects.requireNonNull(cache.retrieve("5/11", () -> CompletableFuture.completedFuture(1605))).join());
+		Assertions.assertEquals(69, cache.retrieve("6/9", () -> CompletableFuture.supplyAsync(() -> 69)).join());
+		Assertions.assertEquals(69, cache.retrieve("6/9", () -> CompletableFuture.supplyAsync(() -> 70)).join());
+
 		// Test clear
 		cache.clear();
 		Assertions.assertNull(cache.get("4/20"));
@@ -139,4 +152,8 @@ public void valueLoaderConcurrentTest() throws InterruptedException {
 		Assertions.assertEquals(1, callCounter.get(), "Value loader should only be called once");
 	}
 
+	private static Object unwrapValue(Object value) {
+		return value instanceof Cache.ValueWrapper ? ((Cache.ValueWrapper) value).get() : value;
+	}
+
 }

spring/src/main/java/io/github/xanthic/cache/spring/XanthicSpringCache.java

@@ -54,11 +54,21 @@ public void put(@NotNull Object key, Object value) {
 		cache.put(key, toStoreValue(value));
 	}
 
+	@Override
+	public ValueWrapper putIfAbsent(@NotNull Object key, Object value) {
+		return toValueWrapper(cache.putIfAbsent(key, toStoreValue(value)));
+	}
+
 	@Override
 	public void evict(@NotNull Object key) {
 		cache.remove(key);
 	}
 
+	@Override
+	public boolean evictIfPresent(@NotNull Object key) {
+		return cache.remove(key) != null;
+	}
+
 	@Override
 	public void clear() {
 		cache.clear();