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  的区别,

原文地址:https://www.cnblogs.com/920913cheng/p/10382743.html

时间: 2024-10-27 04:06:03

redis(Springboot中封装整合redis,java程序如何操作redis的5种基本数据类型)的相关文章

Java Spring mvc 操作 Redis 及 Redis 集群

本文原创,转载请注明:http://www.cnblogs.com/fengzheng/p/5941953.html 关于 Redis 集群搭建可以参考我的另一篇文章 Redis集群搭建与简单使用 Redis 是什么,能做什么 Redis 是一个开源(BSD许可),内存存储的数据结构服务器,可用作数据库,高速缓存和消息队列代理.它支持字符串.哈希表.列表.集合.有序集合,位图,hyperloglogs等数据类型.内置复制.Lua脚本.LRU收回.事务以及不同级别磁盘持久化功能,同时通过Redis

SpringBoot+Mybatis+MybatisPlus整合实现基本的CRUD操作

SpringBoot+Mybatis+MybatisPlus整合实现基本的CRUD操作 1> 数据准备 -- 创建测试表 CREATE TABLE `tb_user` ( `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID', `user_name` varchar(20) NOT NULL COMMENT '用户名', `password` varchar(20) NOT NULL COMMENT '密码', `name` varchar

eclipse写java程序实现连接redis数据库教程

第一步,在windows下载安装配置好redis数据库.这里我就不再概述了.下载jedis-2.4.2.jar,当然最好是下载最新版本的jar包.这个在百度搜索下就出来的.下载后,放在一个文件夹下面,一会会需要到. 第二步.打开eclipse,新建一个java工程.如下图所示: 第三步:在Test这个java工程里面,我们新建一个folder,命名lib,把刚才下载的jedis-2.4.2.jar包放在我们新建的lib的包下面,如下图所示: 第四步,在eclipse中,选中jar包,build

Java使用Jedis操作Redis大全

Java操作Redis需要导入两个jar: commons-pool2-2.4.2.jar jedis-2.1.0.jar package com.chinasofti.test; import java.io.IOException; import java.io.OutputStream; import java.util.HashMap; import java.util.Map; import java.util.logging.Logger; import org.junit.Befo

JAVA 基础 / 第四课:在ECLIPSE中运行第一个 JAVA 程序以及找不到类的问题

2018-03-06 在Eclipse中运行java 程序 步骤 1 : 打开java文件 直接打开在 命令行Hello World 中创建的java 文件:HelloWorld.java 步骤 2 : 运行 点击绿色运行按钮,直接运行 在eclipse中,编译过程自动执行了 步骤 3 : 观察运行结果 一旦运行成功,会在下方出现控制台console界面 如果找不到控制台console窗口,使用如下步骤打开控制台窗口 步骤 4 : 打开控制台窗口 在默认情况下,console窗口是打开的,倘若无

HelloWorld系列(五)- 在Eclipse中运行第一个 java 程序

在Eclipse中运行java 程序 步骤1:打开java文件步骤2:运行步骤3:观察运行结果步骤4:打开控制台窗口步骤5:练习-在eclipse中运行JAVA程序步骤6:答案-在eclipse中运行JAVA程序 步骤 1 : 打开java文件 直接打开在 命令行Hello World 中创建的java 文件 HelloWorld.java 步骤 2 : 运行 点击绿色运行按钮,直接运行 在eclipse中,编译过程自动执行了 步骤 3 : 观察运行结果 一旦运行成功,会在下方出现控制台cons

Java程序猿必会的四种线程池

前言,对于Java程序猿来说,线程池是面试高频题,是我们必须掌握的一个技能,本篇文章主要给大家讲解四种线程池的使用. 线程池简介 线程池的概念: 线程池就是首先创建一些线程,它们的集合称为线程池.使用线程池可以很好地提高性能,线程池在系统启动时即创建大量空闲的线程,程序将一个任务传给线程池,线程池就会启动一条线程来执行这个任务,执行结束以后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,等待执行下一个任务. 线程池的工作机制: 在线程池的编程模式下,任务是提交给整个线程池,而不是直接提交给

cmd中编译和运行java程序

[cmd下编译] 方法一: 1.首先在工程文件夹下面新建一个sourcelist.txt,把所有要编译的java类的绝对路径写进去,每写一个换一行 javac -classpath lib/jxl.jar -sourcepath src @sourcelist.txt -d bin javac -sourcepath src @sourcelist.txt -d class2(没有三方包的情况,我在项目根目录下新建了一个class2文件夹存放编译成功后的.class文件) -d选项就是desti

命令行中编译和运行JAVA程序出现“错误: 找不到或无法加载主类”

初学JAVA,今天在命令行界面中尝试编译和运行Hello.java (文件当前目录.....\src\chapter1) 1 package chapter1; 2 3 public class Hello { 4 public static void main(String[] args){ 5 if(args.length==0) 6 System.out.println("hello!"); 7 else{ 8 for(int i=0;i<args.length;i++)