使用redis和fastjson做应用和mysql之间的缓存

本文涉及的产品
云数据库 RDS MySQL,集群版 2核4GB 100GB
推荐场景:
搭建个人博客
云原生内存数据库 Tair,内存型 2GB
云数据库 Redis 版,社区版 2GB
推荐场景:
搭建游戏排行榜
简介:

第一次做这种javaweb的项目,难免还是要犯很多错误。
大概也知道,redis常常被用来做应用和mysql之间的缓存。模型大概是这样子的。

为了让redis能够缓存mysql数据库中的数据,我写了很多这样类似的代码:

原来的查询商品


public Product selectProductById(int id) {
    Product product = productMapper.selectByPrimaryKey(id);
    if (product != null) {
        String detail = product.getDetail();
        if (detail != null) {
            product.setDetail(HtmlUtils.string2Html(detail));// 进行html转义,替换html转义符
        }
    }
    return product;
}

用redis缓存之后的查询商品


public Product selectProductById(int id) {
    Product product = JSONObject.parseObject(redisCli.get(PRODUCT_KEY +  id), Product.class);
    if (product != null) {
        product = productMapper.selectByPrimaryKey(id);
        String detail = product.getDetail();
        if (detail != null) {
            product.setDetail(HtmlUtils.string2Html(detail));// 进行html转义,替换html转义符
        }
        redisCli.set(PRODUCT_KEY + product.getId(), JSONObject.toJSON(product).toString(),
                30);
    }
    return product;
}

老板说,不行啊,网站首页太慢了!于是我们又开始在ModelAndView上做文章。
原来首页的代码


@RequestMapping("/wxIndex/{id}")
public ModelAndView goWxIndex(HttpServletRequest request, HttpServletResponse response,
        @PathVariable(value = "id") Integer id) {
    
    ModelAndView mv = new ModelAndView(); 
    mv.setViewName(ViewNameConstant.WXINDEX); 
    //一些逻辑代码
    return mv;
}

于是我们又加了这样的代码:


@RequestMapping("/wxIndex/{id}")
public ModelAndView goWxIndex(HttpServletRequest request, HttpServletResponse response,
        @PathVariable(value = "id") Integer id) {
    
    ModelAndView mv = JSONObject.parseObject(redisCli.get("index"),ModelAndView.class);
    if(mv != null)
    {
        return mv;
    }
    mv = new ModelAndView();
    mv.setViewName(ViewNameConstant.WXINDEX); 
    //一些逻辑代码
    redisCli.put("index",JSONObject.toString(mv),30);
    return mv;
}

于是代码越来越乱。

慢慢学习和适应spring的思想中,明白,我们可以使用拦截的方式去做mysql的缓存。我们拦截到一个sql语句,于是把这条sql语句作为key,把返回的结果作为value保存到redis里面去,失效时间为30秒钟;
期间如果发现一个有insert或者update就把对应表的所有的缓存给清理掉。
有了思想就下手去做好了。不曾想发现mybatis已经提供了对应好的缓存的接口Cache,思想和上述完全一致。
那么我们也就是用他的接口好了。

mybatis默认缓存是PerpetualCache,可以查看一下它的源码,发现其是Cache接口的实现;那么我们的缓存只要实现该接口即可。

该接口有以下方法需要实现:


public abstract interface Cache
  String getId();
  int getSize();
  void putObject(Object key, Object value);   
  Object getObject(Object key);                   
  Object removeObject(Object key);
  void clear();
  ReadWriteLock getReadWriteLock();
}

最重要的两个接口是putObject和getObject;任何select语句都会首先请求getObject函数,如果返回为null,那么再去请求mysql数据库;我们在mysql中取到数据之后,调用putObject函数,进行缓存数据的保存。
序列图为:

网上提供的案例,大部分是这样子:


public class MybatisRedisCache implements Cache {

    private RedisCli redisCli;
    @Override  
    public void putObject(Object key, Object value) {  
        logger.debug(">>>>>>>>>>>>>>>>>>>>>>>>putObject:"+key+"="+value);  
        redisCli.set(SerializeUtil.serialize(key.toString()), SerializeUtil.serialize(value));  
    }  
  
    @Override  
    public Object getObject(Object key) {  
        Object value = SerializeUtil.unserialize(redisCli.get(SerializeUtil.serialize(key.toString())));  
        logger.debug(">>>>>>>>>>>>>>>>>>>>>>>>getObject:"+key+"="+value);  
        return value;  
    }  
}

public class SerializeUtil {  
    public static byte[] serialize(Object object) {  
        ObjectOutputStream oos = null;  
        ByteArrayOutputStream baos = null;  
        try {  
        //序列化  
          baos = new ByteArrayOutputStream();  
          oos = new ObjectOutputStream(baos);  
          oos.writeObject(object);  
          byte[] bytes = baos.toByteArray();  
          return bytes;  
        } catch (Exception e) {  
           e.printStackTrace();  
        }  
          return null;  
        }  
           
    public static Object unserialize(byte[] bytes) {  
        ByteArrayInputStream bais = null;  
        try {  
          //反序列化  
          bais = new ByteArrayInputStream(bytes);  
          ObjectInputStream ois = new ObjectInputStream(bais);  
          return ois.readObject();  
        } catch (Exception e) {  
           
        }  
          return null;  
        } 
} 

如果是通过java提供的序列化进行实体类和String的转换,那么我们要修改所有已经存在的实体Bean类,工作量太大;而且java的序列化效率又低;我们还是考虑使用工程已经引入的fastjson好;使用fastjson,就必须在缓存数据的时候,同时缓存数据的类型;我们使用redis的hash结构,就能解决这个问题

