redis（Springboot中封装整合redis,java程序如何操作redis的5种基本数据类型）

平常测试redis操作命令，可能用的是cmd窗口 操作redis，记录一下 java程序操作reids，

操作redis的方法 可以用Jedis ，在springboot 提供了两种 方法操作 RedisTemplate 和StringRedisTemplate 两种方法的区别 可参考：https://blog.csdn.net/yifanSJ/article/details/79513179

当然 springboot 中也可以使用Jedis ，本次记录的是 如何使用RedisTemplate 操作reids的5种基本数据类型

1. 在项目的pom文件中导入 操作redis所需要的依赖：

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>2.1.2.RELEASE</version>
           <relativePath /> <!-- lookup parent from repository -->
       </parent>
       <groupId>com.example</groupId>
       <artifactId>springboot-redis</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>springboot-redis</name>
       <description>Demo project for Spring Boot</description>
   
       <properties>
           <java.version>1.8</java.version>
       </properties>
   
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-redis</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
   
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <scope>runtime</scope>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
           <!-- https://mvnrepository.com/artifact/org.apache.directory.studio/org.apache.commons.lang -->
           <dependency>
               <groupId>org.apache.directory.studio</groupId>
               <artifactId>org.apache.commons.lang</artifactId>
               <version>2.6</version>
           </dependency>
           <dependency>
               <groupId>redis.clients</groupId>
               <artifactId>jedis</artifactId>
       <!-- <version>2.9.0</version> -->
           </dependency>
   
       </dependencies>
   
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
   
   </project>

