Java Spring Boot为REDIS反序列化响应

当我的代码尝试反序列化对REDIS的响应时，出现以下错误：

嵌套异常为com.fasterxml.jackson.databind.JsonMappingException:无法构造org.springframework.http.ResponseEntity的实例：未找到合适的构造函数，无法从对象值反序列化（缺少默认构造函数或创建者，或者可能需要添加/启用类型信息？）

我的控制器：

@Cacheable(value = "restapi", keyGenerator = "customKeyGenerator")
    @RequestMapping(value = "/restapi/{id}", method = RequestMethod.GET, produces = { "application/json;charset=UTF-8" })
    @ResponseStatus(HttpStatus.OK)

    public ResponseEntity<Object> findRestApi(@PathVariable("id") Integer id) {

        RestModel model= new RestModel ();

        model = restService.findRestById(id);

        return new ResponseEntity<>(produto, headers, HttpStatus.OK);
}

@Cacheable（value=“restapi”，keyGenerator=“customKeyGenerator”）
@RequestMapping（value=“/restapi/{id}”，method=RequestMethod.GET，products={”application/json；charset=UTF-8“}）
@ResponseStatus（HttpStatus.OK）
公共响应属性findRestApi（@PathVariable（“id”）整数id）{
RestModel=newrestmodel（）；
model=restService.findRestById（id）；
返回新的ResponseEntity（produto、headers、HttpStatus.OK）；
}

我的Redis配置类

@Configuration
@EnableCaching
public class CacheConfig extends CachingConfigurerSupport {

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private Integer port;

    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory redisConnectionFactory = new JedisConnectionFactory();
        redisConnectionFactory.setHostName(host);
        redisConnectionFactory.setPort(port);
        return redisConnectionFactory;
    }

    @Bean
    RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory rcf) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(rcf);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new JsonRedisSerializer());

        return template;
    }

    static class JsonRedisSerializer implements RedisSerializer<Object> {

        private final ObjectMapper om;

        public JsonRedisSerializer() {
            this.om = new ObjectMapper().enableDefaultTyping(DefaultTyping.NON_FINAL, As.PROPERTY);
        }

        @Override
        public byte[] serialize(Object t) throws SerializationException {
            try {
                return om.writeValueAsBytes(t);
            } catch (JsonProcessingException e) {
                throw new SerializationException(e.getMessage(), e);
            }
        }

        @Override
        public Object deserialize(byte[] bytes) throws SerializationException {

            if(bytes == null){
                return null;
            }

            try {
                return om.readValue(bytes, Object.class);
            } catch (Exception e) {
                throw new SerializationException(e.getMessage(), e);
            }
        }
    }

    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        cacheManager.setDefaultExpiration(300);
        return cacheManager;
    }

    @Bean
    public KeyGenerator customKeyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                StringBuilder sb = new StringBuilder();
                sb.append(o.getClass().getName());
                sb.append(method.getName());
                for (Object obj : objects) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
}

@配置
@启用缓存
公共类CacheConfig扩展了CachingConfigurerSupport{
@值（${spring.redis.host}”）
私有字符串主机；
@值（${spring.redis.port}”）
专用整数端口；
@豆子
public JedisConnectionFactory redisConnectionFactory（）{
JedisConnectionFactory redisConnectionFactory=新的JedisConnectionFactory（）；
redisConnectionFactory.setHostName（主机）；
redisConnectionFactory.setPort（端口）；
返回连接工厂；
}
@豆子
RedisTemplate RedisTemplate（RedisConnectionFactory rcf）{
RedisTemplate=新RedisTemplate（）；
模板。设置连接工厂（rcf）；
setKeySerializer（新的StringRedisSerializer（））；
setValueSerializer（新的JsonRedisSerializer（））；
返回模板；
}
静态类JsonRedisSerializer实现了RedisSerializer{
私有最终对象映射器om；
公共JsonRedisSerializer（）{
this.om=new ObjectMapper（）.enableDefaultTyping（DefaultTyping.NON_FINAL，As.PROPERTY）；
}
@凌驾
公共字节[]序列化（对象t）引发序列化异常{
试一试{
返回om.writeValueAsBytes（t）；
}捕获（JsonProcessingException e）{
抛出新的序列化异常（e.getMessage（），e）；
}
}
@凌驾
公共对象反序列化（字节[]字节）引发序列化异常{
如果（字节==null）{
返回null；
}
试一试{
返回om.readValue（字节，对象.class）；
}捕获（例外e）{
抛出新的序列化异常（e.getMessage（），e）；
}
}
}
@豆子
公共缓存管理器缓存管理器（RedisTemplate RedisTemplate）{
RedisCacheManager cacheManager=新的RedisCacheManager（redisTemplate）；
cacheManager.setDefaultExpiration（300）；
返回缓存管理器；
}
@豆子
公钥生成器customKeyGenerator（）{
返回新的KeyGenerator（）{
@凌驾
公共对象生成（对象o、方法方法、对象…对象）{
StringBuilder sb=新的StringBuilder（）；
sb.append（o.getClass（）.getName（））；
sb.append（method.getName（））；
用于（对象对象对象：对象）{
sb.append（obj.toString（））；
}
使某人返回字符串（）；
}
};
}
}

---

有人知道我能做什么吗？谢谢

您需要为ResponseEntity编写自定义JsonDeserializer。要缓存您的模型而不是

ResponseEntity

，请在服务方法

restService.findRestById（id）上使用
@Cacheable
，而不是控制器方法。@HemantPatel非常感谢您！您的解决方案非常有效！！