Spring Cache 下对分页请求的正确缓存方式

前言

　　在 spring boot 应用程式开发的时候，在对 service 层加入缓存支持的过程中，遇到了处理分页缓存的难题，在摸索了多个解决方式后，找到了比较适合，特此记录

问题描述

　　在程序中存在 User与 Note 实体。假设用户此时需要从服务器获得 Note 数据，在大部分情况下，用户不需要一次性获取所有的 Note 数据，我们会使用 Page 来减少带宽压力的，同时使用缓存来减少对数据库的访问。

　　在缓存流程中，在对数据进行查找时候，需要先查找缓存中是否存在相应 key 的数据，如果没有，则触发一次数据库访问并把查询到的结果存入缓存中，这在 Spring Boot 中以注解的方式很容易实现，我们可以这样子使用： 

    @Transactional(readOnly = true)
    @Cacheable(
            key = "'user_'+#user.id+':'+#pageable.pageSize+'_'+#pageable.pageNumber",
            condition = "#user!=null && #pageable!=null",
            unless = "#result==null",
            cacheNames = "note"
           )
    @Nonnull
    @Override
    public Page<Note> findAllByUserAndPageable(@Nonnull User user, @Nonnull Pageable pageable) throws IllegalArgumentException {

　　但是当用户对其中一个 Note 进行更改时，缓存的更新就成了一大难题，试想有一个方法如下:

    @Nonnull
    @Override
    public Note addOne(@Nonnull Note toAdd) throws IllegalArgumentException {...

　　我们新增了一个 Note，现在程序需要清除与之有关联的缓存数据，比如 分页，Spring Cache 提供了 @CacheEvict ，现在我们使用它来清除缓存，很自然的，对应产生缓存的方式，我们在 @CacheEvict 的数据中加入 key = "'user_'+#user.id+':'#pageable.pageSize+'_'+#pageable.pageNumber"。很不幸，这是个错误的使用方式，在这里，我们获取不到 pageable 对象。

　　@CacheEvict 里边有个 allEntries 选项，把它设置为 true 清空 当前 cacheNames 下的所有缓存如何？同样的，这不是一个好的处理方式。如果这么做了，当前缓存中的所有 缓存，包括那些没有被修改的数据，比如单个的 Note 缓存同样被删的一干二净。但是，其中的涉及小细节给了我们一些 hint。

解决思路

　　在上面的问题中，我们发现使用 allEntries 并不适用，它会导致缓存 cacheNames 下的所有数据被清空，请注意是指定的 cacheNames 下的所有数据，那么我们是否可以将分页数据单独放入对应 User 的 cacheName 下，当发生缓存更改时，直接删除只包含分页缓存的 cacheName 下的缓存？ 比如 cacheNames="#principle.username" ?

　　如果通读过 Spring-doc 的 Cache 章节，会发现，cacheNames 属性并不支持 SpEL 表达式，所以以上的设置并不行得通。似乎山穷水尽，其实不然。仔细观察 @Cache... 的通用属性，会发现 cacheResolver 的注释是这样的。

The bean name of the custom {@link org.springframework.cache.interceptor.CacheResolver} to use.

　　可以使用 bean ，至少有一丝曙光，点进去 CacheResolver，他只规定了一个方法 resolveCaches，查看它的 Hierarchy 视图，所幸类试图并不复杂，

　　让我们查看 CacheResolverAdapter 的源码与注释。

Spring's {@link CacheResolver} implementation that delegates to a standard
JSR-107 {@link javax.cache.annotation.CacheResolver}.
Used internally to invoke user-based JSR-107 cache resolvers.

　　使用JCacheCache 的 JCache (JSR-107)实现， pass

　　查看 AbstractCacheResolver 的源码与注释。

A base {@link CacheResolver} implementation that requires the concrete
implementation to provide the collection of cache name(s) based on the
invocation context.

 　　很幸运，我们很快发现了候选。但是我们需要参考 spring 的默认实现 SimpleCacheResolver。

A simple {@link CacheResolver} that resolves the {@link Cache} instance(s)
based on a configurable {@link CacheManager} and the name of the
cache(s) as provided by {@link BasicOperation#getCacheNames() getCacheNames()}.

解决进行

　　让我们针对 cache names 细节做一些具体实现：继承这个类，更改 getCacheNames 方法，然后我们就得到了一个具体的实现

    /**
     * dynamic generates cache name: findAllByUserAndPageable_${userId}
     * <br>
     * use for page&lt;Note&gt; with annotation{@link org.springframework.cache.annotation.CacheEvict}, {@link org.springframework.cache.annotation.Cacheable}
     */
    public static class DynamicNotePageCacheNames extends SimpleCacheResolver implements CacheResolver {
        private final AuthenticationHelper authenticationHelper;
        public static final String FIND_ALL_BY_USER_AND_PAGEABLE = "findAllByUserAndPageable";

        public DynamicNotePageCacheNames(CacheManager cacheManager, AuthenticationHelper authenticationHelper) {
            super(cacheManager);
            log.debug(String.format("using customize CacheResolver: %s , cacheManager: %s",
                    this.getClass().getName(), cacheManager.getClass().getName()));
            this.authenticationHelper = authenticationHelper;
        }

        @Override
        protected Collection<String> getCacheNames(CacheOperationInvocationContext<?> context) {

            Long uId = authenticationHelper.checkAndExtractUserFromAuthentication().getId();
            String cacheName = String.format("%s_%d", FIND_ALL_BY_USER_AND_PAGEABLE, uId);
            log.debug(String.format("generate cache name %s for target %s", cacheName, context.getTarget()));
            return Collections.singleton((String.format("%s_%d", FIND_ALL_BY_USER_AND_PAGEABLE, uId)));
        }
    }

　　这里我从 Security 中获取到当前的登录用户的 id，将 id 与 方法字符串拼接起来作为 cachename 返回。需要注意的是 在方法体中我并没有对 uId 进行空检查是因为在调用 checkAndExtractUserFromAuthentication 方法 尝试获取 user 的时候，如果当前 Authentication 中只存在匿名用户的时候，方法会抛出  AccessDeniedException 错误，直接导致了 403 返回，具体可参考章节附。

　　让我们使用这个bean,实例化并且改写 service 层

    @Bean("dynamicNotePageCacheNames")
    public DynamicNotePageCacheNames cacheResolver() {
        return new DynamicNotePageCacheNames(cacheManager, authenticationHelper);
    }

　　@Cacheable的使用：

    @Transactional(readOnly = true)
    @Cacheable(
            key = "#pageable.pageSize+'_'+#pageable.pageNumber",
            condition = "#user!=null && #pageable!=null",
            unless = "#result==null",
           cacheResolver = "dynamicNotePageCacheNames"
    )
    @Nonnull
    @Override
    public Page<Note> findAllByUserAndPageable(@Nonnull User user, @Nonnull Pageable pageable) throws IllegalArgumentException {

　　@CacheEvict的使用：

    @Transactional(rollbackFor = EntityExistsException.class)
    @Caching(
            evict = {
                    @CacheEvict(
                            condition = "#toAdd!=null ",
                            cacheResolver = "dynamicNotePageCacheNames", allEntries = true),
              
            },
            put = @CachePut(key = "'id_'+#result.id",
                    condition = "#toAdd!=null",
                    unless = "#result==null", cacheNames = CustomCacheConfig.NOTE)
    )
    @Nonnull
    @Override
    public Note addOne(@Nonnull Note toAdd) throws IllegalArgumentException {

　　需要注意的是，类上的注解 @CacheConfig 会覆盖方法中的设置，参考

附

AuthenticationHelper：

/**
 *
 *
 * @author pancc
 * @version 1.0
 */
@Component
public class AuthenticationHelper {
    private final UserService userService;

    public AuthenticationHelper(UserService userService) {
        this.userService = userService;
    }

    /**
     * extract User From Authentication at current request, at this case it refers to a {@link UsernamePasswordAuthenticationToken}<br>
     * <br>
     * <code>anonymousUser</code> filter out anonymous user set by spring security web
     *
     * @param authentication if null, will get from current request
     * @return optional with current user  or empty
     * @see JWTAuthenticationFilter
     * @see TokenAuthenticationProcessor#getAuthentication(String)
     * @see AnonymousAuthenticationFilter#AnonymousAuthenticationFilter(java.lang.String)
     */
    private Optional<User> extractUserOptionalFromAuthentication(Authentication authentication) {
        final String anonymous = "anonymousUser";
        if (authentication == null) {
            authentication = SecurityContextHolder.getContext().getAuthentication();
        }
        if (authentication == null || !authentication.isAuthenticated()) {
            return Optional.empty();
        }
        if ((authentication.getPrincipal().getClass().equals(String.class))) {
            String username = (String) authentication.getPrincipal();
            if (username == null || username.contentEquals(anonymous)) {
                return Optional.empty();
            }
            return userService.findByUsername(username);
        }
        return Optional.empty();
    }

    /**
     * extract User From Authentication at current request, at this case it refers to a {@link UsernamePasswordAuthenticationToken}<br>
     *
     * @return optional with current user  or empty
     * @see JWTAuthenticationFilter
     * @see TokenAuthenticationProcessor#getAuthentication(String)
     */
    public Optional<User> extractUserOptionalFromAuthentication() {
        return this.extractUserOptionalFromAuthentication(null);
    }

    /**
     * extract User From Authentication, at this case it points to a {@link UsernamePasswordAuthenticationToken}<br>
     * this method may throw {@link AccessDeniedException} if not caught, resulting in server response 403 code
     * <br>
     * <b>required login</b>
     *
     * @param authentication {@link UsernamePasswordAuthenticationToken}
     * @return current user or throw AccessDeniedException that means 403 Http-code
     * @throws AccessDeniedException if current Authentication contains bad Credentials
     * @see ExceptionResolver.AccessDeniedAdvice
     * @see JWTAuthenticationFilter
     * @see TokenAuthenticationProcessor#getAuthentication(String)
     */
    public User checkAndExtractUserFromAuthentication(Authentication authentication) throws AccessDeniedException {
        return this.extractUserOptionalFromAuthentication(authentication).orElseThrow(() -> new AccessDeniedException("Access Denied"));
    }

    /**
     * extract User From Authentication at current request, at this case it refers to a {@link UsernamePasswordAuthenticationToken}<br>
     * this method may throw {@link AccessDeniedException} if not caught, resulting in server response 403 code
     * <br>
     * <b>required login</b>
     *
     * @return current user or throw AccessDeniedException that means 403 Http-code
     * @throws AccessDeniedException if current Authentication contains bad Credentials
     * @see ExceptionResolver.AccessDeniedAdvice
     * @see JWTAuthenticationFilter
     * @see TokenAuthenticationProcessor#getAuthentication(String)
     */
    public User checkAndExtractUserFromAuthentication() throws AccessDeniedException {
        return this.extractUserOptionalFromAuthentication(null).orElseThrow(() -> new AccessDeniedException("Access Denied"));
    }

}