Spring Boot 本地缓存工具类计划与实现

在 Spring Boot 应用中，缓存是提升性能的重要手段之一。为了更方便地利用缓存，我们可以计划一套通用的本地缓存工具类，封装常见的缓存操作，简化开发流程。本文将具体先容怎样计划并实现一套 Spring Boot 本地缓存工具类，并提供完整代码示例。

---

1. 工具类计划目标

在计划缓存工具类时，我们需要思量以下目标：

• 通用性：工具类应支持多种缓存操作，如获取、添加、更新、删除等。
  
• 易用性：通过简朴的 API 调用即可完成缓存操作，减少重复代码。
  
• 机动性：支持自界说缓存过期时间、缓存键生成战略等。
  
• 可扩展性：工具类应易于扩展，支持不同的缓存实现（如 Caffeine、Guava 等）。
  

---

2. 工具类实现

2.1 添加依赖

首先，在 pom.xml 中添加 Spring Boot 缓存支持的依赖：

1. <dependency>
2.     <groupId>org.springframework.boot</groupId>
3.     <artifactId>spring-boot-starter-cache</artifactId>
4. </dependency>
5. <dependency>
6.     <groupId>com.github.ben-manes.caffeine</groupId>
7.     <artifactId>caffeine</artifactId>
8. </dependency>

复制代码

2.2 启用缓存

在 Spring Boot 启动类上添加 @EnableCaching 注解，启用缓存功能：

1. @SpringBootApplication
2. @EnableCaching
3. public class MyApplication {
4.     public static void main(String[] args) {
5.         SpringApplication.run(MyApplication.class, args);
6.     }
7. }

复制代码

2.3 缓存工具类实现

以下是一个通用的本地缓存工具类实现，基于 Spring 的 CacheManager 和 Caffeine 缓存库：

1. package com.example.cache;
3. import org.springframework.cache.Cache;
4. import org.springframework.cache.CacheManager;
5. import org.springframework.stereotype.Component;
6. import org.springframework.util.StringUtils;
8. import javax.annotation.Resource;
9. import java.util.concurrent.Callable;
11. /**
12. * 本地缓存工具类
13. */
14. @Component
15. public class LocalCacheUtil {
17.     @Resource
18.     private CacheManager cacheManager;
20.     /**
21.      * 获取缓存值
22.      *
23.      * @param cacheName 缓存名称
24.      * @param key       缓存键
25.      * @return 缓存值
26.      */
27.     public <T> T get(String cacheName, Object key) {
28.         Cache cache = getCache(cacheName);
29.         if (cache != null) {
30.             Cache.ValueWrapper valueWrapper = cache.get(key);
31.             if (valueWrapper != null) {
32.                 return (T) valueWrapper.get();
33.             }
34.         }
35.         return null;
36.     }
38.     /**
39.      * 获取缓存值，如果不存在则通过 loader 加载
40.      *
41.      * @param cacheName 缓存名称
42.      * @param key       缓存键
43.      * @param loader    缓存加载器
44.      * @return 缓存值
45.      */
46.     public <T> T get(String cacheName, Object key, Callable<T> loader) {
47.         Cache cache = getCache(cacheName);
48.         if (cache != null) {
49.             return cache.get(key, loader);
50.         }
51.         return null;
52.     }
54.     /**
55.      * 添加缓存
56.      *
57.      * @param cacheName 缓存名称
58.      * @param key       缓存键
59.      * @param value     缓存值
60.      */
61.     public void put(String cacheName, Object key, Object value) {
62.         Cache cache = getCache(cacheName);
63.         if (cache != null) {
64.             cache.put(key, value);
65.         }
66.     }
68.     /**
69.      * 删除缓存
70.      *
71.      * @param cacheName 缓存名称
72.      * @param key       缓存键
73.      */
74.     public void evict(String cacheName, Object key) {
75.         Cache cache = getCache(cacheName);
76.         if (cache != null) {
77.             cache.evict(key);
78.         }
79.     }
81.     /**
82.      * 清空缓存
83.      *
84.      * @param cacheName 缓存名称
85.      */
86.     public void clear(String cacheName) {
87.         Cache cache = getCache(cacheName);
88.         if (cache != null) {
89.             cache.clear();
90.         }
91.     }
93.     /**
94.      * 获取缓存对象
95.      *
96.      * @param cacheName 缓存名称
97.      * @return 缓存对象
98.      */
99.     private Cache getCache(String cacheName) {
100.         if (!StringUtils.hasText(cacheName)) {
101.             throw new IllegalArgumentException("缓存名称不能为空");
102.         }
103.         return cacheManager.getCache(cacheName);
104.     }
105. }

复制代码

---

3. 工具类利用示例

3.1 设置缓存

在 application.yml 中设置 Caffeine 缓存：

1. spring:
2.   cache:
3.     type: caffeine
4.     caffeine:
5.       spec: maximumSize=1000,expireAfterWrite=10m

复制代码

3.2 利用工具类

在业务代码中，可以通过注入 LocalCacheUtil 来利用缓存工具类：

1. @Service
2. public class BookService {
4.     @Resource
5.     private LocalCacheUtil localCacheUtil;
7.     /**
8.      * 获取书籍信息
9.      */
10.     public Book getBookById(Long id) {
11.         // 先从缓存中获取
12.         Book book = localCacheUtil.get("books", id);
13.         if (book == null) {
14.             // 如果缓存中不存在，则从数据库加载
15.             book = loadBookFromDatabase(id);
16.             // 将结果放入缓存
17.             localCacheUtil.put("books", id, book);
18.         }
19.         return book;
20.     }
22.     /**
23.      * 更新书籍信息
24.      */
25.     public void updateBook(Book book) {
26.         // 更新数据库
27.         updateBookInDatabase(book);
28.         // 更新缓存
29.         localCacheUtil.put("books", book.getId(), book);
30.     }
32.     /**
33.      * 删除书籍信息
34.      */
35.     public void deleteBookById(Long id) {
36.         // 删除数据库记录
37.         deleteBookFromDatabase(id);
38.         // 删除缓存
39.         localCacheUtil.evict("books", id);
40.     }
42.     // 模拟从数据库加载书籍信息
43.     private Book loadBookFromDatabase(Long id) {
44.         // 这里模拟数据库查询
45.         return new Book(id, "Spring Boot Guide", "Author Name");
46.     }
48.     // 模拟更新数据库
49.     private void updateBookInDatabase(Book book) {
50.         // 这里模拟数据库更新
51.     }
53.     // 模拟删除数据库记录
54.     private void deleteBookFromDatabase(Long id) {
55.         // 这里模拟数据库删除
56.     }
57. }

复制代码

---

4. 工具类的优势

• 简化缓存操作：通过工具类封装，业务代码中只需调用简朴的方法即可完成缓存操作。
  
• 统一管理缓存：全部缓存操作都通过工具类进行，便于维护和扩展。
  
• 支持多种缓存战略：可以通过设置机动调整缓存过期时间、最大容量等参数。
  
• 易于扩展：如果需要切换缓存实现（如从 Caffeine 切换到 Ehcache），只需修改设置，无需改动业务代码。
  

---

5. 总结

本文计划并实现了一套 Spring Boot 本地缓存工具类，通过封装 Spring 的 CacheManager 和 Caffeine 缓存库，提供了简朴易用的缓存操作 API。该工具类可以显著简化缓存的利用，提升开发服从，同时具备良好的扩展性和机动性。希望本文能帮助你更好地理解和利用 Spring Boot 中的本地缓存功能。
如果你有任何题目或建议，接待在批评区留言讨论！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。