public class CustomerCacheEventListener implements CacheEventListener {
    @Override
    public void notifyElementRemoved(Ehcache ehcache, Element element) throws CacheException {
        log.info("cache removed. key = {}, value = {}", element.getObjectKey(), element.getObjectValue());
    }

    @Override
    public void notifyElementPut(Ehcache ehcache, Element element) throws CacheException {
        log.info("cache put. key = {}, value = {}", element.getObjectKey(), element.getObjectValue());
    }

    @Override
    public void notifyElementUpdated(Ehcache ehcache, Element element) throws CacheException {
        log.info("cache updated. key = {}, value = {}", element.getObjectKey(), element.getObjectValue());
    }

    @Override
    public void notifyElementExpired(Ehcache ehcache, Element element) {
        log.info("cache expired. key = {}, value = {}", element.getObjectKey(), element.getObjectValue());
    }

    @Override
    public void notifyElementEvicted(Ehcache ehcache, Element element) {
        log.info("cache evicted. key = {}, value = {}", element.getObjectKey(), element.getObjectValue());
    }

    @Override
    public void notifyRemoveAll(Ehcache ehcache) {
        log.info("all elements removed. cache name = {}", ehcache.getName());
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

    @Override
    public void dispose() {
        log.info("cache dispose.");
    }
}

public class CustomerCacheEventListenerFactory extends CacheEventListenerFactory {
    @Override
    public CacheEventListener createCacheEventListener(Properties properties) {
        return new CustomerCacheEventListener();
    }
}

public class EhCache3EventLogger implements CacheEventListener {
    @Override
    public void onEvent(CacheEvent cacheEvent) {
        log.info("\nEvent: {} \nKey: {} \noldValue: {} \nnewValue: {}", cacheEvent.getType(), cacheEvent.getKey(), cacheEvent.getOldValue(), cacheEvent.getNewValue());
    }
}

@Cacheable(USERS_ALL_CACHE)
public List<User> findAllUsers() {

@Cacheable(value = USER_BY_ID_CACHE, key = "#id")
@Transactional(readOnly = true)
public User getUserById(long id) {

@Cacheable(key = "'id:' + #id")
@Transactional(readOnly = true)
public User getUser(long id) {

@CacheEvict(value="shops:detail",key="'id:'+#p0['id']",condition="#p0['id']>0")
public Shop getById(Map<String, Object> param);

@CachePut(value="shops:detail",key="'id:'+#p0['id']")
public Shop update(Map<String, Object> param);

@Caching(put = {
        @CachePut(cacheNames = USER_BY_ID_CACHE, key = "#user.id"),
        @CachePut(cacheNames = USER_BY_LOGIN_CACHE, key = "#user.username")},
        evict = {@CacheEvict(cacheNames = USERS_ALL_CACHE, allEntries = true)})
public User createOrUpdateUser(User user) {

cacheManager.getCache(USER_BY_ID_CACHE).evict(user.getId());
cacheManager.getCache(USER_BY_LOGIN_CACHE).evict(user.getUsername());
cacheManager.getCache(USERS_ALL_CACHE).clear();

ConcurrentMapCache concurrentMapCache = (ConcurrentMapCache) cacheManager.getCache(USERS_ALL_CACHE);
System.out.println("cacheManager.getCache(USERS_ALL_CACHE) = " + cacheManager.getCache(USERS_ALL_CACHE));
System.out.println("concurrentMapCache.getNativeCache() = " + concurrentMapCache.getNativeCache());

@Service
public class UserService {

    // 基本的三个 cache：所有对象集合缓存、byId、ByKey
    private static final String USERS_ALL_CACHE = "users";
    private static final String USER_BY_ID_CACHE = "userById";
    private static final String USER_BY_LOGIN_CACHE = "userByLogin";

    private final UserMapper userMapper;
    private final CacheManager cacheManager;

    public UserService(UserMapper userMapper, CacheManager cacheManager) {
        this.userMapper = userMapper;
        this.cacheManager = cacheManager;
    }

    @Cacheable(USERS_ALL_CACHE)
    @Transactional(readOnly = true)
    public List<User> getAll() {
        return userMapper.selectAll();
    }
}

@Test
public void findAll() {
    Cache cache = cacheManager.getCache(USERS_ALL_CACHE);
    assertThat(cache, notNullValue());
    cache.clear();

    List<User> users = userService.findAll();

    assertThat(Objects.requireNonNull(cache.get(SimpleKey.EMPTY)).get(), equalTo(users));
}

// 查询所有，存入 cache: users
@Cacheable(USERS_ALL_CACHE)
@Transactional(readOnly = true)
public List<User> getAll() {
    return userMapper.selectAll();
}

// 新增保存，更新 byId 和 byUsername 的两个 cache，清空 users cache
@Caching(put = {
        @CachePut(cacheNames = USER_BY_ID_CACHE, key = "#user.id"),
        @CachePut(cacheNames = USER_BY_LOGIN_CACHE, key = "#user.username")},
        evict = {@CacheEvict(cacheNames = USERS_ALL_CACHE, allEntries = true)})
public User save(User user) {
    userMapper.insert(user);
    return user;
}

// 更新保存，同上
@Caching(put = {
        @CachePut(cacheNames = USER_BY_ID_CACHE, key = "#user.id"),
        @CachePut(cacheNames = USER_BY_LOGIN_CACHE, key = "#user.username")},
        evict = {@CacheEvict(cacheNames = USERS_ALL_CACHE, allEntries = true)})
public User update(User user) {
    userMapper.updateByPrimaryKey(user);
    return user;
}

// 根据 id 删除对象，手动调用 CacheManager 清空相关所有 cache，就是上面说的方法参数里面没有用来清空的 key 参数场景
public void delete(Long id) {
    User user = userMapper.selectByPrimaryKey(id);
    if (user == null) {
        return;
    }
    userMapper.deleteByPrimaryKey(user);
    cacheManager.getCache(USER_BY_ID_CACHE).evict(user.getId());
    cacheManager.getCache(USER_BY_LOGIN_CACHE).evict(user.getUsername());
    cacheManager.getCache(USERS_ALL_CACHE).clear();
}

// 根据 user id 查询对象，存入 userById cache
@Cacheable(value = USER_BY_ID_CACHE, key = "#id")
@Transactional(readOnly = true)
public User getOne(Long id) {
    return userMapper.selectByPrimaryKey(id);
}

// 根据 user username，存入 userByLogin
@Cacheable(cacheNames = USER_BY_LOGIN_CACHE, key = "#username")
@Transactional(readOnly = true)
public User getByUsername(String username) {
    return userMapper.selectByUsername(username);
}

...
@PostMapping("/users")
public void save(@RequestBody User user) {
    if (userService.getByUsername(user.getUsername()) != null) {
        throw new RuntimeException("exist");
    }
    userService.save(user);
}
...

public void purgeAllCaches() {
    logger.info("CacheClearTask.purgeAllCaches");
    cacheManager.getCacheNames().parallelStream().forEach(
            name -> Objects.requireNonNull(cacheManager.getCache(name)).clear());
}

@Component
public class CacheManagerCheck implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(CacheManagerCheck.class);

    private final CacheManager cacheManager;

    public CacheManagerCheck(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }

    @Override
    public void run(String... strings) throws Exception {
        logger.info("\n\n" + "=========================================================\n"
                + "Using cache manager: " + this.cacheManager.getClass().getName() + "\n"
                + "=========================================================\n\n");
    }
}