spring-data整合redis的实例

学自：b站的博主：“一岁就会编程”的在线智能办公系统的教学视频

创建一个Spring Boot项目

依赖可以自己导入或创建时添加上

pom文件里添加依賴

<dependencies>
        <!--spring-Data-redis依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--commons-poll2 对象池依賴-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!--web組件-->
        <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>

 至于建的包，类什么的用图片看吧，写的麻烦

application.properties文件里写入

#Redis服务器地址
spring.redis.host=xxx.xxx.xxx.xxx
#Redis服务器端口
spring.redis.port= 6379
#Redis服务器密码
spring.redis.password= 自己的
#选择哪个库，默认0库
spring.redis.database=1
#选择超时时间
spring.redis.timeout=10000ms
#最大连接数，默认8
spring.redis.lettuce.pool.max-active=1024
#最大连接阻塞等待时间，单位毫秒，默认 -1ms
spring.redis.lettuce.pool.max-wait=10000ms
#最大空闲连接数，默认8
spring.redis.lettuce.pool.max-idle=200
#最小空闲数连接，默认0
spring.redis.lettuce.pool.min-idle=5

#哨兵模式
#这是第一种
#主节点名称
spring.redis.sentinel.master=自己的
#节点
spring.redis.sentinel.nodes=xxx.xxx.xxx.xxx:26379,xxx.xxx.xxx.xxx:26380,xxx.xxx.xxx.xxx:xxxxx

 User.java

public class User implements Serializable {

    private Integer id;
    private String name;
    private int 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 int getAge() {
        return age;
    }

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

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

 RedisConfig.java

@Configuration
public class RedisConfig {

    /*
    * 序列化模板
    * */

    @Bean
    public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory){
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
        //为string类型的key设置序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //为string类型的value设置序列化
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        //为hash类型的key设置序列化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //为hash类型的value设置序列化
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        return redisTemplate;
    }

    //哨兵模式这是第二种
    @Bean
    public RedisSentinelConfiguration redisSentinelConfiguration(){
        RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration()
                .master("mymaster")
                .sentinel("xxx.xxx.xxx.xxx",26379)
                .sentinel("xxx.xxx.xxx.xxx",xxxxx)
                .sentinel("xxx.xxx.xxx.xxx",xxxxx);
        redisSentinelConfiguration.setPassword("自己的密碼");
        return redisSentinelConfiguration;
    }
}

test测试类

@SpringBootTest
public class SpringdataredisApplicationTests {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    /*
    * 测试连接
    * */
    @Test
    void initConn() {
        //ValueOperations ops = redisTemplate.opsForValue();
        //ops.set("name","zhangsan");
        ValueOperations<String,String> stringStringValueOperations = stringRedisTemplate.opsForValue();
        stringStringValueOperations.set("age","28");
        String age = stringStringValueOperations.get("age");
        System.out.println(age);
    }

    /*
    * 测试序列化
    * */
    @Test
    void testSerial(){
        User user = new User();
        user.setId(1);
        user.setName("zhangsan");
        user.setAge(20);
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("user",user);
        Object user1 = ops.get("user");
        System.out.println(user1);
    }

    /*
     * 操作string
     * */
    @Test
    void testString(){
        ValueOperations ops = redisTemplate.opsForValue();
        //添加一条数据
        ops.set("name","zhangsan");
        //获取一条数据
        String name = (String) ops.get("name");
        System.out.println(name);
        //层级关系，目录形式存储数据
        ops.set("user:01","lisi");
        //添加多条数据
        Map<String,String> map = new HashMap<>();
        map.put("age","20");
        map.put("address","sh");
        ops.multiSet(map);

        //添加多条数据
        List<String> keys = new ArrayList<>();
        keys.add("name");
        keys.add("age");
        keys.add("address");
        List list = ops.multiGet(keys);
        list.forEach(System.out::println);
        //删除数据
        redisTemplate.delete("name");
    }