于是接口就成了下面这个样子:


public class MybatisRedisCache implements Cache {
    private RedisCli redisCli;
    @Override
    public void putObject(Object key, Object value) {
        String keyStr = getKey(key);
        
        Map<String,String> map = new HashMap<String,String>();
        //如果是多组数据,那么保存的方式不同,多组的情况需要保存子实体类型
        if(value.getClass().equals(ArrayList.class))
        {
            @SuppressWarnings("unchecked")
            List<Object> list = (List<Object>)value;
            map.put("type", "java.util.ArrayList");
            if(list.size() > 0)
            {
                map.put("subType", list.get(0).getClass().getCanonicalName());
            }
            else
            {
                map.put("subType",Object.class.getCanonicalName());
            }
            map.put("value", JSONObject.toJSONString(value));
        }
        else
        {
            map.put("type", value.getClass().getCanonicalName());
            map.put("value", JSONObject.toJSONString(value));
        }
        this.redisCli.hAllSet(keyStr, map,30);
        this.cacheKeys.add(keyStr);
    }

    @Override
    public Object getObject(Object key) {
        try
        {
            String keyStr = getKey(key);
            
            Map<Object,Object> map = this.redisCli.hAllGet(keyStr);
            String type = (String)map.get("type");
            String value = (String)map.get("value");
            
            if(type == null || value == null)
            {
                return null;
            }
            
            if("java.util.ArrayList".equals(type))
            {
                String subType = (String)map.get("subType");
                return JSONObject.parseArray(value, Class.forName(subType));
            }
            else
            {
                return JSONObject.parseObject(value, Class.forName(type));
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
        
    }
    
    @Override
    public void clear() {
        if(this.cacheKeys.isEmpty())
        {
            return ;
        } 
        for(String key : this.cacheKeys)
        {
            this.redisCli.del(key);
        }
        this.cacheKeys.clear();
    }
}

ps: 我们这里还是把key直接保存在了内存里面,这样存在的问题就是,如果服务器重启,那么需要清理所有的缓存;不然一定会造成脏数据。
或者,我们在保存缓存数据的时候,设置缓存数据的生命时间是30秒即可,希望对大家有所帮助。



相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
相关文章
|
2天前
|
存储 缓存 关系型数据库
MySQL数据库缓存query_cache 19
【7月更文挑战第19天】MySQL数据库缓存query_cache
135 73
|
8天前
|
canal 缓存 NoSQL
Redis常见面试题(一):Redis使用场景,缓存、分布式锁;缓存穿透、缓存击穿、缓存雪崩;双写一致,Canal,Redis持久化,数据过期策略,数据淘汰策略
Redis使用场景,缓存、分布式锁;缓存穿透、缓存击穿、缓存雪崩;先删除缓存还是先修改数据库,双写一致,Canal,Redis持久化,数据过期策略,数据淘汰策略
Redis常见面试题(一):Redis使用场景,缓存、分布式锁;缓存穿透、缓存击穿、缓存雪崩;双写一致,Canal,Redis持久化,数据过期策略,数据淘汰策略
|
16天前
|
缓存 NoSQL Redis
使用Redis实现缓存穿透的解决方案
使用Redis实现缓存穿透的解决方案
|
4天前
|
存储 缓存 NoSQL
深入理解分布式缓存在后端系统中的应用与实践
【7月更文挑战第20天】 本文将探讨分布式缓存技术在后端系统设计中的关键角色,并揭示其如何优化性能和扩展性。文章不仅剖析了分布式缓存的基本原理和工作机制,而且提供了实际案例分析,展示了其在处理大规模数据时的优势。我们将深入了解几种流行的分布式缓存解决方案,并讨论它们在不同场景下的适用性。最后,文章将指导读者如何在真实世界的应用中实施分布式缓存,包括架构设计、性能调优以及故障排除的最佳实践。
|
4天前
|
存储 缓存 NoSQL
深入理解分布式缓存在现代后端系统中的应用与挑战
随着互联网技术的飞速发展,分布式缓存已成为提升后端系统性能的关键技术之一。本文将从数据导向和科学严谨的角度出发,探讨分布式缓存技术的原理、应用场景以及面临的主要挑战。通过对具体案例的分析和数据统计,我们旨在为读者提供一个全面而深入的理解框架,帮助开发者更好地设计和优化后端系统。 【7月更文挑战第20天】
9 0
|
9天前
|
关系型数据库 MySQL 数据挖掘
MySQL 聚合函数案例解析:深入实践与应用
MySQL 聚合函数案例解析:深入实践与应用
|
12天前
|
存储 NoSQL 关系型数据库
RDS(Relational Database Service)和Redis
【7月更文挑战第12天】
20 0
|
14天前
|
设计模式 存储 缓存
Java面试题:结合设计模式与并发工具包实现高效缓存;多线程与内存管理优化实践;并发框架与设计模式在复杂系统中的应用
Java面试题:结合设计模式与并发工具包实现高效缓存;多线程与内存管理优化实践;并发框架与设计模式在复杂系统中的应用
17 0
|
16天前
|
缓存 NoSQL Redis
使用Redis实现缓存穿透的解决方案
使用Redis实现缓存穿透的解决方案
|
19天前
|
缓存 监控 NoSQL
若依修改----监控相关,主要包括在线用户,数据监控,服务监控,缓存监控,缓存列表,缓存监控有助于帮我们搞清楚redis的缓存情况,数据监控的密码控制台管理用户名和密码在application-dru
若依修改----监控相关,主要包括在线用户,数据监控,服务监控,缓存监控,缓存列表,缓存监控有助于帮我们搞清楚redis的缓存情况,数据监控的密码控制台管理用户名和密码在application-dru