Redis基础及与springboot整合

早春的树长在理想三旬

已于 2022-03-27 18:41:40 修改

阅读量382

点赞数

分类专栏：再谈java基础数据库文章标签： java redis spring

于 2022-03-27 18:40:05 首次发布

本文链接：https://blog.csdn.net/JohnLeeK/article/details/123778451

版权

数据库同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

再谈java基础

3 篇文章 0 订阅

订阅专栏

安装redis

下载redis，百度就有
上传到centos
linux下安装gcc环境
- yum install gcc

解压redis安装包
- tar -zxvf redis-xxx.xx.tar
编译和安装解压好的redis
- cd /study/redis.6.2…
- make
- make install

redis默认安装在/usr/local/bin目录下

运行Redis

前台启动（不推荐）

在/usr/local/bin下执行

redis-server

在这里插入图片描述

后台启动（推荐）

将解压的redis目录下redis.conf拷贝至/etc/bin下（cp redis.conf /etc/redis.conf），并做修改daemonize no 改成yes
进到/usr/local/bin下，用redis-server /etc/redis.conf启动redis
查看redis进程ps -ef | grep redis

在这里插入图片描述

客户端访问redis

redis-cli

redis关闭

1、redis-cli shutdown
2、也可以在终端中shutdown
3、杀进程，kill 进程编号（5780）

Redis常用数据类型

redis 键（key）相关命令

keys * 查看当前库所有key (匹配：keys *1)

exists key判断某个key是否存在

type key 查看你的key是什么类型

del key 删除指定的key数据

unlink key 根据value选择非阻塞删除,仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。

expire key 10 10秒钟：为给定的key设置过期时间

ttl key 查看还有多少秒过期，-1表示永不过期，-2表示已过期

select命令切换数据库

dbsize查看当前数据库的key的数量

flushdb清空当前库

flushall通杀全部库

redis 字符串 String

简介

String是Redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。

String类型是二进制安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象。

String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M

常用命令

set&&get

set k1 lili #添加一个value为lili的字符串，键为k1，设置相同的key会覆盖之前的value
get k1 #取k1的值

strlen

strlen key返回value的长度

append key value

append <key> <value>追加value

setnx

setnx <key> <value>key存在不创建，不存在才创建

incr && decr

incr <key> decr <key>一个key中value加一，一个是减一

**incrby / decrby <步长>**将 key 中储存的数字值增减。自定义步长。

127.0.0.1:6379> incrby k2 2
(integer) 102
127.0.0.1:6379> decrby k2 10
(integer) 92

mset …

同时设置一个或多个 key-value对

mget …

同时获取一个或多个 value

127.0.0.1:6379> mset k1 v1 k2 v2 k3 100
OK
127.0.0.1:6379> mget k1 k3
1) "v1"
2) "100"

msetnx …

同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。

getrange <起始位置><结束位置>

获得值的范围，类似java中的substring，前包，后包

setrange <起始位置>

用覆写所储存的字符串值，从<起始位置>开始(索引从0****开始)。

127.0.0.1:6379> set k4 lucymarry
OK
127.0.0.1:6379> getrange k4 0 3
"lucy"
127.0.0.1:6379> setrange k4 0 haha
(integer) 9
127.0.0.1:6379> get k4
"hahamarry"
127.0.0.1:6379>

setex <过期时间>

设置键值的同时，设置过期时间，单位秒。

127.0.0.1:6379> setex k5 10 100
OK
127.0.0.1:6379> ttl k5
(integer) -2

getset

以新换旧，设置了新值同时获得旧值

127.0.0.1:6379> set k5 haha
OK
127.0.0.1:6379> getset k5 hello
"haha"
127.0.0.1:6379> get k5
"hello"
127.0.0.1:6379>

redis 列表（list)

单键多值

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差。

常用命令

lpush && rpush

127.0.0.1:6379> lpush k1 v1 v2 v3 v4 #逆序
(integer) 4
127.0.0.1:6379> lrange k1 0 -1
1) "v4"
2) "v3"
3) "v2"
4) "v1"
127.0.0.1:6379> rpush k2 v1 v2 v3 v4 #正序
(integer) 4
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v2"
3) "v3"
4) "v4"

