Redis的使用

pom.xml文件的配置

spring-boot-starter-parent这块配置就是Spring Boot父级依赖，有了这个，当前的项目就是Spring Boot项目了，spring-boot-starter-parent是一个特殊的starter,它用来提供相关的Maven默认依赖，使用它之后，常用的包依赖可以省去version标签。使用父级依赖提供的默认version。

<parent>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-parent -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.8.RELEASE</version>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--springdata 整合 redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>


</project>

注意：

1.先赋值，在设置失效期；

 //先赋值，在设置失效期，因为这两个操作的对象不是同一个。
    redisTemplate.opsForValue().set(key,Value);
    redisTemplate.expire(key,timeout,unit);

比较详细的操作博文
注入以下RedisTemplate

@Autowired
private RedisTemplate<String,String> redisTemplate;

RedisTemplate中定义了对5种数据结构操作

redisTemplate.opsForValue();//操作字符串

redisTemplate.opsForHash();//操作hash

redisTemplate.opsForList();//操作list

redisTemplate.opsForSet();//操作set

redisTemplate.opsForZSet();//操作有序set

StringRedisTemplate与RedisTemplate

• 两者的关系是StringRedisTemplate继承RedisTemplate。

• 两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。

• SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。

StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。

RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。

操作

1、保存和读取Set：

代码示例：

SetOperations<String, String> set = redisTemplate.opsForSet();
		set.add("set1","22");  
		set.add("set1","33");  
		set.add("set1","44");  
		Set<String> resultSet =redisTemplate.opsForSet().members("set1");  
		System.out.println("resultSet:"+resultSet); 

运行结果为：

resultSet:[[set3, set2, set1]]  jedis

2、Hash结构：

1、put(H key, HK hashKey, HV value):这里的
示例代码：

Map<String,String> map=new HashMap<String,String>();  
map.put("key1","value1");  
map.put("key2","value2");  
map.put("key3","value3");  
map.put("key4","value4");  
map.put("key5","value5");  
redisTemplate.opsForHash().putAll("map1",map);  
Map<String,String> resultMap= redisTemplate.opsForHash().entries("map1");  
List<String>reslutMapList=redisTemplate.opsForHash().values("map1");  
Set<String>resultMapSet=redisTemplate.opsForHash().keys("map1");  
String value=(String)redisTemplate.opsForHash().get("map1","key1");  
System.out.println("value:"+value);  
System.out.println("resultMapSet:"+resultMapSet);  
System.out.println("resultMap:"+resultMap);  
System.out.println("resulreslutMapListtMap:"+reslutMapList); 

运行结果为：

value:value1  

resultMapSet:[key1, key2, key5, key3, key4]  

resultMap:{key3=value3, key2=value2, key1=value1, key5=value5, key4=value4}  

resulreslutMapListtMap:[value1, value2, value5, value3, value4]  

 @Autowired
    RedisTemplate<String,String> redisTemplate;

    /**
     * 根据主键ID查询对象
     * @param id
     * @return
     */
    public User selectById(int id){
        //1.先判断Redis中是否存在该KEy，如果存在，从Redis中取出，并返回
        boolean b = redisTemplate.opsForHash().hasKey("user",id+"");

        if(b){
            User u = (User)redisTemplate.opsForHash().get("user",id);
            System.out.println("Redis中查询出对象");
            return  u;
        }else{
            //如果不存在，从数据库中查询，取出赋值Redis，并返回
            User u = new User();
            u.setId(id);
            u.setAge(22);
            u.setName("华锋");
            u.setUsername("root");
            u.setPassword("root");
            System.out.println("从数据库中查询的对象");
            try{
                redisTemplate.opsForHash().put("user",u.getId()+"",u.toString());
            }catch (Exception e){
                e.printStackTrace();
                System.out.println("这里出问题了");
            }
            return u;
        }
    }

