1
2
3
4
5
6
7
8
9
10
<!--springboot整合redis jar  开始-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
<!--springboot整合redis jar  结束-->

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# redis 数据源配置   springboot+mybatis+redis cluster

# 最大能够保持空闲状态的连接数
redis.maxIdle=2000

#最大连接数
redis.maxTotal=20000

#最大的等待是时长  毫秒
redis.maxWaitMillis=20000

# 当调用borrow object方法时，是否进行有效性检查
redis.testOnBorrow=false

# 集群节点配置    对应redis服务器创建的集群模式中的IP和端口
redis.nodes=192.168.140.41:8001,192.168.140.41:8002,192.168.140.42:8003,192.168.140.43:8004,192.168.140.43:8005,192.168.140.43:8006

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.aaa.springboot.property;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

/**
 * @author ：caicai
 * @date ：Created in 2022/8/12 13:30
 * @description： redis配置属性类（springboot加载自定义配置文件）
 * @modified By：
 * @version:
 */
@Data
//不在3层之内就使用组件注解 交给ioc容器管理
@Component
//spring 指定本类要加载的配置文件路径
@PropertySource("classpath:project.properties")
//加载到配置文件后，读取配置文件中以redis开头的配置 和本类中属性一致
@ConfigurationProperties(prefix = "redis")
public class RedisProperty {
    // 最大能够保持空闲状态的链接数
    private int maxIdle;
    // 最大连接数
    private int maxTotal;
    // 最大等待时长   毫秒
    private int maxWaitMillis;
    // 当调用borrow object方法时，是否进行有效性检查
    private boolean testOnBorrow;
    // 集群节点配置
    private String nodes;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package com.aaa.springboot.config;
import com.aaa.springboot.property.RedisProperty;
import com.aaa.springboot.util.MyCustomCache;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.JedisPoolConfig;

import javax.annotation.Resource;

@Configuration  // 相当于 redis-cluster-config.xml   <bean></bean>
public class RedisClusterConfig {
    // 依赖注入
    @Resource
    private RedisProperty redisProperty;


    /**
     *  配置JedisConnectionFactory redis连接工厂
     * @return
     */
    @Bean   //<bean id=jedisConnectionFactory class =org.springframework.data.redis.connection.jedis.JedisConnectionFactory>
    public JedisConnectionFactory jedisConnectionFactory(){
        // 实例化对象  使用redis 集群 + redis连接池
        // RedisClusterConfiguration clusterConfig, JedisPoolConfig poolConfig
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(clusterConfig(),poolConfig());

        // 返回对象
        return jedisConnectionFactory;
    }


    /**
     * 初始化 RedisClusterConfiguration   redis 集群配置
     * @return
     */
    @Bean
    public RedisClusterConfiguration clusterConfig() {
        // 实例化
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();

        // 192.168.140.41:8001,192.168.140.41:8002,192.168.140.42:8003,192.168.140.43:8004,192.168.140.43:8005,192.168.140.43:8006
        String nodes = redisProperty.getNodes();
        // nodesArray=["192.168.140.41:8001","192.168.140.41:8002","192.168.140.42:8003",....]
        String[] nodesArray = nodes.split(",");

        // 对节点集合进行遍历
        for (String node : nodesArray) {
            // node: 第一次："192.168.140.41:8001"  第二次  "192.168.140.41:8002"
            // 在次分割  获取ip 和 端口
            String[] nodeip = node.split(":");
            // 实例化节点
            RedisNode redisNode = new RedisNode(nodeip[0], Integer.valueOf(nodeip[1]));
            // 添加节点到集群配置类中
            redisClusterConfiguration.addClusterNode(redisNode);
        }
        return redisClusterConfiguration;
    }


    /**
     *  初始化JedisPoolConfig  redis连接池配置
     * @return
     */
    @Bean
    public JedisPoolConfig poolConfig() {
        // 实例化连接池配置
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

        jedisPoolConfig.setMaxIdle(redisProperty.getMaxIdle());
        jedisPoolConfig.setMaxTotal(redisProperty.getMaxTotal());
        jedisPoolConfig.setTestOnBorrow(redisProperty.isTestOnBorrow());
        jedisPoolConfig.setMaxWaitMillis(redisProperty.getMaxWaitMillis());
        return jedisPoolConfig;
    }