lpop && rpop 从左边/右边吐出一个值,值在键在，值光键亡。

127.0.0.1:6379> lpop k1
"v4"
127.0.0.1:6379> lpop k1
"v3"
127.0.0.1:6379> lpop k1
"v2"
127.0.0.1:6379> lpop k1
"v1"
127.0.0.1:6379> lpop k1
(nil)
127.0.0.1:6379> 

127.0.0.1:6379> rpop k2
"v4"
127.0.0.1:6379> rpop k2
"v3"
127.0.0.1:6379> rpop k2
"v2"
127.0.0.1:6379> rpop k2
"v1"
127.0.0.1:6379> rpop k2
(nil)

lrange

按照索引下标获得元素(从左到右)

rpoplpush 从列表右边吐出一个值，插到列表左边。

127.0.0.1:6379> lpush k1 v1 v2 v3
(integer) 3
127.0.0.1:6379> rpush k2 q1 q2 q3
(integer) 3
127.0.0.1:6379> rpoplpush k1 k2
"v1"
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "q1"
3) "q2"
4) "q3"
127.0.0.1:6379>

lindex 按照索引下标获得元素(从左到右)

127.0.0.1:6379> rpush k1 v1 v2 v3
(integer) 3
127.0.0.1:6379> lrange k1 0 -1
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> lindex k1 0
"v1"
127.0.0.1:6379>

llen 获得列表长度

127.0.0.1:6379> llen k1
(integer) 3
127.0.0.1:6379>

linsert key before/after oldvalue newvalue

127.0.0.1:6379> lrange k1 0 -1
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> linsert k1 before v3 v4
(integer) 4
127.0.0.1:6379> lrange k1 0 -1
1) "v1"
2) "v2"
3) "v4"
4) "v3"

127.0.0.1:6379> linsert k1 after v3 v5
(integer) 5
127.0.0.1:6379> lrange k1 0 -1
1) "v1"
2) "v2"
3) "v4"
4) "v3"
5) "v5"
127.0.0.1:6379>

lrem key n value 从左边删除n个value(从左到右)

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> rpush k1 v1 v2 v1 v3 v4 v1
(integer) 6
127.0.0.1:6379> lrange k1 0 -1
1) "v1"
2) "v2"
3) "v1"
4) "v3"
5) "v4"
6) "v1"
127.0.0.1:6379> lrem k1 2 v1
(integer) 2
127.0.0.1:6379> lrange k1 0 -1
1) "v2"
2) "v3"
3) "v4"
4) "v1"

lset key index value

127.0.0.1:6379> lrange k1 0 -1
1) "v2"
2) "v3"
3) "v4"
4) "v1"
127.0.0.1:6379> lset k1 0 v1
OK
127.0.0.1:6379> lrange k1 0 -1
1) "v1"
2) "v3"
3) "v4"
4) "v1"
127.0.0.1:6379>

redis 集合（set)

Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。

Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是****O(1)。

一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变

常用命令

sadd …

将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略
smembers

取出该集合的所有值。
sismember

判断集合是否为含有该值，有1，没有0
scard

返回该集合的元素个数。

127.0.0.1:6379> sadd k1 v1 v2 v3
(integer) 3
127.0.0.1:6379> smembers k1
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> sismember k1 v1
(integer) 1
127.0.0.1:6379> scard k1
(integer) 3
127.0.0.1:6379>

srem …

删除集合中的某个元素。
spop

随机从该集合中吐出一个值。

127.0.0.1:6379> smembers k1
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> srem k1 v1
(integer) 1
127.0.0.1:6379> smembers k1
1) "v3"
2) "v2"
127.0.0.1:6379> spop k1
"v2"
127.0.0.1:6379> smembers k1
1) "v3"

srandmember

随机从该集合中取出n个值。不会从集合中删除。

127.0.0.1:6379> smembers k1
1) "v3"
2) "v2"
3) "v4"
4) "v1"
127.0.0.1:6379> srandmember k1 2
1) "v2"
2) "v3"
127.0.0.1:6379> srandmember k1 2
1) "v3"
2) "v1"

smove value把集合中一个值从一个集合移动到另一个集合

