springMVC 緩存（入門 spring+mybaties+redis一）

　　使用redis之前需要咋電腦上安裝redis；

　　使用spring+mybaties+redis的本質是擴展類   org.apache.ibatis.cache.Cache；在我們自己擴展的Cache里面使用redis的api；

一：需要引入的依賴：

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.7.2.RELEASE</version>
</dependency>
<dependency>
　　<groupId>redis.clients</groupId>
　　<artifactId>jedis</artifactId>
　　<version>2.1.0</version>
</dependency>

二：在mybaties-config.xml配置文件中開啟緩存：

<settings>
　　<!-- 這個配置使全局的映射器啟用或禁用緩存 -->  
    <setting name="cacheEnabled" value="true"/>
　　<!-- 全局啟用或禁用延遲加載。當禁用時，所有關聯對象都會即時加載。 -->  
    <setting name="lazyLoadingEnabled" value="false"/>
    <setting name="aggressiveLazyLoading" value="true"/>
</settings>
此處需要注意的是：
屬性延遲加載和關聯對象加載（lazyLoadingEnabled）給關閉了，不然放進redis中的cglib代理對象，在對數據發生更改的時候，會出錯。

　三：寫屬於自己的擴展類（org.apache.ibatis.cache.Cache類的擴展類）：

類一如下：

package com.rayeye.law.app.utils.redis;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ibatis.cache.Cache;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Created by Sean on 2016/9/13.
 */
public class RedisCache   implements Cache {

    private static Log logger = LogFactory.getLog(RedisCache.class);
    private Jedis redisClient = createClient();
    /** The ReadWriteLock. */
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    private String id;
    public RedisCache(final String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        logger.debug(">>>>>>>>>>>>>>>>>>>>>>>>MybatisRedisCache:id=" + id);
        this.id = id;
    }

    @Override
    public String getId() {
        return this.id;
    }

    @Override
    public int getSize() {
        return Integer.valueOf(redisClient.dbSize().toString());
    }

    @Override
    public void putObject(Object key, Object value) {
        logger.debug(">>>>>>>>>>>>>>>>>>>>>>>>putObject:" + key + "=" + value);
        redisClient.set(SerializeUtil.serialize(key.toString()), SerializeUtil.serialize(value));
    }

    @Override
    public Object getObject(Object key) {
        Object value = SerializeUtil.unserialize(redisClient.get(SerializeUtil.serialize(key.toString())));
        logger.debug(">>>>>>>>>>>>>>>>>>>>>>>>getObject:" + key + "=" + value);
        return value;
    }

    @Override
    public Object removeObject(Object key) {
        return redisClient.expire(SerializeUtil.serialize(key.toString()), 0);
    }

    @Override
    public void clear() {
        redisClient.flushDB();
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }

    protected  static Jedis createClient() {
        try {
            JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");
            return pool.getResource();
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new RuntimeException("初始化連接池錯誤");
    }



}


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) {
        if(bytes == null)return null;
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
類二如下：

package com.rayeye.law.app.utils.redis;

import org.apache.ibatis.cache.decorators.LoggingCache;

/**
 * Created by Sean on 2016/9/13.
 */
public class LoggingRedisCache extends LoggingCache {
    public LoggingRedisCache(String id) {
        super(new RedisCache(id));
    }
}

四：在mapper.xml文件中直接引用緩存

<!-- 啟用緩存 -->
    <cache type="cn.seafood.cache.LoggingRedisCache" />

如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rayeye.law.app.dao.LawAssistantMapper">
    <cache  type="com.rayeye.law.app.utils.redis.LoggingRedisCache"/>

<select id="getWFK" parameterType="java.util.Map" resultType="java.util.Map">
    select * from weifaku where entityStatus=0
</select>

</mapper>


以上為spring+mybaties+redis簡單整合的流程，
redis的優勢：
1.性能極高，
2.豐富的數據類型，
3.操作具有原子性（聯合的操作也具有原子性），

缺點：
1.收到物理內存的限制（redis是一個獨立的模塊，獨占一定內存），不能適用於海量數據的讀寫（適用於較小數據量的高性能操作）。

總結：Redis受限於特定的場景，專注於特定的領域之下，速度相當之快，目前還未找到能替代使用產品。