Strange behaviour when integrate Spring JPA Data and Spring Cache - spring

Question

When I integrate Spring JPA Data and Spring Cache, there is a strange behaviour I can't explain.
I am using Spring Boot to setup my demo project. The code is below.
My config bean:
#Configuration
public class AppConfig {
#Bean
public CacheManager cacheManager() {
return new ConcurrentMapCacheManager("Person");
}
}
My entity bean.
#Entity
public class Person implements Serializable {
private static final long serialVersionUID = 2263555241909370718L;
#Id
#GeneratedValue
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
My JPA interface. I overwrite some methods from JpaRepository and add #cachable annotation.
public interface PersonRepository extends JpaRepository<Person, Long> {
#Override
#CacheEvict(value = "Person", allEntries = true)
public void delete(Long id);
#Cacheable("Person")
public Person findByName(String name);
#Override
#Query("select p from Person p where p.id = :id + 1L")
#Cacheable("Person")
public Person findOne(#Param("id") Long id);
}
My unit test class
#RunWith(SpringJUnit4ClassRunner.class)
#SpringApplicationConfiguration(classes = SpringDataDemoApplication.class)
public class SpringDataDemoApplicationTests {
#Autowired
private PersonRepository personRepository;
#Autowired
private CacheManager cacheManager;
#Before
public void setup() {
Person p1 = new Person();
p1.setName("Chris");
personRepository.save(p1);
}
#Test
public void test2() {
JpaRepository<Person, Long> jpaRepository = personRepository;
Person p = personRepository.findOne(0L);
Assert.assertNotNull(p);
p = personRepository.findOne(0L);
Assert.assertNotNull(p);
System.err.println("---------------------------------------");
p = jpaRepository.findOne(0L);
Assert.assertNotNull(p);
p = jpaRepository.findOne(0L);
Assert.assertNotNull(p);
}
}
The output is very strange.
Hibernate: insert into person (id, name) values (default, ?)
Hibernate: select person0_.id as id1_0_, person0_.name as name2_0_ from person person0_ where person0_.id=?+1
---------------------------------------
Hibernate: select person0_.id as id1_0_, person0_.name as name2_0_ from person person0_ where person0_.id=?+1
Hibernate: select person0_.id as id1_0_, person0_.name as name2_0_ from person person0_ where person0_.id=?+1
It should only print out one sql statement for my expect. The jpaRepository.findOne(0L) doesn't use the cache object.
The cache annotation is not working after I assign the PersonRepository interface to its parent interface, JpaRepository.
These 2 variables are exactly point to the same reference, even it a proxy object. Why call the same reference's method causing 2 difference result?
I also notice that the #Query annotation is working well. Both the JpaRepository and PersonRepository references use the customized SQL.
I guess there maybe some differences between how Spring Cache and Spring JPA Data generate the proxy advisor. Is that possible a bug here?

Answer 1

Add #EnableCaching to your configuration:
#EnableCaching
#Configuration
public class AppConfig {
#Bean
public CacheManager cacheManager() {
return new ConcurrentMapCacheManager("Person");
}
}
Declaring the cache annotations does not automatically trigger their actions per se, you should declaratively enable the Caching behavior by using EnableCaching annotation. One of the advantages of this approach is you can disable it by removing only one configuration line rather than all the annotations in your code.

Answer 2

I think I find the reason why this happened. I add some aop code to track what method be called in the repository.
#Aspect
#Configuration
public class AppConfig {
#Bean
public CacheManager cacheManager() {
return new ConcurrentMapCacheManager();
}
#AfterReturning("execution(* org..*Repository.*(..))")
public void logServiceAccess(JoinPoint joinPoint) {
Arrays.asList(joinPoint.getTarget().getClass().getMethods()) //
.stream() //
.filter(m -> m.getName().startsWith("findOne")) //
.forEach(m -> System.err.println(m));
System.err.println("Completed: " + joinPoint);
}
}
The output is
public final java.lang.Object com.sun.proxy.$Proxy66.findOne(java.io.Serializable)
public final org.chris.demo.domain.Person com.sun.proxy.$Proxy66.findOne(java.lang.Long)
Spring container proxy 2 findOne methods with different arguments. I think that caused by generic code as all generic code will be removed after compile.
When I use the parent interface call the method, it call the public final java.lang.Object com.sun.proxy.$Proxy66.findOne(java.io.Serializable)
method. And on that method, there is not way to add #cacheable annotation.
I don't know whether there is way to focus Spring container generate only one findOne method when there is a sub-interface overwrite the method by generic programming.