问题记录：用了一晚上，也没有解决。后面解决之后补上。

   @Autowired
    RedisTemplate<String,String> redisTemplate;
    /**
     * 根据主键ID查询对象
     * @param id
     * @return
     */
    public User selectById(Integer id){

        HashOperations<String, Integer, User> hashOperations = redisTemplate.opsForHash();
        boolean b=false ;
        //1.先判断Redis中是否存在该KEy，如果存在，从Redis中取出，并返回
        try{
            //这里始终报异常，说类型转换错误，而需要的参数是Object。提示却是说要String类型。
             b = hashOperations.hasKey("user1",id);
        }catch (Exception e){
            e.printStackTrace();
            
        }

3、保存和读取list

示例代码：

List<String> list1=new ArrayList<String>();  
 list1.add("a1");  
list1.add("a2");  
 list1.add("a3");  
 
 List<String> list2=new ArrayList<String>();  
  list2.add("b1");  
 list2.add("b2");  
 list2.add("b3");  
redisTemplate.opsForList().leftPush("listkey1",list1);  
redisTemplate.opsForList().rightPush("listkey2",list2);  
List<String> resultList1=(List<String>)redisTemplate.opsForList().leftPop("listkey1");  
 List<String> resultList2=(List<String>)redisTemplate.opsForList().rightPop("listkey2");  
System.out.println("resultList1:"+resultList1);  
System.out.println("resultList2:"+resultList2);  

运行结果：

resultList1:[a1, a2, a3]  

resultList2:[b1, b2, b3]

这里需要解释一下：不管是leftPush还是rightPush都可以用leftPop或者rightPoP任意一种获取到其中的值，不过就是获取的遍历方向不一样。有学过数据结构的人都知道里面循环链表是可以前后遍历的，就和这里的场景是一样的。如果还有不懂的话可以去看看这部分的源代码，其实就是遍历方向不同，所以效率也不同。所以最好leftPush用leftPoP遍历，rightPush用rightPoP遍历

4、保存和读取String(最常用的)

参考
方法：
1、set(K key, V value)：新增一个字符串类型的值,key是键，value是值。
2、get(Object key)
3、append(K key, String value)：在原有的值基础上新增字符串到末尾。
4、get(K key, long start, long end)：截取key键对应值得字符串，从开始下标位置开始到结束下标的位置(包含结束下标)的字符串。
5、set(K key, V value, long timeout, TimeUnit unit) 设置变量值的过期时间。

截取key键对应值得字符串，从开始下标位置开始到结束下标的位置(包含结束下标)的字符串

@Autowired
private RedisTemplate<String,String> redisTemplate;


    //简单测试
    @Override
    public void getString(String key) {
        System.out.println("缓存正在设置。。。。。。。。。");
        redisTemplate.opsForValue().set("key1","value1");
        redisTemplate.opsForValue().set("key2","value2");
        redisTemplate.opsForValue().set("key3","value3");
        redisTemplate.opsForValue().set("key4","value4");
        System.out.println("缓存已经设置完毕。。。。。。。");
        String result1=redisTemplate.opsForValue().get("key1").toString();
        String result2=redisTemplate.opsForValue().get("key2").toString();
        String result3=redisTemplate.opsForValue().get("key3").toString();
        System.out.println("缓存结果为：result："+result1+"  "+result2+"   "+result3);
    }

    //字符串过期测试
    @Override
    public void setStringExpire() {
        redisTemplate.opsForValue().set("timeOutValue","timeOut",5,TimeUnit.SECONDS);
        String timeOutValue = redisTemplate.opsForValue().get("timeOutValue")+"";
        System.out.println("通过set(K key, V value, long timeout, TimeUnit unit)方法设置过期时间，过期之前获取的数据:"+timeOutValue);
        try {
            Thread.sleep(6*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        timeOutValue = redisTemplate.opsForValue().get("timeOutValue")+"";
        System.out.print(",等待6s过后，获取的值:"+timeOutValue);
    }