安装完成Redis，我们就可以操作Redis，实现数据的CRUD了。这需要用到Redis客户端，包括：

  • 命令行客户端
  • 图形化桌面客户端
  • 变成客户端

命令行客户端

Redis安装完成后就自带了命令行客户端：redis-cli

  • 使用如下命令

    redis-cli [options] [commonds]

    其中常见的options有：

    • -h 127.0.0.1：指定要连接的redis节点的IP地址，默认是127.0.0.1
    • -p 6379：指定要连接的redis节点的端口，默认是6379
    • -a 123123：指定redis的访问密码

  • 其中的commands就是Redis的操作命令，例如：

    • ping：与redis服务端做心跳测试，服务端正常会返回pong

  • 不指定，则进入redis-cli的交互控制台

图形化桌面客户端

下载地址：AnotherRedisDesktopManager、RedisDesktopManager

  • 安装完成后就可以使用了

Java客户端

在Redis官网提供了各种语言的客户端，地址：https://redis.io/clients

Java常用客户端

  • Jedis
  • lettuce
  • SpringDataRedis

Jedis

Jedis官网地址：https://github.com/redis/jedis

快速入门

  • 新建Maven工程，引入下面的依赖

    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>3.7.0</version>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>

  • 编写测试类，与Redis建立连接

    private Jedis jedis;

    @BeforeEach
    void setUp() {
      // 获取连接
      jedis = new Jedis("127.0.0.1", 6379);
      // 设置密码
      jedis.auth("123123");
      // 选择库
      jedis.select(0);
    }

  • 操作方法

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

  • 释放资源

    @AfterEach
    void tearDown() {
      if (jedis != null) {
        jedis.close();
      }
    }

Jedis连接池

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

public class JedisConnectionFactory {
    private static final JedisPool jedisPool;

    static {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(8);
        poolConfig.setMaxIdle(8);
        poolConfig.setMinIdle(0);
        poolConfig.setMaxWaitMillis(1000);
				// 创建连接池对象
        jedisPool = new JedisPool(poolConfig,"127.0.0.1", 6379, 1000, "123123");
    }

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

从连接池中获取jedis对象

jedis = new Jedis("127.0.0.1", 6379);
// 改为
jedis = JedisConnectionFactory.getJedis();

SpringDataRedis

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

官网地址：https://spring.io/projects/spring-data-redis

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

SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：

快速入门

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

  • 使用Spring Initializr创建SpringBoot项目，选择以下依赖：

    • Lombok
    • Spring Data Redis

  • 确保引入以下依赖

    <!-- Redis依赖 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- 连接池依赖 -->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
    </dependency>
    <!-- Lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>

  • 编写配置文件

    spring:
      redis:
        host: 127.0.0.1
        port: 6379
        password: 123123
        lettuce:
          pool:
            max-active: 8
            max-idle: 8
            min-idle: 8
            max-wait: 100ms

  • 编写测试类执行测试方法

    @SpringBootTest
    class RedisDemoApplicationTests {

        @Autowired
        private RedisTemplate redisTemplate;

        @Test
        void testString() {
            redisTemplate.opsForValue().set("name", "Google");
            Object name = redisTemplate.opsForValue().get("name");
            System.out.println(name);
        }
    }

RedisSerializer配置

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

得到的结果是这样的：

缺点：

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

解决方案：

  • 配置Reids

    @Configuration
    public class RedisConfig {

        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
            // 1.创建RedisTemplate对象
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            // 2.设置连接工厂
            template.setConnectionFactory(connectionFactory);

            // 3.创建序列化对象
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();

            // 4.设置key和hashKey采用String的序列化方式
            template.setKeySerializer(stringRedisSerializer);
            template.setHashKeySerializer(stringRedisSerializer);

            // 5.设置value和hashValue采用json的序列化方式
            template.setValueSerializer(jsonRedisSerializer);
            template.setHashValueSerializer(jsonRedisSerializer);
            return template;
        }
    }

  • 此时我们已经将RedisTemplate的key设置为String序列化，value设置为Json序列化的方式，再来执行方法测试

  • 由于我们设置的value序列化方式是Json的，因此我们可以直接向redis中插入一个对象

    @Test
    void testSaveUser() {
      redisTemplate.opsForValue().set("user:100", new User("swcode", 21));
      Object name = redisTemplate.opsForValue().get("user:100");
      System.out.println(name);
    }

尽管Json序列化可以满足我们的需求，但是依旧存在一些问题。

如上图所示，为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。

那么我们如何解决这个问题呢？我们可以通过下文的StringRedisTemplate来解决这个问题。

StringRedisTemplate

为了节省内存空间，直接使用String序列化器，只储存String类型的key和value。存储对象时，手动完成对象的序列化和反序列化

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

  • 测试StringReidsTemplate

    @SpringBootTest
    class RedisDemoApplicationTests {
      
        @Autowired
        private StringRedisTemplate stringRedisTemplate;

        ObjectMapper objectMapper = new ObjectMapper();

        @Test
        void testStringSaveObj() throws JsonProcessingException {
            User user = new User("胡歌", 21);
            String json = objectMapper.writeValueAsString(user);
            stringRedisTemplate.opsForValue().set("user:101",json);
            
            // 获取数据
            String jsonUser = stringRedisTemplate.opsForValue().get("user:101");
            User user1 = objectMapper.readValue(jsonUser, User.class);
            System.out.println("user = " + user1);

        }
    }

  • 在图形客户端查看结果

总结

RedisTemplate的两种序列化实践方案，两种方案各有各的优缺点，可以根据实际情况选择使用。

方案一：

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

方案二：

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

快来参与讨论吧~