Redis学习笔记--002

Redis的JAVA客户端

一、Redis的Java客户端的种类

二、Jedis

Jedis是一个用于连接和与Redis服务器进行交互的Java客户端库。Redis是一个高性能的内存数据存储系统，Jedis允许Java应用程序通过简单的API与Redis进行通信。

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

2.1、使用步骤

1. 获取Jedis连接

//设置主机地址和端口号
Jedis jedis = new Jedis("192.168.74.1xx", 6379);
1
2

2. 给Jedis设置redis密码

// 设置密码认证
jedis.auth("123456");
1
2

3. 操作

HashMap<String,String> map=new HashMap<>();
	map.put("id","1");
	map.put("name","radan");
    jedis.hset("user:1",map);
    System.out.println(jedis.hgetAll("user:1"));
1
2
3
4
5

4. 释放连接

jedis.close();
1

2.2、Jedis连接池

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

JedisConnectionFactory 连接池配置类

public class JedisConnectionFactory {
    private static JedisPool jedisPool = null;
    static {
        // 配置连接池
        JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
        // 最大连接数
        jedisPoolConfig.setMaxIdle(8);
        // 最大空闲连接
        jedisPoolConfig.setMaxIdle(8);
        // 最小空闲连接
        jedisPoolConfig.setMinIdle(0);
        // 设置最长等待时间   ms
        jedisPoolConfig.setMaxWaitMillis(200);
        jedisPool = new JedisPool(jedisPoolConfig,"192.168.74.128",6379);
    }
    // 获取Jedis对象
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
       public static void closeJedis(){
        jedisPool.close();
    }   
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

三、SpringDataRedis

3.1、介绍

Spring Data Redis是Spring框架的一个模块，用于简化在Java应用程序中与Redis数据库进行交互的过程。它提供了高级别的抽象和易于使用的API，使得在Spring应用中使用Redis变得更加容易。

Spring Data Redis的一些关键特点和用途

1. Redis操作抽象化： Spring Data Redis抽象了与Redis数据库的交互，允许你以面向对象的方式操作数据。你可以将Java对象存储在Redis中，而不必担心底层的Redis命令。

2. 注解支持： Spring Data Redis支持注解，使得在Java类中定义Redis数据模型更加方便。你可以使用注解来标记实体类、字段和方法，以指定它们与Redis数据之间的映射关系。

3. 连接池管理： Spring Data Redis集成了连接池管理，确保有效地管理Redis连接。这有助于提高性能和资源利用率。

4. 声明式事务： 你可以使用Spring的声明式事务管理来确保Redis操作的一致性。这使得在多个Redis命令之间进行原子性操作更加容易。

5. 缓存支持： Spring Data Redis还提供了与Spring框架的缓存抽象集成，使得可以轻松地将Redis用作应用程序的缓存存储。

6. 查询支持： 该模块允许你使用Spring表达式语言（SpEL）构建自定义查询，以根据不同的条件检索数据。

7. Pub/Sub支持： Spring Data Redis支持发布/订阅模式，允许你创建消息发布者和订阅者，以便实现实时消息传递。

3.2、RedisTemplate

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

3.3、SpringDataRedis使用步骤

SpringBoot已经提供了对SpringBootDataRedis的支持，使用非常方便：

1. 引入依赖

   
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>
    
        <dependency>
            <groupId>org.apache.commonsgroupId>
            <artifactId>commons-pool2artifactId>
            <version>2.11.1version>
        dependency>
1
2
3
4
5
6
7
8
9
10
11

2. 配置文件

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

3. 注入RedisTemplate

   @Autowired
    private RedisTemplate redisTemplate;
1
2

4. 测试

    void test001(){
        //  插入一条数据
        redisTemplate.opsForValue().set("name","李四");
        //  读取一条数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name="+name);
    }
1
2
3
4
5
6
7

解决方法：

3.4、SpringDataRedis的序列化方式

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

1. 引入依赖

       <dependency>
          <groupId>com.fasterxml.jackson.coregroupId>
          <artifactId>jackson-databindartifactId>
       dependency>
1
2
3
4

2. 编写配置类

要求RedisTemplate对象的键使用String类型，值使用Object对象类型

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory){
        //  创建RedisTemplate对象
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
        //  设置连接工厂
        redisTemplate.setConnectionFactory(connectionFactory);
        // 创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //  设置Key的序列化
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        //  设置Value的序列化
        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

3. 测试结果

    @Test
    void test002(){
        //  插入一条数据
        redisTemplate.opsForValue().set("user:20",new User("张三",28));
        //  读取一条数据
        Object name = redisTemplate.opsForValue().get("user:20");
        System.out.println("name="+name);
    }
1
2
3
4
5
6
7
8

这样也有缺点：为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入redis，会带来额外的开销。

四、StringRedisTemplate

解决：JSON序列化器会将类的class类型写入json结果中，存入redis，会带来额外的开销这一问题

4.1、解决方法

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

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

4.2、ObjectMapper介绍

是Java编程语言中常用的库，用于将Java对象与JSON（JavaScript对象表示法）数据之间进行转换。它是Jackson库的一部分，提供了一套用于在Java中处理JSON的数据处理工具。

ObjectMapper主要使用方法：

// 将Java对象序列化为JSON字符串
  String jsonString = objectMapper.writeValueAsString(person);
// 将JSON字符串反序列化为Java对象
  Person deserializedPerson = objectMapper.readValue(jsonString, 需要待转的对象类.class);
1
2
3
4

4.3、StringRedisTemplate类

StringRedisTemplate类的使用：

@SpringBootTest
public class RedisString {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    //引入ObjectMapperJSON处理类
    private static final ObjectMapper objectMapper = new ObjectMapper();
    @Test
    void  testString() throws JsonProcessingException {
        User user = new User("李四", 14);
        // 1.存数据
        // 将User对象转换为Json数据
        String jsonString  = objectMapper.writeValueAsString(user);
        System.out.println(jsonString);  // {"username":"李四","age":14}
        stringRedisTemplate.opsForValue().set("name",jsonString);
        // 2.取数据
        String name = stringRedisTemplate.opsForValue().get("name");
        System.out.println(name);   // {"username":"李四","age":14}
        //  将JSON数据转为对象格式
        User user1 = objectMapper.readValue(name, User.class);
        System.out.println(user1);  //   User(username=李四, age=14)

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

之前的问题得到了解决：

五、其它结构的使用

Hash结构的使用：使用基本没有太大差别，更多的是偏向Java代码的这种分格

代码：

  @Test
    void test002(){
        //  存数据
        stringRedisTemplate.opsForHash().put("user:23","name","小王");
        stringRedisTemplate.opsForHash().put("user:23","age","6");
        // 取一个字段
        Object name = stringRedisTemplate.opsForHash().get("user:23", "name");
        System.out.println(name);
        // 取所有的字段
        Map<Object, Object> objectMap = stringRedisTemplate.opsForHash().entries("user:23");
        System.out.println(objectMap);
    }
1
2
3
4
5
6
7
8
9
10
11
12

测试：