Redis客户端RedisTemplate入门学习

Redis的Java客户端

Jedis客户端入门

1.引入依赖

<dependency>
            <groupId>redis.clientsgroupId>
            <artifactId>jedisartifactId>
            <version>3.7.0version>
        dependency>
1
2
3
4
5

2.建立连接并操作

//建立连接
    @BeforeEach
    void setUp() {

        //建立连接
        jedis = new Jedis("ip", 6379);
        //设置密码
        jedis.auth("redhat");
        //选择库
        jedis.select(0);
    }

    //测试string
    @Test
   public void testString() {
        //插入数据，方法名称就是redis命令名称，非常简单
        String result = jedis.set("name", "张三");
        System.out.println("result"+result);
        //获取数据
        String name=jedis.get("name");
        System.out.println("name = "+name);
    }

    @Test
    public void testHash(){
        //插入hash
        jedis.hset("zzx","age","18");
        jedis.hset("zzx","name","zzx");
        Map<String, String> map = jedis.hgetAll("zzx");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println("k:"+entry.getKey()+"   "+"v:"+entry.getValue());
        }
    }
    //释放资源
    @AfterEach
    void tearDown(){
        //释放资源
        if (jedis!=null){
            jedis.close();
        }
    }
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

Jedis连接池

jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大家使用Jedis连接池代替Jedis的直连方式。

连接对象工厂池

public class JedisConnectionFactory {
    private static final JedisPool jedisPool;

    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大连接数
        jedisPoolConfig.setMaxTotal(8);
        //最大空闲连接
        jedisPoolConfig.setMaxIdle(8);
        //最小空闲连接
        jedisPoolConfig.setMinIdle(0);
        //设置最长等待时间，ms
        jedisPoolConfig.setMaxWaitMillis(200);
        jedisPool =new JedisPool(jedisPoolConfig,"ip",6379,1000,"redhat");
    }
    //获取Jedis连接对象
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

SpringDataRedis介绍

SpringData是spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis。

• 提供了对不同Redis客户端的整合（Lettuce和Jedis）
• 提供了RedisTemplate统一API来操作Redis
• 支持Redis的发布订阅模式
• 支持Redis哨兵和Redis集群
• 支持基于Lettuce的响应式编程
• 支持基于JDK，JSON，字符串，Spring对象的数据序列化及反序列化
• 支持基于Redis的JDKCollection实现

RedisTemplate工具类中的api：

SpringDataRedis快速入门

SpringBoot已经提供了对SpringDataRedis的支持，使用非常简单

1.引入依赖

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>

        
        <dependency>
            <groupId>org.apache.commonsgroupId>
            <artifactId>commons-pool2artifactId>
        dependency>
1
2
3
4
5
6
7
8
9
10
11

2.配置文件

spring:
  redis:
    host: ip
    port: 6379
    password: redhat
    lettuce:
      pool:
        max-active: 8 #最大连接数
        max-idle: 8 #最大空闲连接
        min-idle: 0 #最小空闲连接
        max-wait: 100 #连接等待时间
1
2
3
4
5
6
7
8
9
10
11

SpringDataRedis的序列化方式

RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的：

缺点：

• 可读性差
• 内存占用较大

改变RedisTemplate的序列化方式

key一般用StringRedisSerializer

value一般用GenericJackson2JsonRedisSerializer

修改序列化方式

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        //创建Template
        RedisTemplate<String,Object> redisTemplate =new RedisTemplate<>();
        //设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer=new GenericJackson2JsonRedisSerializer();

        //key和hashKey采用String序列化
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());

        //value和hashValue采用JSON序列化
        redisTemplate.setValueSerializer(jsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jsonRedisSerializer);

        return redisTemplate;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

StringRedisTemplate

在之前使用jsonRedisSerializer序列化器时产生的@class这个字段会造成资源浪费，为了节省内存空间，我们并不会使用JSON序列化器来处理Value，而是统一使用String序列化器，要求只能存储String的key和Value。当需要存储Java对象时手动完成对象的序列化和反序列化。

StringRedisTemplate的作用

由于StringRedisTemplate的key和value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程：

总结RedisTemplate的两种序列化实践方案：

方案一：

1. 自定义RedisTemplate
2. 修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer

方案二：

1. 使用StringRedisTemplate
2. 写入Redis时，手动把对象序列化为JSON
3. 读写Redis时，手动把读取到的JSON反序列化为对象

Redistemplate操作Hash类型

import com.alibaba.fastjson.JSON;
import com.cdcas.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.Map;

@SpringBootTest
class RedisDemoApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void contextLoads() {
        //插入一条String类型数据
        redisTemplate.opsForValue().set("name","李四");
        //读取一条String类型数据
        Object name =redisTemplate.opsForValue().get("name");
        System.out.println("name = "+name);
    }
    @Test
    void testSaveUser(){
        //写入数据
        redisTemplate.opsForValue().set("user:100",new User("赵志鑫",21));
        //获取数据
        User user=(User) redisTemplate.opsForValue().get("user:100");
        System.out.println(user);
    }
    @Test
    void testStringTemplate(){
        //准备对象
        User user=new User("虎牙",18);
        //手动序列化
        String userJson= JSON.toJSONString(user);
        //写入json数据
        System.out.println(user);
        stringRedisTemplate.opsForValue().set("user",userJson);
        //获取json数据
        String userFromRedis = stringRedisTemplate.opsForValue().get("user");
        User parseObject = JSON.parseObject(userFromRedis, User.class);
        System.out.println("=============================");
        System.out.println("从redis中获取的对象"+parseObject);
    }
    @Test
    void testHash(){
        stringRedisTemplate.opsForHash().put("cdcas:user:100","name","赵志鑫");
        stringRedisTemplate.opsForHash().put("cdcas:user:100","forMe","哈哈");
        Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("cdcas:user:100");
        System.out.println("entries ="+entries);
    }
}

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