    /*
     * 操作hash
     * */
    @Test
    void testHash(){
        HashOperations hashOperations = redisTemplate.opsForHash();
        /*
        * 添加一条数据
        * 第一个参数：redis的key
        * 第二条参数：hash的key
        * 第三条参数：hash的value
        * */
        hashOperations.put("user","name","zhangsan");
        /*
        * 获取一条数据
        * 第一个参数：redis的key
        * 第二个参数：hash的key
        * */
        hashOperations.get("user","name");
        //添加多条数据
        Map<String,String> map = new HashMap<>();
        map.put("age","20");
        map.put("address","sh");
        hashOperations.putAll("user",map);
        //添加多条数据
        List<String> keys = new ArrayList<>();
        keys.add("name");
        keys.add("age");
        keys.add("address");
        List user = hashOperations.multiGet("user",keys);
        user.forEach(System.out::println);
        //获取hash类型的所有数据
        Map<String,String> entries = hashOperations.entries("user");
        entries.entrySet().forEach(e->{
            System.out.println(e.getKey()+"-->"+e.getValue());
        });
        //hash的删除数据
        hashOperations.delete("user","name","age");
    }

    /*
     * 操作list
     * */
    @Test
    void testList(){
        ListOperations listOperations = redisTemplate.opsForList();
        //左添加
//        listOperations.leftPush("students","wangwu");
//        listOperations.leftPush("students","lisi");
        /*
        * 左添加
        * 第一个参数：redis的key
        * 第二条参数：被左添加的数据
        * 第三条参数：添加的数据，添加到第二个参数的左边
        * */
        listOperations.leftPush("student","wangwu","zhangsan");
        //右添加
//        listOperations.rightPush("students","zhaoliu");
        //获取数据
        List list = listOperations.range("students",0,2);
        list.forEach(System.out::println);
        //获取总条数
        Long size = listOperations.size("students");
        System.out.println(size);
        //删除数据
        listOperations.remove("students",1,"lisi");
        //左弹出
        listOperations.leftPop("students");
        //右弹出
        listOperations.rightPop("students");
    }

    /*
     * 操作set
     * */
    @Test
    void testSet(){
        SetOperations setOperations = redisTemplate.opsForSet();
        //添加数据
        String[] letters = new String[]{"aaa","bbb","ccc","ddd","eee"};
        //setOperations.add("letters","aaa","bbb","ccc","ddd","eee");
        setOperations.add("letters",letters);
        //获取数据`
        Set set = setOperations.members("letters");
        set.forEach(System.out::println);
        //删除数据
        setOperations.remove("letters","aaa","bbb");
    }

    /*
     * 操作 sorted set
     * */
    @Test
    void testSortedSet(){
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
        //
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>("zhangsan",7D);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>("zhangsan",3D);
        ZSetOperations.TypedTuple<Object> objectTypedTuple3 = new DefaultTypedTuple<>("zhangsan",5D);
        ZSetOperations.TypedTuple<Object> objectTypedTuple4 = new DefaultTypedTuple<>("zhangsan",1D);
        ZSetOperations.TypedTuple<Object> objectTypedTuple5 = new DefaultTypedTuple<>("zhangsan",10D);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        tuples.add(objectTypedTuple3);
        tuples.add(objectTypedTuple4);
        tuples.add(objectTypedTuple5);
        zSetOperations.add("scope",tuples);
        //获取数据
        Set set = zSetOperations.range("scope",0,4);
        set.forEach(System.out::println);
        //获取总条数
        Long size = zSetOperations.size("scope");
        System.out.println(size);
        zSetOperations.remove("scope","zhangsan","lisi");
    }

    /*
     * 获取所有key
     * */
    @Test
    void testAllkey(){
        //获取当前数据库所有key
        Set keys = redisTemplate.keys("*");
        keys.forEach(System.out::println);
    }

    /*
     * 失效时间
     * */
    @Test
    void testExpire(){
        ValueOperations ops = redisTemplate.opsForValue();
        //方法一，添加key的时候设置失效时间
        ops.set("code","test",30, TimeUnit.SECONDS);
        //方法二给已经存在的key设置失效时间
        //redisTemplate.expire("address",30,TimeUnit.SECONDS);
        //查看失效时间
        //Long expire = redisTemplate.getExpire("code");
        //System.out.println(expire);
    }
}