springboot+mybatis框架整合redis cluster

一二级缓存

一级缓存：一级缓存是SqlSession级别的缓存。在操作数据库时需要构造sqlSession对象，在对象中有一个数据结构(HashMap)用于存储缓存数据。不同的sqlSession之间的缓存数据区域(HashMap)是互相不影响的。
二级缓存：二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

简单理解：一级缓存就是一个sqlsession对象查询数据库之后进行缓存，但是这个缓存只能自己看，而而二级缓存就是多个sqlsession对象中的一个查询数据之后进行缓存数据，但是这个缓存区域是多个sqlsession对象都可以访问的，举个例子，就像项目中不同的角色对相同的数据进行查看一样，查看的数据是一样的，缓存区有数据之后就不会再去执行sql了，会直接在缓存区拿数据。

二级缓存特点：和一级缓存默认开启不一样，二级缓存需要我们手动开启。

框架整合

1.在可以增删改查的springboot项目下的pom.xml文件下引入以下jar包

<!-- redis缓存 -->    
<dependency>            
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>     
<!-- jedis包 -->    
<dependency>      
<groupId>redis.clients</groupId>      
<artifactId>jedis</artifactId>    
</dependency>

2.redis集群连接配置
#spirngboot+mybatis连接redis cluster配置#最大能够保持空闲状态的链接数
redis.maxIdle=2000
#最大连接数
redis.maxTotal=20000
#最大的等待时长
redis.maxWaitMillis=20000
#当调用borrow Object方法时，是否进行有效性检查redis.testOnBorrow=false
#集群节点配置redis.nodes=192.168.152.31:6001,192.168.152.31:6002,192.168.152.32:6003,192.168.152.32:6004,192.168.152.33:6005,192.168.152.33:6006

3.使用springboot读取自定义配置
@Component
@PropertySource(“classpath:project.properties”) //springboot读取自定义配置文件注解
@ConfigurationProperties(prefix =“redis”) //配置文件中如果有很多配置，只读以redis开头的
@Data
public class RedisProperties {
//最大能够保持空闲状态的链接数
private int maxIdle;
//最大连接数
private int maxTotal;
//最大的等待时长
private int maxWaitMillis;
//当调用borrow Object方法时，是否进行有效性检查
private boolean testOnBorrow;
//集群节点配置
private String nodes;
}

4.编写配置类，使用自定义配置文件，创建redis cluster连接对象

@Configuration
public class RedisClusterConfig {
//依赖注入加载properties配置类
@Resource
private RedisProperties redisProperties;
//实例化redis集群的连接工厂类
@Bean//
public JedisConnectionFactory jedisConnectionFactory(){
//实例化并返回
RedisClusterConfiguration clusterConfig, JedisPoolConfig poolConfig JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(clusterConfig(),poolConfig()); return jedisConnectionFactory;
}

//实例化连接redis集群配置，并且被上面依赖注入
@Bean
public RedisClusterConfiguration clusterConfig(){
//实例化对象
RedisClusterConfiguration redisClusterConfiguration =new RedisClusterConfiguration();
//获取配置
String nodes = redisProperties.getNodes();
//分割配置得到数
String[] nodesArray = nodes.split( “, “);
for (String node : nodesArray) {
//node循环 第一次：192.168.170.41:6001 第二次：192.168.170.41:6002 …
String[] hostAndPortArray = node.split(”:”);
//实例化节点
RedisNode redisNode =new RedisNode(hostAndPortArray[0],Integer.valueOf(hostAndPortArray[1]));
//添加节点 redisClusterConfiguration.addClusterNode(redisNode);
}
return redisClusterConfiguration;
}

//实例化redis集群连接池
@Bean
public JedisPoolConfig poolConfig(){
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); jedisPoolConfig.setMaxIdle(redisProperties.getMaxIdle()); jedisPoolConfig.setMaxTotal(redisProperties.getMaxTotal()); jedisPoolConfig.setMaxWaitMillis(redisProperties.getMaxWaitMillis()); jedisPoolConfig.setTestOnBorrow(redisProperties.isTestOnBorrow());
return jedisPoolConfig;
}

