SpringRedisData操作

创建项目


application.yml配置文件 我们连接池使用的是lettuce。

Jedis是直连模式，在多个线程间共享一个Jedis实例时是线程不安全的，可以通过创建多个Jedis实例来解决，但当连接数量增多时，物理连接成本就较高同时会影响性能，因此较好的解决方法是使用JedisPool。

Lettuce的连接是基于Netty的，连接实例可以在多个线程间共享，Netty可以使多线程的应用使用同一个连接实例，而不用担心并发线程的数量。通过异步的方式可以让我们更好地利用系统资源。

spring:
  redis:
    host: 192.168.26.146
    port: 6380
    password: root
    database: 0
    timeout: 10000ms

    lettuce:
      pool:
        max-active: 1024
        max-wait: 10000ms
        max-idle: 200
        min-idle: 5

导入的依赖

<dependencies>
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

使用的RedisTemplate《String ,String》与StringRedisTemplate的作用都是解决字符乱码的问题

 @Autowired
    private RedisTemplate<String,String> redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    @Test
    void contextLoads() {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("age","18");

        ValueOperations<String, String> stringStringValueOperations = stringRedisTemplate.opsForValue();
        stringStringValueOperations.set("name","阿威");
        System.out.println(stringStringValueOperations.get("name"));
    }

  

对象序列化，我们这里单独写一个配置文件 但是我这里出现了一些错误 还没有排查清楚

@Configuration
public class RedisConfig {
  @Bean
    public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory){
        System.out.println("----------------");
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //为string类型设置key序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //为string类型设置value序列化
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        //hash类型的key设置序列化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

        //设置连接工厂
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        return redisTemplate;
    }
    }

实体类

package com.aw.pojo;

import java.io.Serializable;

public class User implements Serializable {

    private Integer id;
    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

现在我们就可以传入实体对象

  @Test
    void testSerial(){
        User user = new User();
        user.setId(1);
        user.setName("阿威");
        user.setAge(18);

        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("user10",user);

        User user1 = (User) valueOperations.get("user");
        System.out.println(user1);
        }

对几种数据类型的操作

     @Test
    public void testString(){
        //string基本数据类型存储
        ValueOperations valueOperations = redisTemplate.opsForValue();
            valueOperations.set("name","aw");

            //层级关系
            valueOperations.set("com:aw","aw");


            //存储多个string hash
            Map<String, String> objectObjectHashMap = new HashMap<>();
                objectObjectHashMap.put("name","aw");
                objectObjectHashMap.put("age","18");
                objectObjectHashMap.put("sex","1");
                valueOperations.multiSet(objectObjectHashMap);
            //获取多个数据
            ArrayList<String> list = new ArrayList<>();
                list.add("name");
                list.add("age");
                list.add("sex");

            List list1 = valueOperations.multiGet(list);
            list1.forEach(System.out::println);
        }


    @Test //hash
    public void testHash(){
        HashOperations hashOperations = redisTemplate.opsForHash();
        //添加一条数据 redis的key hash的key hash的value
        hashOperations.put("students","name","zhangsan");
        //获取一条数据
        hashOperations.get("students","name");


        //存储多个数据
        Map<java.lang.String, java.lang.String> objectObjectHashMap = new HashMap<>();
        objectObjectHashMap.put("name","aw");
        objectObjectHashMap.put("age","18");
        objectObjectHashMap.put("sex","1");
        hashOperations.putAll("user",objectObjectHashMap);
        //获取多个数据
        ArrayList<String> list = new ArrayList<>();
        list.add("name");
        list.add("age");
        list.add("sex");
        List<String> user = hashOperations.multiGet("user", list);
        user.forEach(System.out::println);

        //获取hash类型的所有数据
        Map<String,String> user1 = hashOperations.entries("user");
        user1.entrySet().forEach(e->{
            System.out.println(e.getKey()+"----"+e.getValue());
        });
    }

