Search for a command to run...
Or "why does the Spring magic stopped working?"
I'm a developer from France, I mainly do backend dev and DevOps on micro-service environments.
I also give formations about Spring Framework and other subjects.
Currently working at Zenika Bordeaux and not changing anytime soon :D
Hi David! You answered the doubts in this blog. Thanks for it. But when I tried solution you have provided, it throws error like:
Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'githubLookUpService': Requested bean is currently in creation: Is there an unresolvable circular reference?
It must be green ok? — Ruby Rhod
Hi! This is my first post on a series of quick tips to improve your tests in Java, I hope you will learn something today 👍 Have you ever used Instant.now(), LocalDateTime.now() or ZonedDateTime.now() in your code, only to find it difficult to test l...
I want to share with you a common mistake I find in codebases using Spring when it comes to features auto-magically added by annotations.
Let's start with this piece of code :
@Service
public class MyLibrary {
BookRepository bookRepository;
@Cacheable("books")
public Collection<Book> fetchAllBooks() {
// Do some resources intensive request here
return bookRepository.fetchAllBooks();
}
}
Pretty straightforward: in our bean MyLibrary, the method fetchAllBooks() fetches some books and the annotation @Cacheable from Spring Cache enables some caching of the result to avoid doing the query at every call. So far so good.
What if I add another method :
@Service
public class MyLibrary {
BookRepository bookRepository;
public void createBook(Book Book) {
// Let's pretend we need the collection of existing books :
Collection<Book> existingCollection = this.fetchAllBooks();
// do something with the new book and the collection
}
@Cacheable("books")
public Collection<Book> fetchAllBooks() {
// Do some resources intensive request here
return bookRepository.fetchAllBooks();
}
}
Here the method createBook() needs to fetch some books too (bear with me for the sake of the example), so it makes sense to call the one already there, right? We expect the method createBook() to get the collection of existing books from the cache.
Unfortunately, it won't work as expected: the cache will never be used, and here is why.
All the nice features of Spring enabled by those annotations are implemented using proxies (and a lot of AOP). As you may know, when you inject the MyLibrary bean, you don't get exactly the instance of the MyLibrary class, instead, you get a proxy.
To implement the caching mechanism around the method fetchAllBooks(), Spring creates a proxy that will do the caching for you, and only call your method fetchAllBooks() if there is nothing in the cache. All your public methods are in fact proxied, even if no extra behavior is implemented.
public class ProxyOfMyLibrary {
// The class name would be 'MyLibrary$$SpringCGLIB$$0' in reality
// A reference to your original MyLibrary class
MyLibrary target;
public void createBook(Book Book) {
// Your code is called here
target.createBook(Book);
}
public Collection<Book> fetchAllBooks() {
// fetch an existing value in cache
// if found, return it
// else, call target.fetchAllBooks() (i.e. your code)
// then store the result in cache
// and return it
}
}
This is of course simplified but the important info is this:
ProxyOfMyLibrary.createBook() will call the real MyLibrary.createBook() that you wrote, and your method calls MyLibrary.fetchAllBooks(), not ProxyOfMyLibrary.fetchAllBooks() in which the caching mechanism is.
I often see this with @Cacheable but keep in mind that this would apply to any other annotation that adds behavior to your code like @Transactional,@RolesAllowed or @Secured, to name a few.
The simple solution would be to put the annotation @Cacheable on another bean, the BookRepository in my example.
Another solution is to inject the bean into itself: you will get a pointer to the proxy, on which you call the method.
@Service
public class MyLibrary implements ApplicationContextAware {
MyLibrary self;
BookRepository bookRepository;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.self = applicationContext.getBean(MyLibrary.class);
}
public void createBook(Book Book) {
// Note that we don't use 'this' but 'self' here
Collection<Book> existingCollection = self.fetchAllBooks();
}
@Cacheable("books")
public Collection<Book> fetchAllBooks() {
return bookRepository.fetchAllBooks();
}
}
However, I would advise against doing this if you can avoid it, as it clutters your code and is a smell of a class trying to do too much.
I hope this can explain why, sometimes, Spring's magic doesn't seem to work.
Let me know if this helped you avoid a headache!