127.0.0.1:6379> smembers k1
1) "v3"
2) "v2"
3) "v4"
4) "v1"
127.0.0.1:6379> sadd k2 v5 v6
(integer) 2
127.0.0.1:6379> smembers k2
1) "v5"
2) "v6"
127.0.0.1:6379> smove k1 k2 v1
(integer) 1
127.0.0.1:6379> smembers k2
1) "v5"
2) "v1"
3) "v6"
127.0.0.1:6379>

sinter 返回两个集合的交集元素。
sunion 返回两个集合的并集元素。
sdiff 返回两个集合的差集元素(key1中的，不包含key2中的)

127.0.0.1:6379> clear
127.0.0.1:6379> smembers k1
1) "v3"
2) "v2"
3) "v1"
4) "v4"
127.0.0.1:6379> smembers k2
1) "v5"
2) "v1"
3) "v6"
127.0.0.1:6379> sinter k1 k2
1) "v1"
127.0.0.1:6379> sunion k1 k2
1) "v3"
2) "v5"
3) "v1"
4) "v2"
5) "v6"
6) "v4"
127.0.0.1:6379> sdiff k1 k2
1) "v2"
2) "v3"
3) "v4"
127.0.0.1:6379> sdiff k2 k1
1) "v5"
2) "v6"
127.0.0.1:6379>

redis 哈希（Hash）

Redis hash 是一个键值对集合。

Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。

类似Java里面的Map<String,Object>,准确点应该是Map<String,Map<filed,value>>

常用命令

hset 给集合中的键赋值
hget 从集合取出 value

127.0.0.1:6379> hset user:1001 id 1
(integer) 1
127.0.0.1:6379> hset user:1001 name zhangsan
(integer) 1
127.0.0.1:6379> hget user:1001 id
"1"
127.0.0.1:6379> hget user:1001 name
"zhangsan"
127.0.0.1:6379>

hmset … 批量设置hash的值

127.0.0.1:6379> hmset user2:1002 id 1 name lisi sex 1 hight 180
OK
127.0.0.1:6379> hget user2:1002 id
"1"
127.0.0.1:6379> hget user2:1002 sex
"1"
127.0.0.1:6379>

hexists查看哈希表 key 中，给定域 field 是否存在。

127.0.0.1:6379> hexists user2:1002 id
(integer) 1

hkeys 列出该hash集合的所有field

127.0.0.1:6379> hkeys user2:1002
1) "id"
2) "name"
3) "sex"
4) "hight"
127.0.0.1:6379>

hvals 列出该hash集合的所有value

127.0.0.1:6379> hvals user2:1002
1) "1"
2) "lisi"
3) "1"
4) "180"
127.0.0.1:6379>

hincrby 为哈希表 key 中的域 field 的值加上增量 1 -1

127.0.0.1:6379> hincrby user2:1002 id 2
(integer) 3
127.0.0.1:6379> hget user2:1002 id
"3"
127.0.0.1:6379>

hsetnx 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在

127.0.0.1:6379> hsetnx user2:1002 age 40
(integer) 1
127.0.0.1:6379> hkeys user2:1002
1) "id"
2) "name"
3) "sex"
4) "hight"
5) "age"
127.0.0.1:6379>

redis 有序集合 (Zset)

Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。

不同之处是有序集合的每个成员都关联了一个评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但是评分可以是重复了。

因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。

访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。

常用命令

zadd …

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
zrange [WITHSCORES]

返回有序集 key 中，下标在之间的元素

127.0.0.1:6379> clear
127.0.0.1:6379> zadd topn 200 java 300 c++ 400 mysql 500 php
(integer) 4
127.0.0.1:6379> zadd k1 200 java 300 c++ 400 mysql 500 php
(integer) 4
127.0.0.1:6379> zrange k1  0 -1
1) "java"
2) "c++"
3) "mysql"
4) "php"
127.0.0.1:6379> zrange k1  0 -1 withscores
1) "java"
2) "200"
3) "c++"
4) "300"
5) "mysql"
6) "400"
7) "php"
8) "500"
127.0.0.1:6379>

zrangebysore key min max