    /**
     *   特殊的bean配置  在springboot启动时也会被执行
     *   没有返回值，目的是调用静态注入方法，把当前配置完成的jedisConnectionFactory
     *   赋值给MyCustomCache中的属性
     */
    @Bean
    public void setJCF(){
        // 调用MyCustomCache 静态方法，把jedisConnectionFactory注入进去
        MyCustomCache.setJedisConnectionFactory(jedisConnectionFactory());
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?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.aaa.springboot.dao.DeptDao">
    <!--    开启二级缓存-->
    <cache type="com.aaa.springboot.util.MyCustomCache"></cache>

    <select id="queryInfo" resultType="com.aaa.springboot.entity.DeptEntity">
        select * from tb_dept
        <where>
            <if test="dname!=null and dname!=''">
                and dname like concat("%",#{dname},"%")
            </if>
            <if test="loc!=null and loc!=''">
                and loc like concat("%",#{loc},"%")
            </if>
        </where>
    </select>


    <insert id="addInfo">
        insert into tb_dept(dname,loc) values (#{dname},#{loc})
    </insert>


    <update id="updateInfo">
        update tb_dept set dname=#{dname},loc=#{loc} where dept_no = #{deptNo}
    </update>


    <delete id="delInfo">
        delete from tb_dept where dept_no = #{deptNo}
    </delete>
</mapper>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
package com.aaa.springboot.util;

import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author ：caicai
 * @date ：Created in 2022/8/12 14:18
 * @description：自定义的缓存类 用于调用第三方缓存（我们在这调用的是redis cluster 缓存）
 *              必须要实现 Cache接口
 * @version:
 */
public class MyCustomCache implements Cache {
    // 定义缓存对象的唯一识别  mybatis官网要求必须提供一个接收String参数作为id的构造器
    private String id;

    // 使用在springboot 启动时，加载配置文件
    // 实例化 jedisConnectionFactory 对象，来进行数据存入和获取及删除相关操作
    private static JedisConnectionFactory jedisConnectionFactory;

    // 实例话读写锁对象  多个请求同时对缓存中某一个操作时的策略
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    // 无法使用正常注入，使用该对象 所以使用一个静态方法注入 给当前jedisConnectionFactory对象来赋值
    public static void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory){
        MyCustomCache.jedisConnectionFactory=jedisConnectionFactory;
    }


    /**
     * 提供一个接收有String参数 作为id的构造器（官网要求）
     * @return
     */
    public MyCustomCache(String id) {
        if (null == id){
            throw new RuntimeException("id不能为空，必须传递！！");
        }
        this.id = id;
    }


    /**
     *  获取缓存对象id
     * @return
     */
    @Override
    public String getId() {
        return this.id;
    }

    /**
     * 向redis集群中写入缓存对象
     * @param key
     * @param value
     */
    @Override
    public void putObject(Object key, Object value) {
        // 通过实例化连接redis集群的工厂类  获取一个redis连接  静态属性在非静态方法中可以直接使用  静态属性在类加载时就被放入到所有内存共享区域-方法区  所有对象都是共享
        RedisConnection connection = jedisConnectionFactory.getConnection();

        // 因为存储时存储的时字节数组类型  所以key 和 value 都要经过序列化
        // 使用springboot整合redis提供的序列化方式
        JdkSerializationRedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();

        // 使用该类，序列化 key 和 value  a=1 变为：aserialize =  1serialize
        byte[] serializeKey = jdkSerializationRedisSerializer.serialize(key);
        byte[] serializeValue = jdkSerializationRedisSerializer.serialize(value);

        // 通过RedisConnection 可以执行redis所有命令
        // 在此使用spring类型操作，向集群中存入数据  存入的key 和value都是序列化过的字节数组
        connection.set(serializeKey,serializeValue);

        // 这里面不要手动关闭连接，因为配置的有连接池，连接的使用和关闭由连接池来完成
        // connection.close();

    }

    /**
     *  通过 key 获取缓存对象
     * @param key
     * @return
     */
    @Override
    public Object getObject(Object key) {
        // 通过实例化连接 redis 集群的工厂类 获取一个redis 连接静态属性在非静态方法中可以直接使用  静态属性在类加载时就被放入到所有内存共享区域-方法区  所有对象都是共享
        RedisConnection connection = jedisConnectionFactory.getConnection();

        // 因为存储时存储的是自己数组类型  所以key 和 value 都要经过序列化
        // 使用springboot整合redis提供的序列化方式
        JdkSerializationRedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();

        // 序列化变字节数组   serializekey = a
        byte[] serializeKey = jdkSerializationRedisSerializer.serialize(key);

        //通过序列化的key获取到序列化后的值
        byte[] serializeValue = connection.get(serializeKey);

        // 反序列化后并返回   1serialize --> 1
        return jdkSerializationRedisSerializer.deserialize(serializeValue);
    }


    /**
     *  根据 key 删除缓存对象
     * @param key
     * @return
     */
    @Override
    public Object removeObject(Object key) {
        // 通过实例化连接 redis 集群的工厂类  获取一个redis 连接
        RedisConnection connection = jedisConnectionFactory.getConnection();


        // 使用springboot整合redis提供的序列化方式
        JdkSerializationRedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();

        // 序列 key 变为字节数组
        byte[] serializeKey = jdkSerializationRedisSerializer.serialize(key);

        // 删除时也要使用序列化后的key  这种写法当在大量缓存进行删除时，效率会低    每次都会执行删除
        // connection.del(serializeKey);

        // 设置该 key 失效  0为立马失效  立马失效，就获取不到，等同于删除    底层redis使用惰性删除  定期批量清理失效的key 批量操作，而不是一个一个操纵，提高效率
        return connection.expireAt(serializeKey,0);
    }


    /**
     *   清空所有缓存书库
     */
    @Override
    public void clear() {
        // 通过实例化连接redis集群的工厂类，获取一个redis连接   静态属性在非静态方法中可以直接使用  静态属性在类加载时就被放入到所有内存共享区域-方法区  所有对象都是共享
        RedisConnection connection = jedisConnectionFactory.getConnection();

        // flushDb redis 每个实例对象默认分为16库  清空当前库
        // connection.flushDb();

        // flushAll 清空所有库
        connection.flushAll();
    }

    /**
     *  获取当前缓存中对象数量
     * @return
     */
    @Override
    public int getSize() {
        // 通过实例化连接redis集群的工厂类，获取一个redis连接
        RedisConnection connection = jedisConnectionFactory.getConnection();

        // 使用 dbSize
        Long aLong = connection.dbSize();

        // 转为 int 类型，并返回
        return Integer.valueOf(aLong.toString());
    }

    /**
     *  缓存读写锁  （缓存读写策略）
     * @return
     */
    @Override
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }
}