[CHORE] Simple caching

pom.xml

@@ -31,6 +31,16 @@
 			<artifactId>spring-data-commons</artifactId>
 			<version>3.3.0</version>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-cache</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>com.github.ben-manes.caffeine</groupId>
+			<artifactId>caffeine</artifactId>
+			<version>3.1.8</version>
+		</dependency>
 
 		<dependency>
 			<groupId>org.postgresql</groupId>

src/main/java/edu/harvard/dbmi/avillach/dictionary/DictionaryApplication.java

@@ -2,8 +2,10 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cache.annotation.EnableCaching;
 
 @SpringBootApplication
+@EnableCaching
 public class DictionaryApplication {
 
     public static void main(String[] args) {

src/main/java/edu/harvard/dbmi/avillach/dictionary/concept/ConceptService.java

@@ -6,6 +6,7 @@
 import edu.harvard.dbmi.avillach.dictionary.concept.model.ContinuousConcept;
 import edu.harvard.dbmi.avillach.dictionary.filter.Filter;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 
@@ -26,6 +27,7 @@ public ConceptService(ConceptRepository conceptRepository, ConceptDecoratorServi
         this.conceptDecoratorService = conceptDecoratorService;
     }
 
+    @Cacheable("concepts")
     public List<Concept> listConcepts(Filter filter, Pageable page) {
         return conceptRepository.getConcepts(filter, page);
     }
@@ -40,6 +42,7 @@ public List<Concept> listDetailedConcepts(Filter filter, Pageable page) {
         }).toList();
     }
 
+    @Cacheable("concepts_count")
     public long countConcepts(Filter filter) {
         return conceptRepository.countConcepts(filter);
     }

src/main/java/edu/harvard/dbmi/avillach/dictionary/facet/FacetService.java

@@ -2,6 +2,7 @@
 
 import edu.harvard.dbmi.avillach.dictionary.filter.Filter;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
@@ -17,6 +18,7 @@ public FacetService(FacetRepository repository) {
         this.repository = repository;
     }
 
+    @Cacheable("facets")
     public List<FacetCategory> getFacets(Filter filter) {
         return repository.getFacets(filter);
     }

src/main/java/edu/harvard/dbmi/avillach/dictionary/facet/FilterPreProcessor.java

@@ -10,6 +10,10 @@
 
 import java.io.IOException;
 import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Function;
 
 @ControllerAdvice
 public class FilterPreProcessor implements RequestBodyAdvice {
@@ -30,8 +34,23 @@ public Object afterBodyRead(
         Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType,
         Class<? extends HttpMessageConverter<?>> converterType
     ) {
-        if (body instanceof Filter filter && StringUtils.hasLength(filter.search())) {
-            return new Filter(filter.facets(), filter.search().replaceAll("_", "/"), filter.consents());
+        if (body instanceof Filter filter) {
+            List<Facet> newFacets = filter.facets();
+            List<String> newConsents = filter.consents();
+            if (filter.facets() != null) {
+                newFacets = new ArrayList<>(filter.facets());
+                newFacets.sort(Comparator.comparing(Facet::name));
+            }
+            if (filter.consents() != null) {
+                newConsents = new ArrayList<>(newConsents);
+                newConsents.sort(Comparator.comparing(Function.identity()));
+            }
+            filter = new Filter(newFacets, filter.search(), newConsents);
+
+            if (StringUtils.hasLength(filter.search())) {
+                filter = new Filter(filter.facets(), filter.search().replaceAll("_", "/"), filter.consents());
+            }
+            return filter;
         }
         return body;
     }

src/main/java/edu/harvard/dbmi/avillach/dictionary/util/CacheConfig.java

@@ -0,0 +1,24 @@
+package edu.harvard.dbmi.avillach.dictionary.util;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.caffeine.CaffeineCacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.concurrent.TimeUnit;
+
+@Configuration
+public class CacheConfig {
+    @Bean
+    public Caffeine caffeineConfig() {
+        return Caffeine.newBuilder().expireAfterAccess(15, TimeUnit.MINUTES).maximumSize(5000);
+    }
+
+    @Bean
+    public CacheManager cacheManager(Caffeine caffeine) {
+        CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
+        caffeineCacheManager.setCaffeine(caffeine);
+        return caffeineCacheManager;
+    }
+}

src/test/java/edu/harvard/dbmi/avillach/dictionary/concept/ConceptServiceTest.java

@@ -6,6 +6,7 @@
 import edu.harvard.dbmi.avillach.dictionary.concept.model.ContinuousConcept;
 import edu.harvard.dbmi.avillach.dictionary.filter.Filter;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -38,6 +39,8 @@ void shouldListConcepts() {
         Mockito.when(repository.getConcepts(filter, page)).thenReturn(expected);
 
         List<Concept> actual = subject.listConcepts(filter, page);
+        subject.listConcepts(filter, page);
+        Mockito.verify(repository, Mockito.times(1)).getConcepts(filter, page);
 
         Assertions.assertEquals(expected, actual);
     }
@@ -48,7 +51,9 @@ void shouldCountConcepts() {
         Mockito.when(repository.countConcepts(filter)).thenReturn(1L);
 
         long actual = subject.countConcepts(filter);
+        subject.countConcepts(filter);
 
+        Mockito.verify(repository, Mockito.times(1)).countConcepts(filter);
         Assertions.assertEquals(1L, actual);
     }
 

src/test/java/edu/harvard/dbmi/avillach/dictionary/facet/FacetServiceTest.java

@@ -4,6 +4,7 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
+import org.mockito.internal.verification.Times;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.mock.mockito.MockBean;
@@ -28,6 +29,8 @@ void shouldGetFacets() {
         Mockito.when(repository.getFacets(filter)).thenReturn(expected);
 
         List<FacetCategory> actual = subject.getFacets(filter);
+        subject.getFacets(filter);
+        Mockito.verify(repository, Mockito.times(1)).getFacets(filter);
 
         Assertions.assertEquals(expected, actual);
     }

src/test/java/edu/harvard/dbmi/avillach/dictionary/facet/FilterPreProcessorTest.java

@@ -18,6 +18,19 @@ class FilterPreProcessorTest {
     @Autowired
     private FilterPreProcessor subject;
 
+    @Test
+    void shouldSortFilter() {
+        Filter filter = new Filter(List.of(new Facet("b", ""), new Facet("a", "")), "", List.of("c", "b", "a"));
+        Filter actual = (Filter) subject.afterBodyRead(
+            filter, Mockito.mock(HttpInputMessage.class), Mockito.mock(MethodParameter.class), SimpleType.constructUnsafe(Filter.class),
+            null
+        );
+
+        Filter expected = new Filter(List.of(new Facet("a", ""), new Facet("b", "")), "", List.of("a", "b", "c"));
+        Assertions.assertEquals(expected, actual);
+
+    }
+
     @Test
     void shouldProcessFilter() {
         Object processedFilter = subject.afterBodyRead(