127.0.0.1:6379> zrangebyscore k1 200 500
1) "java"
2) "c++"
3) "mysql"
4) "php"
127.0.0.1:6379> zrangebyscore k1 200 500 withscores
1) "java"
2) "200"
3) "c++"
4) "300"
5) "mysql"
6) "400"
7) "php"
8) "500"
127.0.0.1:6379>

zrevrangebyscore key max min

127.0.0.1:6379> zrevrangebyscore k1 500 200
1) "php"
2) "mysql"
3) "c++"
4) "java"
127.0.0.1:6379>

zincrby key increment value

127.0.0.1:6379> zrevrangebyscore k1 500 200
1) "php"
2) "mysql"
3) "c++"
4) "java"
127.0.0.1:6379> zincrby k1 600 java
"800"
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "c++"
2) "300"
3) "mysql"
4) "400"
5) "php"
6) "500"
7) "java"
8) "800"
127.0.0.1:6379>

zrem

删除该集合下，指定值的元素

zcount

统计该集合，分数区间内的元素个数

zrank

返回该值在集合中的排名，从0开始。

127.0.0.1:6379> zrange k1 0 -1 withscores
1) "c++"
2) "300"
3) "mysql"
4) "400"
5) "php"
6) "500"
7) "java"
8) "800"
127.0.0.1:6379> zrem k1 c++
(integer) 1
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "mysql"
2) "400"
3) "php"
4) "500"
5) "java"
6) "800"
127.0.0.1:6379> zcount k1 0 -1
(integer) 0
127.0.0.1:6379> zcount k1 400 800
(integer) 3
127.0.0.1:6379> zrank k1 java
(integer) 2
127.0.0.1:6379>

Maven工程整合Redis、

禁用Linux的防火墙：Linux(CentOS7)里执行命令

systemctl stop firewalld.service
systemctl disable firewalld.service

创建maven工程添加依赖

<?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>

    <groupId>com.lyq</groupId>
    <artifactId>JedisDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>

    </dependencies>

</project>

创建测试类

public class TestJedis {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.19.129",6379);
        String ping = jedis.ping();
        System.out.println(ping);//----> pong
        jedis.close();
    }
}

SpringBoot整合Redis

注意事项

Spring Boot Data(数据) Redis 中提供了RedisTemplate和StringRedisTemplate，其中StringRedisTemplate是RedisTemplate的子类，两个方法基本一致，不同之处主要体现在操作的数据类型不同，RedisTemplate中的两个泛型都是Object，意味着存储的key和value都可以是一个对象，而StringRedisTemplate的两个泛型都是String；意味着StringRedisTemplate的key和value都只能是字符串。
RedisTemplate (object,object)；自动序列化自动反序列化，对象必须实现序列化接口，Serialize
StringRedisTemplate (String,String)

创建工程

创建springboot工程添加依赖（这里springboot版本为2.1.1.RELEASE）
pom.xml

<?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 https://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.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>spredisdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spredisdemo</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-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.0</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件

spring:
  redis:
    host: 192.168.19.129
    port: 6379
    database: 0
    timeout: 1800000
    lettuce:
      pool:
        max-active: 20
        max-wait: -1
        max-idle: 5
        min-idle: 0

配置类

创建redis配置类

package com.example.spredisdemo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
//key序列化方式
        template.setKeySerializer(redisSerializer);
//value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

测试controller

测试类

@RestController
public class Test {
    @Autowired
    private RedisTemplate redisTemplate;
    @RequestMapping("/redis")
    public String redis(){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("springboot","redis");
        Object result = valueOperations.get("springboot");

        return result.toString();
    }
}

单元测试

StringRedisTemplate

@SpringBootTest(classes = SpredisdemoApplication.class)
@RunWith(SpringRunner.class)
public class RedisTest {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    @Test
    public void stringRedis(){
//        String str1 = stringRedisTemplate.opsForValue().get("str1");
        stringRedisTemplate.opsForValue().set("name11","ceshi", 120, TimeUnit.SECONDS);
        String name11 = stringRedisTemplate.opsForValue().get("name11");
        System.out.println(name11);
    }
    @Test
    public void listRedis(){
        ListOperations<String, String> operation = stringRedisTemplate.opsForList();
        List<String> names = new ArrayList<>();
        names.add("lisi");
        names.add("zhangsan");
        operation.leftPushAll("names",names);
        operation.leftPushAll("k1","v1","v2","v3");

        List<String> namesList = operation.range("names", 0L, -1L);
        namesList.stream().forEach(System.out::println);
    }

