JCache是Java EE中定义的统一缓存API规范，Redisson作为基于Redis实现的Java驻内存数据网格，完整支持了JCache规范，其序列化机制是连接Java对象与Redis存储数据的核心桥梁，直接决定了缓存的读写效率、内存占用以及跨节点数据交互的可靠性。
JCache with Redisson序列化基础原理
当使用Redisson实现JCache接口时，所有需要存入缓存的Java对象都需要经过序列化转换为字节数组，才能存储到Redis中；从缓存读取数据时，则需要将Redis中的字节数组反序列化为对应的Java对象。Redisson默认已经为JCache提供了适配的序列化方案，开发者也可以根据业务需求自定义序列化规则。
默认序列化流程
Redisson在处理JCache的缓存操作时，会优先使用配置的序列化器处理键值对：
- 键的序列化：默认使用
StringCodec，将键转换为字符串对应的字节数组，保证键的可读性和通用性 - 值的序列化：默认使用
JsonJacksonCodec，基于Jackson库将对象转换为JSON格式的字节数组，支持大部分常见的Java类型
Redisson内置序列化器类型
Redisson提供了多种内置的序列化器，开发者可以根据不同的业务场景选择合适的类型，常见的序列化器如下：
| 序列化器类名 | 说明 | 适用场景 |
|---|---|---|
| JsonJacksonCodec | 基于Jackson的JSON序列化，可读性好，兼容性强 | 大部分业务对象，需要跨语言交互的场景 |
| SerializationCodec | 基于JDK原生序列化机制 | 仅Java环境使用，对象无需额外适配的场景 |
| StringCodec | 仅处理字符串类型，不做额外转换 | 缓存键或者纯字符串值的场景 |
| KryoCodec | 基于Kryo的高性能序列化 | 对序列化性能要求高的Java场景 |
| FstCodec | 基于FST的高性能序列化 | 对序列化性能要求高，且对象结构稳定的场景 |
JCache中配置Redisson序列化器
在使用JCache with Redisson时，需要通过配置指定使用的序列化器，配置方式分为代码配置和配置文件配置两种。
代码方式配置
通过Redisson的Config对象设置序列化器，再将配置传递给JCache的缓存管理器：
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import javax.cache.Cache;
import javax.cache.CacheManager;
import javax.cache.Caching;
import javax.cache.configuration.MutableConfiguration;
import javax.cache.spi.CachingProvider;
public class JCacheRedissonSerializeDemo {
public static void main(String[] args) {
// 创建Redisson配置
Config config = new Config();
// 单Redis节点配置
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
// 设置全局值序列化器为KryoCodec，提升序列化性能
config.setCodec(new org.redisson.codec.KryoCodec());
// 获取JCache的CachingProvider
CachingProvider cachingProvider = Caching.getCachingProvider();
// 创建缓存管理器，传入Redisson的JCache实现
CacheManager cacheManager = cachingProvider.getCacheManager(
null,
null,
Redisson.class.getClassLoader()
);
// 配置缓存，指定缓存名称为userCache
MutableConfiguration<String, User> cacheConfig = new MutableConfiguration<>();
cacheConfig.setStoreByValue(true);
// 获取缓存实例
Cache<String, User> cache = cacheManager.createCache("userCache", cacheConfig);
// 存入对象
User user = new User("1", "张三", 25);
cache.put("user_1", user);
// 读取对象
User cachedUser = cache.get("user_1");
System.out.println(cachedUser.getName());
}
// 静态内部类，用于缓存的对象
static class User {
private String id;
private String name;
private int age;
public User() {}
public User(String id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
}
}
配置文件方式配置
也可以在Redisson的配置文件（如redisson.yaml）中指定序列化器：
singleServerConfig:
address: "redis://127.0.0.1:6379"
codec: !<org.redisson.codec.JsonJacksonCodec> {}
之后在代码中加载该配置文件即可应用序列化配置。
自定义序列化器实现
如果内置的序列化器无法满足需求，比如需要兼容旧的序列化格式，或者需要特殊处理某些类型的对象，可以自定义序列化器，只需要实现Redisson的Codec接口即可。
以下是自定义一个简单的字符串和对象互转的序列化器示例：
import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.Encoder;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class CustomStringCodec implements Codec {
private final Encoder encoder = in -> {
if (in == null) {
return new byte[0];
}
// 将对象转换为字符串再转为字节数组
return in.toString().getBytes(StandardCharsets.UTF_8);
};
private final Decoder<Object> decoder = (buf, state) -> {
byte[] bytes = new byte[buf.readableBytes()];
buf.readBytes(bytes);
// 将字节数组转为字符串返回
return new String(bytes, StandardCharsets.UTF_8);
};
@Override
public Decoder<Object> getValueDecoder() {
return decoder;
}
@Override
public Encoder getValueEncoder() {
return encoder;
}
@Override
public Decoder<Object> getMapKeyDecoder() {
return decoder;
}
@Override
public Encoder getMapKeyEncoder() {
return encoder;
}
@Override
public Decoder<Object> getMapValueDecoder() {
return decoder;
}
@Override
public Encoder getMapValueEncoder() {
return encoder;
}
}
自定义完成后，将该Codec设置到Redisson配置中即可生效。
序列化使用优化建议
- 优先选择性能合适的序列化器：如果对性能要求高且仅为Java环境使用，可选择KryoCodec或者FstCodec；如果需要跨语言交互，选择JsonJacksonCodec
- 避免缓存过大的对象：序列化后的字节数组过大会增加Redis的内存占用和网络传输开销，建议拆分大对象后再缓存
- 缓存对象尽量简洁：不需要缓存的字段可以添加transient关键字（JDK序列化场景）或者在序列化时忽略，减少序列化后的数据量
- 统一序列化配置：集群环境下所有节点的Redisson序列化配置需要保持一致，避免出现反序列化失败的问题
注意：如果使用JDK原生的SerializationCodec，缓存的对象必须实现Serializable接口，否则会抛出序列化异常。