Redis 基础篇 | SpringBoot 整合篇 |（3）SpringBoot整合redis

在 Java 生态中连接 redis 一般有两种办法，一种是使用 Jedis，另一种则是使用 SpringDataRedis （底层为 lettuce）

以 Jedis 方式连接 redis，是以redis命令作为方法名称，学习成本低，简单实用。但是Jedis实例是线程不安全的，多线程环境下需要基于连接池来使用

一、Jedis 连接 redis

Jedis使用的基本步骤：

1. 引入依赖创建Jedis对象
2. 建立连接使用Jedis
3. 方法名与Redis命令一致
4. 释放资源

1.1 引入依赖创建Jedis对象

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.7.0</version>
</dependency>

1.2 建立连接使用Jedis

private Jedis jedis;

@BeforeEach
void setup(){
    // 1. 建立连接
    jedis = new Jedis("47.97.206.60", 6379);
    // 2. 设置密码
    jedis.auth("123456");
    // 3. 选择库
    jedis.select(0);
}

1.3 测试string

@Test
void testString() {
    String result = this.jedis.set("name", "张三");
    System.out.println("result = " + result);
    // 获取数据
    String name = this.jedis.get("name");
    System.out.println("name = " + name);
}

1.4 释放资源

@AfterEach
void tearDown() {
    // 释放资源
    if (jedis != null) {
        jedis.close();
    }
}

1.5 Jedis连接池

public class JedisConnnectionFactory {
    private static final JedisPool jedisPool;

    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(8);
        jedisPoolConfig.setMaxIdle(8);
        jedisPoolConfig.setMinIdle(0);
        jedisPoolConfig.setMaxWaitMillis(200);
        jedisPool = new JedisPool(jedisPoolConfig, "47.97.206.60", 6379, 1000);
    }

    public static Jedis getJedis() {
        return jedisPool.getResource();
    }
}

private Jedis jedis;

@BeforeEach
void setup(){
    // 1. 建立连接
    jedis = JedisConnnectionFactory.getJedis();
    //        jedis = new Jedis("47.97.206.60", 6379);
    // 2. 设置密码
    jedis.auth("123456");
    // 3. 选择库
    jedis.select(0);
}

二、SpringBoot 连接 redis

2.1 引入spring-boot-starter-data-redis依赖

<!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!-- spring2.X集成redis所需common-pool2-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.11.1</version>
        </dependency>

2.2 在application.yml配置Redis信息

spring:  
  redis:
    host: 47.97.206.60  #Redis服务器地址
    port: 6379  #Redis服务器连接端口
    password: 123321
    database: 0   #Redis数据库索引（默认为0）
    connect-timeout: 18000000   #连接超时时间（毫秒）
    lettuce:
      pool:
        max-active: 20    #连接池最大连接数（使用负值表示没有限制）
        max-wait: -1    #最大阻塞等待时间(负数表示没限制)
        max-idle: 5   #连接池中的最大空闲连接
        min-idle: 0   #连接池中的最小空闲连接

2.3 注入RedisTemplate并测试

@Autowired
    RedisTemplate redisTemplate;
@Test
void testString() {
    redisTemplate.opsForValue().set("name", "李四");
    Object name = redisTemplate.opsForValue().get("name");
    System.out.println("name="+name);
}

2.4 SpringDataRedis的序列化方式

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

方案一：

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

方案二：

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

RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是字节形式，可读性很差，占用内存也大。

我们可以自定义RedisTemplate的序列化方式，代码如下：

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)        throws UnknownHostException {    
    // 创建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;
}

尽管JSON的序列化方式可以满足我们的需求，但依然存在一些问题，为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。

为了节省内存空间，我们并不会使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。

Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程：

@Autowired
private StringRedisTemplate stringRedisTemplate;
// JSON工具
private static final ObjectMapper mapper = new ObjectMapper();
@Test
void testStringTemplate() throws JsonProcessingException {
    // 准备对象
    User user = new User("虎哥", 18);
    // 手动序列化
    String json = mapper.writeValueAsString(user);
    // 写入一条数据到redis
    stringRedisTemplate.opsForValue().set("user:200", json);
    // 读取数据
    String val = stringRedisTemplate.opsForValue().get("user:200");
    // 反序列化
    User user1 = mapper.readValue(val, User.class);
    System.out.println("user1 = " + user1);
}