    @Test
    public void testList(){
        ListOperations<String, String> listOperations = redisTemplate.opsForList();
        //添加单个数据
//        listOperations.leftPush("students","zhangsan");
//        listOperations.leftPush("students","lisi");
//        listOperations.rightPush("students","xiaoming");
//        listOperations.rightPush("students","wangwu");
        //添加多条数据
        listOperations.leftPushAll("students","xiaoming","lisi");
        listOperations.rightPushAll("students","zhangsan","wangwu");
        //查询
        List<String> student = listOperations.range("students", 0, 4);
        student.forEach(System.out::println);

        //查询数据量
        System.out.println(listOperations.size("students"));

        //删除
        listOperations.remove("students",1,"xiaoming");
        //左弹出
        System.out.println(listOperations.leftPop("students"));
        //有弹出
        System.out.println(listOperations.rightPop("students"));

    }

    @Test//Set
    public void testSet(){

        SetOperations<String, String> setOperations = redisTemplate.opsForSet();
        String [] str={"aas","saa","ssfa"};
//        setOperations.add("letter","aas","sas","asa");
        //添加数据
        setOperations.add("letter",str);
        //获取数据
        Set<String> letter = setOperations.members("letter");
        letter.forEach(System.out::println);
        //删除数据
            setOperations.remove("letter","aas","saa");
    }
    @Test//有序set
    public void testSortedSet(){
        ZSetOperations<String, String> zSetOperations = redisTemplate.opsForZSet();
        //添加数据
        DefaultTypedTuple<Object> objectDefaultTypedTuple1 = new DefaultTypedTuple<Object>("zhangsan",7D);
        DefaultTypedTuple<Object> objectDefaultTypedTuple2 = new DefaultTypedTuple<Object>("lisi",5D);
        DefaultTypedTuple<Object> objectDefaultTypedTuple3 = new DefaultTypedTuple<Object>("xiaoming",2D);
        DefaultTypedTuple<Object> objectDefaultTypedTuple4 = new DefaultTypedTuple<Object>("wangwu",3D);
        DefaultTypedTuple<Object> objectDefaultTypedTuple5 = new DefaultTypedTuple<Object>("aw",1D);

        Set<ZSetOperations.TypedTuple<Object>> hashSet = new HashSet<ZSetOperations.TypedTuple<Object>>();
        hashSet.add(objectDefaultTypedTuple1);
        hashSet.add(objectDefaultTypedTuple2);
        hashSet.add(objectDefaultTypedTuple3);
        hashSet.add(objectDefaultTypedTuple4);
        hashSet.add(objectDefaultTypedTuple5);

//        zSetOperations.add("score",hashSet);
//        redisTemplate.opsForZSet().add("as",hashSet);
        zSetOperations.add("score","zhangsan",1D);
        zSetOperations.add("score","lisi",4D);
        zSetOperations.add("score","王五",6D);
        zSetOperations.add("score","xiaoming",2D);
        zSetOperations.add("score","aw",3D);

        Set<String> score = zSetOperations.range("score", 1, 4);
        score.forEach(System.out::println);

        System.out.println(zSetOperations.size("score"));

        zSetOperations.remove("score","zhangsan");
    }

    @Test//查询所有的keys
    public void testKeys(){
        Set<String> keys = redisTemplate.keys("*");
        keys.forEach(System.out::println);
    }

    @Test//设置有效时间
    public void testExpire(){
        ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
        //设置有效时间
        valueOperations.set("code","as",30, TimeUnit.SECONDS);

        //给已经存在属性添加有效书简
//        valueOperations.set("name",30, TimeUnit.SECONDS);
      //查看有效时间
        Long code = redisTemplate.getExpire("code");
        System.out.println(code);
    }

哨兵但是我的还是不行
我们还是现在配置文件中添加bean配置

 @Bean
    public RedisSentinelConfiguration redisSentinelConfiguration(){
     System.out.println("---------------");
     RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration()
             .master("master")
             .sentinel("192.168.26.146",26379)
             .sentinel("192.168.26.146",26380)
             .sentinel("192.168.26.146",26381);
     //密码
     redisSentinelConfiguration.setPassword("root");
     return redisSentinelConfiguration;
 }

在application中添加

  sentinel:
      master: master
      nodes: 192.168.26.164:26379,192.168.26.164:26380,192.168.26.164:26381