使用redis和fastjson作應用和mysql之間的緩存

第一次作這種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秒便可，但願對你們有所幫助。