Java项目中使用Redis——Jedis_java jedis

1. Jedis

Jedis 是 Redis 官方推荐的 Java 连接开发工具。

2. 添加 Jedis 依赖

在 Java 项目添加 Jedis 的 maven 依赖 ，导入相应的 jar 包即可使用。

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>
1
2
3
4
5

3. 使用 Jedis 连接 Redis

使用 Jedis 连接 Redis，在 Jedis 的构造方法传入 Redis 的 host 和端口号，如果 Redis 有密码的话，再设置 Jedis 的 auth 参数即可。

void connectRedisTest(){
        Jedis jedis = new Jedis("127.0.0.1", 6375);
        jedis.auth("xxxxxxx");
        System.out.println("Connect redis success!");

        jedis.set("test", "testString");
        System.out.println(jedis.get("test"));

        jedis.hset("player", "name", "kobe");
        jedis.hset("player", "num", "24");
        System.out.println(jedis.hget("player","name"));
        System.out.println(jedis.hgetAll("player"));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

结果

Connect redis success!
testString
kobe
{name=kobe, num=24}
1
2
3
4

4. SpringBoot 整合 Redis

SpringBoot 极大简化了整合 Redis 需要的配置，我们只需要在配置文件（application.yml 或者 application.properities）中配置连接 Redis 的相关参数，就可以使用官方默认提供的 RedisTemplate 类来操作 Redis。但是默认的 RedisTemplate 模板只支持字符串，所以我们需要重新封装 RedisTemplate，设置新的序列化规则，以便我们能够操作 Java 实例对象。

4.1 添加 Maven 依赖

<!-- spring boot redis 缓存引入 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1
2
3
4
5

4.2 application.yml 配置文件

spring:
  redis:
    database: 0 # Redis数据库索引（默认为0）
    sentinel:
      master: iproject-custom-alarm
    hosts: xx.xx.xx.xx:36379,xx.xx.xx.xx:36379,xx.xx.xx.xx:36379 # 哨兵节点
    password: iB4jJ8nL9aJ5fK1nF7iL2iBPLM-21024371aK5lH1 # redis 密码
    sentinelPwd: SYI3BU/lX+7jK0ebsMIpK5Lums+bmUwLH99MeN+ln+y2r9UDRDsiyCRNYlXbCSt2 # 哨兵密码
    # redis 连接池相关参数
    pool:
      maxActive: 50 # 连接池最大连接数
      maxWait: 20 # 连接池最大阻塞等待时间
      maxIdle: 20 # 连接池中的最大空闲连接
      minIdle: 5 # 连接池中的最小空闲连接
      minEvictableIdleTimeMillis: 60000
    timeout: 3000
    enable: 1 # 开关，是否启用redis功能
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.3 解析 host 和 port

配置文件中 hosts 可能配置了多个节点，需要从中解析出每个节点的 host 和 port，这里写了一个工具类。

package com.zte.rdcloud.iproject.domain.versionplan.alarm.infra.redis.config;

import org.springframework.data.redis.connection.RedisNode;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class RedisAddressUtils {

    public RedisAddressUtils() {
    }

    public static List<RedisNode> splitHosts(String hosts) {
        List<RedisNode> nodes = new ArrayList();
        String[] var2 = StringUtils.commaDelimitedListToStringArray(hosts);
        int var3 = var2.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            String node = var2[var4];

            try {
                String[] parts = StringUtils.split(node, ":");
                Assert.state(Objects.nonNull(parts) && parts.length == 2, "Must be defined as 'host:port'");
                nodes.add(new RedisNode(parts[0], Integer.valueOf(parts[1])));
            } catch (RuntimeException var7) {
                throw new IllegalStateException("Invalid redis property '" + node + "'", var7);
            }
        }

        return 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

4.4 Redis 配置类

在 Redis 配置类中，我们要根据 application.yml 配置文件完成 Jedis 连接池、Redis 连接和 RedisTemplate 序列化的配置。

package com.zte.rdcloud.iproject.domain.versionplan.alarm.infra.redis.config;

import com.zte.rdcloud.wbs.util.RedisUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
@ConditionalOnProperty(name = "msa.redis.enable", havingValue = "1")
public class PlanRedisConfig {

    @Value("${msa.redis.sentinel.master}")
    private String sentinelMaster;

    @Value("${msa.redis.hosts}")
    private String sentinelNodes;

    @Value("${msa.redis.password}")
    private String redisPassword;

    @Value("${msa.redis.sentinelPwd}")
    private String sentinelPassword;

    @Value("${msa.redis.pool.maxActive}")
    private int maxTotal;

    @Value("${msa.redis.pool.maxIdle}")
    private int maxIdle;

    @Value("${msa.redis.pool.minIdle}")
    private int minIdle;

    @Value("${msa.redis.pool.maxWait}")
    private long maxWaitMillis;

    @Value("${msa.redis.pool.minEvictableIdleTimeMillis}")
    private long minEvictableIdleTimeMillis;

    @Value("${msa.redis.timeout}")
    private int timeout;

    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration().master(sentinelMaster);
        sentinelConfig.setSentinelPassword(sentinelPassword);
        sentinelConfig.setSentinels(RedisAddressUtils.splitHosts(sentinelNodes));
        sentinelConfig.setDatabase(0);

        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(sentinelConfig);
        jedisConnectionFactory.setPassword(redisPassword);
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        jedisConnectionFactory.setTimeout(timeout);

        return jedisConnectionFactory;
    }

    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(maxTotal);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxWaitMillis(maxWaitMillis);
        poolConfig.setEvictorShutdownTimeoutMillis(minEvictableIdleTimeMillis);

        return poolConfig;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
        //配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 配置连接工厂
        redisTemplate.setConnectionFactory(factory);
        
        // 使用 StringRedisSerializer 来序列化 redis 的 key
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        
        // 使用 Jackson2JsonRedisSerializer 来序列化 redis 的 value
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        RedisUtils.setRedisTemplate(redisTemplate);
        return redisTemplate;
    }

}
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

