refactor: fix reactive anti-pattern and cache key in CachedSitemapGetter (#47)

Replace Guava Cache with Caffeine AsyncCache to eliminate the blocking
.block() call inside a reactive pipeline, which can cause thread starvation
on bounded schedulers.

Use options.getSiteUrl().toString() as the cache key instead of the
SitemapGeneratorOptions object itself. java.net.URL.equals() performs DNS
resolution on every comparison, making it unsuitable as a map/cache key.

Made-with: Cursor

Author: ruibaby

src/main/java/run/halo/sitemap/CachedSitemapGetter.java

@@ -1,39 +1,33 @@
 package run.halo.sitemap;
 
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
+import com.github.benmanes.caffeine.cache.AsyncCache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import java.time.Duration;
 import lombok.AllArgsConstructor;
-import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Mono;
-import reactor.core.scheduler.Schedulers;
 
 @Component
 @AllArgsConstructor
 public class CachedSitemapGetter {
 
-    private final Cache<SitemapGeneratorOptions, String> cache = CacheBuilder.newBuilder()
-        .concurrencyLevel(Runtime.getRuntime().availableProcessors())
-        .initialCapacity(8)
-        .maximumSize(8)
+    private final AsyncCache<String, String> cache = Caffeine.newBuilder()
         .expireAfterWrite(Duration.ofSeconds(30))
-        .build();
+        .maximumSize(8)
+        .buildAsync();
 
     private final DefaultSitemapEntryLister lister;
 
     public Mono<String> get(SitemapGeneratorOptions options) {
-        return Mono.fromCallable(() -> cache.get(options, () -> lister.list(options)
-                .collectList()
-                .map(entries -> {
-                    String xml = new SitemapBuilder()
-                        .buildSitemapXml(entries);
-                    cache.put(options, xml);
-                    return xml;
-                })
-                .defaultIfEmpty(StringUtils.EMPTY)
-                .block()
-            ))
-            .subscribeOn(Schedulers.boundedElastic());
+        String key = options.getSiteUrl().toString();
+        return Mono.fromFuture(() ->
+            cache.get(key, (k, executor) ->
+                lister.list(options)
+                    .collectList()
+                    .map(entries -> new SitemapBuilder().buildSitemapXml(entries))
+                    .defaultIfEmpty("")
+                    .toFuture()
+            )
+        );
     }
 }

src/test/java/run/halo/sitemap/CachedSitemapGetterTest.java

@@ -1,10 +1,12 @@
 package run.halo.sitemap;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import java.net.MalformedURLException;
+import java.net.URL;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;
@@ -22,33 +24,33 @@ public class CachedSitemapGetterTest {
     @Mock
     private DefaultSitemapEntryLister lister;
     private CachedSitemapGetter getter;
+    private SitemapGeneratorOptions options;
 
     @BeforeEach
-    void setUp() {
+    void setUp() throws MalformedURLException {
         when(lister.list(any())).thenReturn(
             Flux.just(SitemapEntry.builder().loc("http://localhost:8090/about").build()));
         getter = new CachedSitemapGetter(lister);
+        options = SitemapGeneratorOptions.builder()
+            .siteUrl(new URL("http://localhost:8090"))
+            .build();
     }
 
     @Test
     void get() throws InterruptedException, ExecutionException {
-        var options = mock(SitemapGeneratorOptions.class);
-
         getter.get(options).block();
-        verify(lister).list(options);
+        verify(lister).list(any());
 
         var executorService = Executors.newCachedThreadPool();
 
         List<? extends Future<?>> futures = IntStream.range(0, 10)
-            .mapToObj(i -> executorService.submit(() -> {
-                getter.get(options).block();
-            }))
+            .mapToObj(i -> executorService.submit(() -> getter.get(options).block()))
             .toList();
 
         for (Future<?> future : futures) {
             future.get();
         }
 
-        verify(lister).list(options);
+        verify(lister, times(1)).list(any());
     }
 }