【JAVA】将java对象缓存到Redis中

最新推荐文章于 2024-08-26 03:34:29 发布

戴陵FL

最新推荐文章于 2024-08-26 03:34:29 发布

阅读量4k

点赞数 1

分类专栏： JAVA 文章标签： java redis

本文链接：https://blog.youkuaiyun.com/weixin_41755556/article/details/121472206

版权

JAVA 专栏收录该内容

6 篇文章

订阅专栏

本文介绍了如何将Java对象（如UserInfo类）序列化后存储到Redis缓存中，以及如何从Redis中取出并反序列化。通过实现Serializable接口和使用SerializeUtil工具类，实现了对象与字节流之间的转换，有效实现了数据的持久化存储。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.要将Java对象缓存到Redis，首先要将该类序列化，以二进制字节流的形式缓存
如类UserInfo，实现序列化接口，并赋予一个序列化ID

@Data
public class UserInfo implements Serializable {

    private static final long serialVersionUID = -2718643841231352368L;

    private String userName;

    private String token;

    private String userId;

    private String expiresTime;

    private String perms;
    
}

2.实现一个序列化工具类

public class SerializeUtil {

    // 序列化
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        byte[] bytes = null;
        try {
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            bytes = baos.toByteArray();
        } catch (Exception e) {
            System.err.println("序列化失败" + e.getMessage());
        }
        return bytes;
    }

    // 反序列化
    public static Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
        ByteArrayInputStream bais = null;
        ObjectInputStream ois = null;
        try {
            bais = new ByteArrayInputStream(bytes);
            ois = new ObjectInputStream(bais);
        } catch (Exception e) {
            System.err.println("反序列化失败" + e.getMessage());
        }
        return ois.readObject();
    }

    /**
     * 字节数组转成16进制表示格式的字符串
     *
     * @param byteArray 需要转换的字节数组
     * @return 16进制表示格式的字符串
     **/
    public static String toHexString(byte[] byteArray) {
        if(byteArray == null || byteArray.length < 1) {
            throw new IllegalArgumentException("this byteArray must not be null or empty");
        }
        final StringBuilder hexString = new StringBuilder();
        for(int i = 0; i < byteArray.length; i++) {
            if ((byteArray[i] & 0xff) < 0x10) {//0~F前面不零
                hexString.append("0");
            }
            hexString.append(Integer.toHexString(0xFF & byteArray[i]));
        }
        return hexString.toString().toLowerCase();
    }


    public static byte[] toByteArray(String hexString) {
        if(StringUtils.isEmpty(hexString)) {
            throw new IllegalArgumentException("this hexString must not be empty");
        }
        hexString = hexString.toLowerCase();
        final byte[] byteArray = new byte[hexString.length() / 2];
        int k = 0;
        for (int i = 0; i < byteArray.length; i++) {//因为是16进制，最多只会占用4位，转换成字节需要两个16进制的字符，高位在先
            byte high = (byte) (Character.digit(hexString.charAt(k), 16) & 0xff);
            byte low = (byte) (Character.digit(hexString.charAt(k + 1), 16) & 0xff);
            byteArray[i] = (byte) (high << 4 | low);
            k += 2;
        }
        return byteArray;
    }

}

3.将UserInfo的某个实例化对象缓存进Redis

public static final String USERINFO_CACHE_PREFIX = "ctyfl.cache.userinfo.";

public void saveUserInfo(UserInfo userInfo) {
	try {
    	redisService.set(USERINFO_CACHE_PREFIX + userInfo.getToken(), SerializeUtil.serialize(userInfo).toString());
    } catch(Exception e) {
    	e.printStackTrace();
    }
}

4.需要时再从Redis中取出

public UserInfo getUserInfoCache(String token) {
	UserInfo userInfo = null;
	if(redisService.exists(USERINFO_CACHE_PREFIX + token)) {
		userInfo = (UserInfo) SerializeUtil.deserialize(SerializeUtil.toByteArray(redisService.get(USERINFO_CACHE_PREFIX + token)));
	}
	return userInfo;
}