使用@Cacheable注释的真实DAO的最佳实践

Question

I'm new to Spring and I'm very excited about all the things it offers!

Right now, I'm trying to modernize a couple of DAOs in my existing project. Specifically, I want to replace my old plain JDBC code with Spring Jdbc support and introduce Spring's transparent caching.

1. First question: am I right that the DAO layer is the right place to add @Cacheable annotations? Or do you do it in the business layer?

2. I can follow all the simple examples to be found on the net. However, when it comes to more real world code, I get stuck:

Specifically, I have several methods that return instances of my model Publisher . In my manual cache implementations I always made sure only one instance is cached and fetched for the different getPublisher() methods. However, using @Cacheable and trying to encapsulate caching within the DAO, I have the problem, that the annotation doesn't work for local method calls (because of proxying).

Here's my sample code:

@Cacheable("publisherCache")
public Publisher getPublisher(int publisherId)
{
    String sql = "SELECT * FROM publisher LEFT JOIN publisherContacts USING (publisherId) WHERE publisherId=? ORDER BY publisherContactId ASC";
    return getJdbcTemplate().query(sql, publisherResultSetExtractor, publisherId);
}

public List<Publisher> findVisiblePublishers()
{
    List<Publisher> publishers = new LinkedList<Publisher>();
    for (int publisherId : findVisiblePublisherIds())
    {
        publishers.add(getPublisher(publisherId));
    }
    return publishers;
}

@Cacheable(value = "publisherCache", key = "'list'")
private List<Integer> findVisiblePublisherIds()
{
    String sql = "SELECT publisherId FROM publisher WHERE isVisible='yes' ORDER BY imprintName";
    return getJdbcTemplate().queryForList(sql, Integer.class);
}

public Publisher findNearestPublisher(String appx)
{
    appx = "%" + appx + "%";
    String sql = "SELECT publisherId FROM publisher WHERE publisherName LIKE ? OR imprintName LIKE ? ORDER BY imprintName DESC LIMIT 1";
    Integer publisherId = getJdbcTemplate().queryForObject(sql, Integer.class, appx, appx);
    if (publisherId == null)
        return null;
    else
        return getPublisher(publisherId);
}

This was my idea, which as said, doesn't work.

The only alternatives I can see right now are:

a) Only cache the getPublisher(publisherId) method and define all other methods that return Publisher s to return int s (publisherIds), or lists thereof. This doesn't feel natural from an API point of view. As a service or business logic, I would expect to get instances from the DAO, not only IDs.

b) Add @Cacheable to all methods, duplicating the cache and using more memory than needed (let's assume there are a lot of publishers and that they are heavy objects).

What is the best practice around this must-be-pretty-common problem? Thanks for any insights.

Answer 1

Common pattern is following: For persistence layer you use hibernate second-level cache. For service layer you use @Cacheable to cache things like long computations or web service call results.