至此，我们已经可以使用 RedisTemplate 来操作 Redis，当然我们也可以进一步对 RedisTemplate 进行封装，将 Java 的数据类型和 Redis 的数据结构命令对应，提供对外的统一接口。

4.5 Redis 工具类

下面只是一个简单的例子，可以根据自己项目的需要封装对应的接口。

package com.zte.rdcloud.wbs.util;

import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.Optional;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class RedisUtils {

    @Setter
    private static RedisTemplate<String, Object> redisTemplate;

    /**
     * 为键值设置过期时间，单位秒
     *
     * @param key  键
     * @param time 时间(秒)
     * @return true:成功；false:失败
     */
    public static boolean expire(String key, long time) {
        try {
            if (time > 0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        }catch (Exception e){
            log.error(e.getMessage());
            return false;
        }
    }

    //------------------------------String-----------------------------

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public static boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.error(e.getMessage());
            return false;
        }
    }

    /**
     * 普通缓存放入并设置过期时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public static boolean set(String key, Object value, long time) {
        try {
            if(time > 0){
                redisTemplate.opsForValue().set(key, value, time);
            }else{
                set(key, value);
            }
            return true;
        }catch (Exception e){
            log.error(e.getMessage());
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public static void del(String... key) {
        try {
            if(null != key && key.length > 0){
                if(key.length == 1){
                    redisTemplate.delete(key[0]);
                }else{
                    redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
                }
            }
        }catch(Exception e){
            log.error(e.getMessage());
        }
    }

    /**
     * 普通缓存获取
     *
     * @param key
     * @return
     */
    public static Object get(String key){
        try {
            return null == key ? null : redisTemplate.opsForValue().get(key);
        }catch(Exception e){
            log.error(e.getMessage());
            return null;
        }
    }

    /**
     * 获取旧值，缓存新值
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public static Object getAndSet(String key, Object value) {
        try {
            return redisTemplate.opsForValue().getAndSet(key, value);
        } catch (Exception e) {
            return null;
        }
    }

    //------------------------------Hash-----------------------------

    /**
     * 向一张hash表中放入数据,如果不存在将创建，存在则覆盖
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public static boolean hSet(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        }catch (Exception e){
            log.error(e.getMessage());
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建，存在则覆盖，并设置过期时间
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public static boolean hSet(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if(time > 0){
                expire(key, time);
            }
            return true;
        }catch (Exception e){
            log.error(e.getMessage());
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建，存在则只设置失效时间（不会设置新值）
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public static boolean hSetIfAbsent(String key, String item, Object value, long time) {
        try {
            Boolean result = redisTemplate.opsForHash().putIfAbsent(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return result;
        } catch (Exception e) {
            log.error(e.getMessage());
            return false;
        }
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public static boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以是多个 不能为null
     */
    public static void hDel(String key, Object... item) {
        try {
            redisTemplate.opsForHash().delete(key, item);
        }catch(Exception e){
            log.error("redis failed hdel", e);
        }
    }

    /**
     * 获取指定键对应的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public static Object hGet(String key, String item) {
        try {
            return redisTemplate.opsForHash().get(key, item);
        }catch (Exception e){
            log.error(e.getMessage());
            return null;
        }
    }

}

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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234