mybatis-config.xml配置:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<settings>
<setting name="cacheEnabled" value="true"/>
</settings>
<typeAliases>
<package name="com.briup.bean" />
</typeAliases>
<!-- environments标签改为在spring中的数据源里面配置 -->
<mappers>
<mapper resource="com/briup/dao/IUserDaoMapper.xml"/>
</mappers>
</configuration>
实体类的mapper.xml配置
<?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.briup.dao.IUserDao">
<cache type="com.briup.cache.MybatisRedisCache"></cache>
<insert id="saveUser" parameterType="User">
<selectKey resultType="long" keyProperty="id" order="BEFORE">
select my_seq.nextval from dual
</selectKey>
insert into t_user(id,name,age,dob)
values(#{id},#{name},#{age},#{dob})
</insert>
<select id="findAllUsers" resultType="User">
select id,name,age,dob
from t_user
</select>
<select id="findUserByName" parameterType="string" resultType="User">
select id,name,age,dob
from t_user
where name=#{name}
</select>
</mapper>
redis工具类
package com.briup.util;
import java.util.ResourceBundle;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class JedisUtils {
public static JedisPool jedisPool;
static {
//ResourceBundle会查找classpath下的xxx.properties的文件,xxx是方法中指定的
ResourceBundle resourceBundle = ResourceBundle.getBundle("redis");
int maxTotal = Integer.parseInt(resourceBundle.getString("redis.pool.maxTotal"));
int maxIdle = Integer.parseInt(resourceBundle.getString("redis.pool.maxIdle"));
int maxWait = Integer.parseInt(resourceBundle.getString("redis.pool.maxWait"));
String ip = resourceBundle.getString("redis.ip");
int port = Integer.parseInt(resourceBundle.getString("redis.port"));
JedisPoolConfig config = new JedisPoolConfig();
// 设置最大连接数
config.setMaxTotal(maxTotal);
// 设置最大空闲数
config.setMaxIdle(maxIdle);
// 设置超时时间
config.setMaxWaitMillis(maxWait);
// 初始化连接池
jedisPool = new JedisPool(config, ip, port);
}
public static void set(Object key, Object value) {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
jedis.set(SerializingUtils.serialize(key), SerializingUtils.serialize(value));
} catch (Exception e) {
e.printStackTrace();
}finally {
jedis.close();
}
}
public static Object get(Object key) {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
byte[] keyBytes = SerializingUtils.serialize(key);
if(jedis.exists(keyBytes)){
return SerializingUtils.deserialize(jedis.get(keyBytes));
}
} catch (Exception e) {
e.printStackTrace();
}finally {
jedis.close();
}
return null;
}
public static void del(Object key) {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
jedis.del(SerializingUtils.serialize(key));
} catch (Exception e) {
e.printStackTrace();
}finally {
jedis.close();
}
}
public static void clear() {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
jedis.flushDB();
} catch (Exception e) {
e.printStackTrace();
}finally {
jedis.close();
}
}
public static int getSize() {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
} catch (Exception e) {
e.printStackTrace();
}finally {
jedis.close();
}
return jedis.dbSize().intValue();
}
public static Jedis getResource(){
return jedisPool.getResource();
}
}
cache工具类
package com.briup.cache;
import java.util.concurrent.locks.ReadWriteLock;
import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.cache.CacheException;
import com.briup.util.JedisUtils;
/**
* Cache为缓存接口,给缓存供应商的SPI(Service Provider Interface)
* Cache接口的实现类必须有一个具有String类型参数的构造方法,该参数作为实现类对象的id,对其进行唯一标识
*/
public class MybatisRedisCache implements Cache {
private String id;
public MybatisRedisCache(String id) {
this.id = id;
}
/**
* 清空缓存
*/
@Override
public void clear() {
JedisUtils.clear();
}
/**
* 获取缓存对象的唯一标识
*/
@Override
public String getId() {
return this.id;
}
/**
* 从缓存对象中获取key对应的value
*/
@Override
public Object getObject(Object key) {
return JedisUtils.get(key);
}
/**
* 获取读写锁 可选的方法,从3.2.6起这个方法不再被框架核心调用 任何需要的锁,都必须由缓存供应商提供
*/
@Override
public ReadWriteLock getReadWriteLock() {
return null;
}
/**
* 获取缓存对象中存储的键/值对的数量 可选的方法,没有被框架核心调用
*/
@Override
public int getSize() {
return JedisUtils.getSize();
}
/**
* 保存key/value到缓存对象中 key可以是任何对象
*/
@Override
public void putObject(Object key, Object value) {
JedisUtils.set(key, value);
}
/**
* 可选的方法,没有被核心框架调用,移除key对应的value
*/
@Override
public Object removeObject(Object key) {
return null;
}
/**
* 重新equals方法
*/
@Override
public boolean equals(Object o) {
if (getId() == null)
throw new CacheException("Cache instances require an ID.");
if (this == o)
return true;
if (!(o instanceof Cache))
return false;
Cache otherCache = (Cache) o;
return getId().equals(otherCache.getId());
}
/**
* 重新hashCode方法
*/
@Override
public int hashCode() {
if (getId() == null)
throw new CacheException("Cache instances require an ID.");
return getId().hashCode();
}
}
序列化工具类
package com.briup.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerializingUtils {
public static byte[] serialize(Object obj) {
ByteArrayOutputStream bos = null;
ObjectOutputStream out = null;
try {
bos = new ByteArrayOutputStream();
out = new ObjectOutputStream(bos);
out.writeObject(obj);
out.flush();
}
catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(out!=null)out.close();
}catch (IOException e) {
e.printStackTrace();
}
}
return bos.toByteArray();
}
public static Object deserialize(byte[] data) {
ObjectInputStream in = null;
Object obj = null;
try {
ByteArrayInputStream byteIn = new ByteArrayInputStream(data);
in = new ObjectInputStream(byteIn);
obj = in.readObject();
}catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(in!=null)in.close();
}catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}
}