@Bean // 一旦加上bean就会被执行
public void setJedisConnectionFactory(){
//调用静态方法赋值 MyCustomCache.setJedisConnectionFactory(jedisConnectionFactory());
}
}

5.编写mybatis二级缓存调用第3方redis cluster缓存

public class MyCustomCache implements Cache {
//提供一个接受 String 参数作为 id 的构造器 缓存的唯一标识，不用自己赋值，每次缓存任何对象时，都会自动生成一个唯一的ID private String id;
//依赖注入redis集群连接的数据源
private static JedisConnectionFactory jedisConnectionFactory; //实例化读写策略类 读读共享 读写互斥 写读互斥 写写互斥 private ReadWriteLock readWriteLock =new ReentrantReadWriteLock();
//使用静态方法给jedisConnectionFactory赋值
public static void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) { MyCustomCache.jedisConnectionFactory = jedisConnectionFactory;
}

// 空构造
public MyCustomCache() {
}
//ID必须不能为空
public MyCustomCache(String id) {
if(null==id){
throw new IllegalArgumentException(“id不能为空”);
}
this.id = id;
}
public String getId() {
return this.id;
}
@Override
public void putObject(Object key, Object value) {
//获取连接对象 aaa 111
RedisConnection connection = jedisConnectionFactory.getConnection();
//需要序列化 实例化序列类 spring整合redis包提供的 JdkSerializationRedisSerializer jdkSerializationRedisSerializer= new JdkSerializationRedisSerializer();
//序列化key和value byte[] serializeKey = jdkSerializationRedisSerializer.serialize(key);/
/fasdfadfafafafa12313aaa
byte[] serializeValue = jdkSerializationRedisSerializer.serialize(value);
//1231afasfarrqewr111 connection.set(serializeKey,serializeValue);
}

@Override
public Object getObject(Object key) {
//获取连接对象 RedisConnection connection = jedisConnectionFactory.getConnection();
//需要序列化 实例化序列类 spring整合redis包提供的 JdkSerializationRedisSerializer jdkSerializationRedisSerializer= new JdkSerializationRedisSerializer();
//序列化key和value key=fasdfadfafafafa12313aaa
byte[] serializeKey = jdkSerializationRedisSerializer.serialize(key);
byte[] serializeValue = connection.get(serializeKey);//1231afasfarrqewr111
//反序列化，得到原来对象，并返回
return jdkSerializationRedisSerializer.deserialize(serializeValue);
}

@Override
public Object removeObject(Object key) {
//获取连接对象
RedisConnection connection = jedisConnectionFactory.getConnection();
//需要序列化 实例化序列类 spring整合redis包提供的
JdkSerializationRedisSerializer jdkSerializationRedisSerializer= new JdkSerializationRedisSerializer();
byte[] serializeKey = jdkSerializationRedisSerializer.serialize(key);; //connection.del(serializeKey);
//直接删除，假如并发量特别大，会影响集群效率
//expire 失效，并不是立马删除，一旦失效就无法使用，redis底层会间隔一段时间再批量删除失效数据，让整体效率提高
return connection.expire(serializeKey,0);
}

@Override
public void clear() {
//获取连接对象
RedisConnection connection = jedisConnectionFactory.getConnection();
//清空当前库
connection.flushDb();
//清空所有库
connection.flushAll();
}
@Override
public int getSize() {
//获取连接对象
RedisConnection connection = jedisConnectionFactory.getConnection();
Long aLong = connection.dbSize();
return Integer.valueOf(aLong.toString());
}
@Override
public ReadWriteLock getReadWriteLock() {
return readWriteLock;
}
}

6.测试

@CacheNamespace(implementation = MyCustomCache.class)