2. 新建RedisTemplateUtil  注入 RedisTemplate 

   package com.example.demo.redisutil;
   
   import java.util.Arrays;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.List;
   import java.util.Map;
   import java.util.Map.Entry;
   import java.util.Set;
   import java.util.concurrent.TimeUnit;
   
   import javax.annotation.Resource;
   
   import org.springframework.data.redis.core.RedisTemplate;
   import org.springframework.stereotype.Component;
   import org.springframework.util.CollectionUtils;
   
   @Component
   public class RedisTemplateUtil {
       @Resource
       private RedisTemplate<String, Object> redisTemplate;

3. 使用RedisTemplate  操作 String类型的数据：
     1,将String类型存入到Redis当中：

   /**
        * redisTemplate操作普通字符串(存值)
        *
        * @param key
        * @param value
        */
       public void redisSetString(String key, String value) {
           redisTemplate.opsForValue().set(key, value);
       }

   2,从redis当中取出String类型的数据：

   /**
        * redisTemplate操作普通字符串 （取值）
        *
        * @param key
        */
       public Object redisGetString(String key) {
           return redisTemplate.opsForValue().get(key);
   
       }

   3.设置reids key的过期时间(原来出现过设置过期时间不起作用，是因为先设置了过期时间 在去存入值到redis )：

       /**
        *
        * 指定缓存失效时间
        *
        * @param key
        *            键
        *
        * @param time
        *            时间(秒)
        *
        * @return
        *
        */
   
       public boolean expire(String key, long time) {
           try {
               if (time > 0) {
                   redisTemplate.expire(key, time, TimeUnit.SECONDS);
               }
               return true;
   
           } catch (Exception e) {
   
               e.printStackTrace();
   
               return false;
   
           }
   
       }

4. 使用RedisTemplate  操作List类型的数据：
    1,将list类型存入到Redis当中：

       /**
        * 将一个list集合存放到redis当中
        *
        * @param key
        */
       public void redisSetList(String key) {
           List<Integer> list = Arrays.asList(9, 2, 3, 4);
           for (Integer integer : list) {
               // 从当前的数据 向右添加
               // redisTemplate.opsForList().rightPush(key, integer);
               // 从当前的数据 向左添加
               redisTemplate.opsForList().leftPush(key, integer);
           }
       }

   2,从redis中取出list数据：

   /**
        * 获取list(获取0 -10 索引的数据)
        *
        * @param key
        * @return
        */
       public Object getList(String key) {
           return redisTemplate.opsForList().range(key, 0, 10);
       }

   3.获取redis中list的长度：

   /**
        * 获取list指定key的长度
        *
        * @param key
        * @return
        */
       public Long getListSize(String key) {
           return redisTemplate.opsForList().size(key);
       }

5. 使用RedisTemplate  操作hash类型的数据：
   1.将hash存放到redis当中：

   /**
        * 将map存放到reids
        *
        * @param key
        */
       public void setHash(String key) {
           Map<String, String> hashMap = new HashMap<>();
           //使用RedisTemplate  有些情况会乱码
           hashMap.put("redis", "redis");
           hashMap.put("mysql", "mysql");
           for (Entry<String, String> keyValue : hashMap.entrySet()) {
               redisTemplate.opsForHash().put(key, keyValue.getKey(), keyValue.getValue());
           }
       }

   2.将hash从redis当中取出来 根据具体的key取出具体的值：

   /**
        * 获取指定key1的值
        *
        * @param key
        * @param key1
        * @return
        */
       public Object getHash(String key, String key1) {
           // 检测 是否 存在该键
           boolean isKey = redisTemplate.opsForHash().hasKey(key, key1);
           return redisTemplate.opsForHash().get(key, key1);
       }

   3.将key中所有的值都取出来：

   /**
        * 获取指定key的所有值
        *
        * @param key
        *
        * @return
        */
       public Object getHash(String key) {
           return redisTemplate.opsForHash().entries(key);
       }

   4.根据具体的key移除具体的值：

   /**
        * 根据具体key移除具体的值
        *
        * @param key
        *
        * @return
        */
       public void removeKey(String key, String key1) {
           redisTemplate.opsForHash().delete(key, key1);
       }

   5.移除key值 则key里面的所有值都被移除：

   public void removeStringKey(String key) {
           redisTemplate.delete(key);
       }

6. 使用RedisTemplate  操作set类型的数据：
   1.set数据存入redis中

       /**
        * set存入redis中
        *
        * @param key
        */
       public void setSet(String key) {
           Set<Object> set = new HashSet<>();
           set.add("setKey");
           set.add("tesetKey");
           for (Object object : set) {
               redisTemplate.opsForSet().add(key, object);
           }
       }

   2.从redis当中将set数据取出来：

   /**
        * 从redis中取出set
        *
        * @param key
        * @return
        */
       public Object getSet(String key) {
           return redisTemplate.opsForSet().members(key);
       }

7. 使用RedisTemplate  操作sortset类型的数据：
   1.将sortSet存放到redis当中：

   /**
        * sortset存入redis中
        *
        * @param key
        */
       public void setZSet(String key) {
           Set<Object> set = new HashSet<>();
           set.add("setKey");
           set.add("tesetKey");
           int i = 0;
           for (Object object : set) {
               i++;
               redisTemplate.opsForZSet().add(key, object, i);
           }
       }

   2.将sortset从redis当中取出来的API有很多：

   /**
        * 从redis中取出sortset
        *
        * @param key
        * @return
        */
       public Object getZSet(String key) {
           Long size = redisTemplate.opsForZSet().size(key);
           return redisTemplate.opsForZSet().rangeByScore(key, 0, size);
       }

8. RedisTemplate操作5种基本类型数据，有一些共同的API 比如设置过期时间，和移除key的值,判断key是否存在
   1设置过期时间

   /**
        *
        * 指定缓存失效时间
        *
        * @param key
        *            键
        *
        * @param time
        *            时间(秒)
        *
        * @return
        *
        */
   
       public boolean expire(String key, long time) {
           try {
               if (time > 0) {
                   redisTemplate.expire(key, time, TimeUnit.SECONDS);
               }
               return true;
   
           } catch (Exception e) {
   
               e.printStackTrace();
   
               return false;
   
           }
   
       }

   2.检测是否存在key

   ：

   /**
        *
        * 判断key是否存在
        *
        * @param key
        *            键
        *
        * @return true 存在 false不存在
        *
        */
   
       public boolean checkKey(String key) {
   
           try {
   
               return redisTemplate.hasKey(key);
   
           } catch (Exception e) {
   
               e.printStackTrace();
   
               return false;
   
           }
   
       }

   3:移除缓存

     /**
        * 移除key
        * @param key
        */
       public void removeKey(String key) {
           redisTemplate.delete(key);
       }

9. 掌握redis，首先得掌握reids如何操作5种基本数据类型，5种基本数据类型中 set和sortset的区别需要特别注意，然后就是关于使用RedisTemplate  可能乱码的问题，以及StringRedisTemplate  的区别，