• 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  的区别,
  • 相关阅读:
    C语言II|博客园04
    C语言!!!博客作业03
    C语言II博客作业02
    C语言II—作业01
    deppin系统安装electron步骤及问题
    deppin20.2 频繁卡死问题已解决
    那些实用的Nginx规则
    hibernate4升级5带来的一些参数变化
    java 后台获取文件上传的真实扩展名
    eclipse 卡顿的优化办法
  • 原文地址:https://www.cnblogs.com/920913cheng/p/10382743.html
Copyright © 2020-2023  润新知