使用redis做mybatis的二级缓存

叁歲伎倆 2022-05-27 10:51 241阅读 0赞

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>
    	
    	
    	
    	<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;
    	}
    	
    }