    @Test
    public void setRedis(){
        SetOperations<String, String> operations = stringRedisTemplate.opsForSet();
//        operations.add("names","zhangsan","lisi","wangwu");
        Set<String> names = operations.members("names");
        System.out.println(operations.size("names"));
//        operations.intersect()
        names.stream().forEach(System.out::println);
    }

    @Test
    public void hashRedis(){
        HashOperations<String, Object, Object> operations = stringRedisTemplate.opsForHash();
//        operations.put("user","id","1");
//        operations.put("user","name","haha");
//        operations.put("user","age","18");
        Map<String,String> user2 = new HashMap<>();
        user2.put("id","12");
        user2.put("name","ceshi");
        user2.put("age","18");
        operations.putAll("user2",user2);
        System.out.println(operations.get("user2","id"));
        System.out.println(operations.get("user2","name"));
        System.out.println(operations.get("user2","age"));
    }

    @Test
    public void zsetRedis(){
        ZSetOperations<String, String> operations = stringRedisTemplate.opsForZSet();
//        operations.add("score","java",100);
//        operations.add("score","c",200);
//        operations.add("score","php",300);
//        Set<String> score = operations.range("score", 0, -1);
//        score.forEach(System.out::println);
        Set<ZSetOperations.TypedTuple<String>> score = operations.rangeByScoreWithScores("score", 100, 300);
        score.forEach(stringTypedTuple -> System.out.println(stringTypedTuple.getValue() + stringTypedTuple.getScore()));
    }
}

RedisTemplate

首先注意RedisTemplate<K, V>k,v均为对象，但是一般操作时更希望key为string类型，而v为objec，所以要改变key的序列化方式，RedisTemplate默认采用

JdkSerializationRedisSerializer，对key序列化用StringRedisSerializer。

package redistest;

import com.example.spredisdemo.SpredisdemoApplication;
import com.example.spredisdemo.dao.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Date;
import java.util.List;
import java.util.function.Consumer;

@SpringBootTest(classes = SpredisdemoApplication.class)
@RunWith(SpringRunner.class)
public class RedisTmpTest {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void stringRedis() {
        User user = new User();
        user.setAge(18);
        user.setBir(new Date());
        user.setId("123");
        user.setName("zhangsan");
//        redisTemplate.opsForValue().get();
        //修改key的序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        ValueOperations op = redisTemplate.opsForValue();
        op.set("user",user);
        User user1 = (User) op.get("user");
        System.out.println(user1.getAge());
    }

    @Test
    public void listRedis() {
        User user = new User();
        user.setAge(18);
        user.setBir(new Date());
        user.setId("123");
        user.setName("zhangsan");
//        redisTemplate.opsForValue().get();
        //修改key的序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        ListOperations listOperations = redisTemplate.opsForList();
//        listOperations.leftPushAll("user",user);

        List<User> list = listOperations.range("user", 0, -1);
        list.stream().forEach(new Consumer<User>() {
            @Override
            public void accept(User user) {
                System.out.println(user.getAge());
            }
        });
    }
}

bound操作

bound操作主要是针对频繁使用的key而言，能简化代码量

    @Test
    public void boundReids(){
        BoundValueOperations<String, String> ops = stringRedisTemplate.boundValueOps("user");
        ops.set("v1");
        ops.append("v2");
        System.out.println(ops.get());

    }

早春的树长在理想三旬

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redis基础及与springboot整合

安装redis下载redis，百度就有上传到centoslinux下安装gcc环境yum install gcc解压redis安装包tar -zxvf redis-xxx.xx.tar编译和安装解压好的rediscd /study/redis.6.2…makemake installredis默认安装在/usr/local/bin目录下运行Redis前台启动（不推荐）在/usr/local/bin下执行redis-server后台启动（推荐）
复制链接

扫一扫