获取对象的key_玩转 SpringBoot2.x 之缓存对象

作者 | 桌前明月

来源 | CSDN博客

头图 | 付费下载自视觉中国

出品 | CSDN(ID:CSDNnews)

前言

提到Redis 大部分的人首先想到的可能就是缓存，那么在 Java 项目中如何把对象缓存起来呢？这就是本文接下来要介绍的内容：缓存对象。本文通过SpringBoot 项目带你快速了解通过Jedis 把对象缓存到Redis中。

阅读本文需要你了解如何搭建 SpringBoot 项目即可，另外需要了解的是本文SpringBoot 版本是 2.1.0.RELEASE。关于SpringBoot 集成 Jedis 请参考：玩转 SpringBoot 2.x 之快速集成 Jedis客户端(普通版)

接下来就让我们开始具体的代码案例介绍吧！

代码案例

演示通过将下面的 User 类创建的对象缓存到 Redis 中，具体有2种方式：序列化、Json。User 类具体代码如下：

 1public class User implements Serializable {
2
3 private String name;
4 private Integer age;
5
6 public User(String name,Integer age){
7 this.name = name;
8 this.age = age;
9 }
10 //省略 getter and setter 方法
11}

关于过期时间处理和返回Jedis 线程操作到线程池操作封装到了 JedisCacheServiceSupport 中，具体代码如下：

 1public abstract class JedisCacheServiceSupport {
2 public static final long EXPIRE_MILLISECONDS_DEFAULT_LONG = 3*60*60*1000;
3
4 public Long getExpireTime(Long expireTime) {
5 expireTime = (expireTime == || expireTime.longValue <= 0) ? EXPIRE_MILLISECONDS_DEFAULT_LONG : expireTime;
6 return expireTime;
7 }
8
9 public void close(Jedis jedis){
10 if(jedis != ){
11 jedis.close;
12 }
13 }
14}

序列化方式

序列化的方式通过现将对象转换成二进制的流(序列化)后保存到 Redis 中，然后通过key 获取到二进制，在把二进制流转换成对象(反序列化)。

保存对象的具体操作如下：

通过 ObjectOutputStream.writeObject(object) 将User 对象转换成byte 数组，然后通过 psetex(byte[] key, long milliseconds, byte[] value) 将 byte 数组存入Redis中。其中

byte key：需要将key 转换成byte数组。
long milliseconds：是对象在Redis 中存活的时间，以毫秒为单位。
byte value：对象转换成的btye 数组。

获取对象的具体操作如下：

通过 get(byte[] key) 获取 User 对象转换的byte 数组，然后通过 ObjectInputStream.readObject 将数组转换成User对象。

通过序列化方式保存和获取对象具体代码如下：

 1@Service
2public class JedisCacheService extends JedisCacheServiceSupport {
3
4 private static Logger logger = LoggerFactory.getLogger(JedisCacheService.class);
5
6
7
8 @Autowired
9 private JedisPool jedisPool;
10
11 /**
12 * 获取缓存中的对象
13 * @param key
14 * @return
15 */
16 public Object getObject(String key) {
17 Jedis jedis = ;
18 Object object = ;
19 try {
20 jedis = jedisPool.getResource;
21 byte ObjectByteArray = jedis.get(key.getBytes);
22 object = unserialize(ObjectByteArray);
23 }catch (Exception e){
24 e.printStackTrace;
25 }finally {
26 close(jedis);
27 }
28 return object;
29 }
30
31 /**
32 * 将对象缓存到Redis中，设置默认过期时间
33 * @param key
34 * @param value
35 */
36 public void putObject(String key, Object value) {
37 putObject(key,value,);
38 }
39 /**
40 * 将对象缓存到Redis中，自定义认过期时间
41 * @param key
42 * @param value
43 */
44 public void putObject(String key, Object value, Long expireTime) {
45 Jedis jedis = ;
46 try {
47 jedis = jedisPool.getResource;
48 jedis.psetex(key.getBytes,getExpireTime(expireTime),serialize(value));
49 }catch (Exception e){
50 e.printStackTrace;
51 }finally {
52 close(jedis);
53 }
54 }
55
56
57 /**
58 * 序列化
59 * @param object
60 * @return
61 */
62 public static byte serialize(Object object) {
63 ObjectOutputStream oos = ;
64 ByteArrayOutputStream baos = ;
65 try {
66 baos = new ByteArrayOutputStream;
67 oos = new ObjectOutputStream(baos);
68 oos.writeObject(object);
69 byte bytes = baos.toByteArray;
70 return bytes;
71 } catch (Exception e) {
72 logger.error(e.getMessage, e);
73 } finally {
74 IOUtil.closeStream(oos);
75 IOUtil.closeStream(baos);
76 }
77 return ;
78 }
79
80 /**
81 * 反序列化
82 * @param bytes
83 * @return
84 */
85 public static Object unserialize(byte[] bytes) {
86 if (bytes == ) return ;
87
88 ByteArrayInputStream bais = ;
89 ObjectInputStream ois = ;
90 try {
91 bais = new ByteArrayInputStream(bytes);
92 ois = new ObjectInputStream(bais);
93 return ois.readObject;
94 } catch (Exception e) {
95 logger.error(e.getMessage, e);
96 } finally {
97 IOUtil.closeStream(bais);
98 IOUtil.closeStream(ois);
99 }
100 return ;
101 }
102}

关闭输入流和输出流工具类具体代码如下：

 1public class IOUtil {
2 public static void closeStream(InputStream inputStream) {
3 if (inputStream != ) {
4 try {
5 inputStream.close;
6 } catch (IOException e) {
7 e.printStackTrace;
8 }
9
10 }
11 }
12
13 public static void closeStream(OutputStream outputStream) {
14 if (outputStream != ) {
15 try {
16 outputStream.close;
17 } catch (IOException e) {
18 e.printStackTrace;
19 }
20
21 }
22 }
23}

序列化方式演示

测试 JedisCacheService putObject(将对象放入缓存中)、getObject(从缓存中获取对象)，具体代码如下：

 1@RunWith(SpringRunner.class)
2@SpringBootTest
3public class JedisCacheServiceTest {
4 private Logger logger = LoggerFactory.getLogger(JedisCacheService.class);
5 @Autowired
6 private JedisCacheService jedisCacheService;
7
8 @Test
9 public void putObject {
10 User user = new User("zhuoqiammingyue

获取对象的key_玩转 SpringBoot2.x 之缓存对象 | 原力计划