mybatis缓存（二）+redis

redis缓存：
缓存中存在数据就直接返回 ，不存在就从数据库读写同时写入缓存
以后再访问同样的数据直接从缓存读取

<!-- redis jar包 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.7.2</version>
</dependency>

配置文件：

     <settings>
        <setting name="cacheEnabled" value="true"/>
     </settings>
 
映射文件：

mybatis默认缓存类 FifoCache :
内存空间不足时 需要一种机制保证内存不溢出
FIFO(默认):
需要将旧的的数据清除（最先插入的数据最先清除）
LRU:最近使用次数最少的,优先删除
LFU:最近一段时间内使用次数最少,优先删除

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true" type="自定义实现类的路径"> 
  </cache>

//实体类
public class Student implements Serializable{
private Integer sid;
private String sname;
private Integer gid;
private Integer sex;
public Integer getSid() {
return sid;
}
public void setSid(Integer sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Integer getGid() {
return gid;
}
public void setGid(Integer gid) {
this.gid = gid;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
}


//自定义实现Cache
public class RedisCache implements Cache {
/**
* 操作redis对象
*/
Jedis jedis=new Jedis("localhost",6379);

/**
* 缓存的id
*/
private String cacheId;
public RedisCache(String cacheId){
this.cacheId=cacheId;
}
@Override
public void clear() {
//jedis.flushDB();
}


@Override
public String getId() {
return cacheId;
}
/**
* mybatis自动调用getObject检测是否缓存中存在
*/
@Override
public Object getObject(Object key) {
try {
byte[] bt=jedis.get(RedisTest.objectToByteArray(key));
if(bt==null){
return null;
}
return RedisTest.byteArrayToObject(bt);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}


@Override
public ReadWriteLock getReadWriteLock() {
return new ReentrantReadWriteLock();
}


@Override
public int getSize() {
return 1;
}
/**
* mybatis读取数据时 将数据库中读取的数据 通过
*   putObject设置到缓存中
*/
@Override
public void putObject(Object key, Object value) {
//写入redis
try {
jedis.set(RedisTest.objectToByteArray(key), RedisTest.objectToByteArray(value));
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* mybatis缓存策略 自动判断内存的大小 绝对是否删除某些过期 久远的数据
* @param key
* @return
*/
@Override
public Object removeObject(Object key) {
Object obj=getObject(key);
try {
jedis.del(RedisTest.objectToByteArray(key));
} catch (IOException e) {
e.printStackTrace();
}
return obj;
}
}


//redis类
public class RedisTest {


/**
* 序列化
* @param object
* @return
* @throws IOException
*/
public static byte[] objectToByteArray(Object object) throws IOException{
ByteOutputStream boStream=new ByteOutputStream();
ObjectOutputStream oosStream=new ObjectOutputStream(boStream);
oosStream.writeObject(object);
return boStream.getBytes();
}

/**
* 反序列化
* @param by
* @return
* @throws Exception
*/
public static Object byteArrayToObject(byte[] by) throws  Exception{
ByteInputStream biStream=new ByteInputStream(by,by.length);
biStream.read(by);
ObjectInputStream oisStream=new ObjectInputStream(biStream);
return oisStream.readObject();
}

public static void main(String[] args) {
Jedis jedis=new Jedis("localhost",6379);

//String
jedis.set("name", "ssg");
jedis.get("name");

//Hash
jedis.hset("user","age", "19");
jedis.hget("user", "age");

//List
jedis.lpush("class", "4","6");
jedis.rpush("class", "123");
jedis.lrange("class", 0, 10);

//Set(不支持重复元素)
jedis.sadd("phone", "pingguo");
jedis.smembers("phone");

//sorted set
jedis.zadd("grade", 66, "aa");
jedis.zrange("grade", 0, 10);
}
}


表结构,接口,测试类和mybatis缓存中一致