Spring java 操作 redis

官方文档

Redis中文网

一、redis基础常识

1.数据类型

Redis存储的是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型

• 字符串 string

• 哈希 hash

• 列表 list

• 集合 set

• 有序集合 sorted set

2.常用命令

2.1 字符串常用命令

SET key value 设置指定 key 的值
GET key 获取指定 key 的值。
SETEX key seconds value 将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。
SETNX key value 只有在 key 不存在时设置 key 的值。

127.0.0.1:6379> setnx age 10
(integer) 1
127.0.0.1:6379> setnx age 11
(integer) 0
127.0.0.1:6379> get age
"10"

2.2 哈希 hash操作命令

HSET key field value 将哈希表 key 中的字段 field 的值设为 value 。
HGET key field 获取存储在哈希表中指定字段的值
[HDEL key field2 field2] 删除一个或多个哈希表字段
HKEYS key 获取所有哈希表中的字段
HVALS key 获取哈希表中所有值
HGETALL key 获取在哈希表中指定 key 的所有字段和值

127.0.0.1:6379> hset 1701020202 name changfan
(integer) 1
127.0.0.1:6379> hset 1701020202 age 20
(integer) 1
127.0.0.1:6379> hget 1701020202 name
"changfan"
127.0.0.1:6379> hget 1701020202 age
"20"
127.0.0.1:6379> hdel 1701020202 age
(integer) 1
127.0.0.1:6379> hget 1701020202 age
(nil)
127.0.0.1:6379> hkeys 1701020202
1) "name"
127.0.0.1:6379> hvals 1701020202
1) "changfan"
127.0.0.1:6379> hgetall 1701020202
1) "name"
2) "changfan"

2.3列表常用命令

redis列表是简单的字符串列表，按照插入顺序，常用命令

[LPUSH key value1 value2] 将一个或多个值插入到列表头部
LRANGE key start stop 获取列表指定范围内的元素
RPOP key 移除并获取列表最后一个元素
LLEN key 获取列表长度
[BRPOP key1 key2 ] timeout 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

127.0.0.1:6379> lpush 001 1 2 3
(integer) 3
127.0.0.1:6379> lrange 001 0 3
1) "3"
2) "2"
3) "1"
127.0.0.1:6379> lrange 001 0 5
1) "3"
2) "2"
3) "1"
127.0.0.1:6379> lrange 001 1 5
1) "2"
2) "1"
127.0.0.1:6379> rpop 001
"1"
127.0.0.1:6379> lrange 001 1 5
1) "2"
127.0.0.1:6379> lrange 001 0 5
1) "3"
2) "2"
127.0.0.1:6379> lrange 001 0 -1
1) "3"
2) "2"
127.0.0.1:6379> BRPOP 001 10
1) "001"
2) "2"
127.0.0.1:6379> lrange 001 0 -1
1) "3"
127.0.0.1:6379> BRPOP 001 10
1) "001"
2) "3"
127.0.0.1:6379> BRPOP 001 10
(nil)
(10.09s)

集合set常用命令

[SADD key member1 member2] 向集合添加一个或多个成员
SMEMBERS key 返回集合中的所有成员
SCARD key 获取集合的成员数
[SINTER key1 key2] 返回给定所有集合的交集
[SUNION key1 key2] 返回所有给定集合的并集
[SDIFF key1 key2] 返回给定所有集合的差集
[SREM key member1 member2] 移除集合中一个或多个成员

通用命令

keys patten 查找所有符合给定的key
Exists key 检查给定key是否存在
type key 返回所存储的值类型
TTL key 返回给定key的剩余生存时间，单位为秒
DEL key key存在时删除key

二、使用Jedis操作java

Redis的java客户端有多种，官方推荐的有三种

• Jedis

• Lettcue

• Redisson

3.1 导入依赖

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

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

3.2 使用

import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.Set;
public class JedisTest {
    @Test
    public void testRedis() {
        // 1.创建链接
        Jedis jedis = new Jedis("xx.xx.xx.xx", 6379);
        //如果你的redis设置了密码，需要调用auth方法进行授权
        //jedis.auth("xxxx");
        String value = jedis.ping();
        //Redis中如果能够ping通，会返回一个pong
        System.out.println(value);
        // 2.执行具体的操作
        jedis.set("username","changfan");
        System.out.println("get from redis: "+jedis.get("username"));
        // 删除key
        jedis.del("username");
        jedis.hset("myhash","adddress","hangzhou");
        System.out.println("---------------keys--------------------");
        Set<String> keys = jedis.keys("*");
        keys.forEach(System.out::println);

        // 3.关闭链接
        jedis.close();
    }
}

三、Spring data redis

4.1 项目结构

4.2导入依赖

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <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>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

4.3 application.properties

spring.data.redis.host=10.10.0.25
spring.data.redis.port=6379
# 默认操作的是0号数据库 可以通过select切换数据库
spring.data.redis.database=0
spring.data.redis.jedis.pool.max-active=8
# 连接池中的最大阻塞等待时间
spring.data.redis.jedis.pool.max-wait=8ms
# 连接池中的最大空闲连接
spring.data.redis.jedis.pool.max-idle=4
# 连接池中的最小空闲连接
spring.data.redis.jedis.pool.min-idle=0

4.4 redisConfig

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    // idea可能存在报错，不影响运行
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public RedisTemplate<Object,Object> redisTemplate(){
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        return  redisTemplate;
    }

}

4.5 使用

import org.junit.jupiter.api.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.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringdataredisDemoApplicationTests {

    // idea可能存在报错，不影响运行
    @Autowired
    private RedisTemplate redisTemplate;

    /*
    操作String类型的数据
     */
    @Test
    public void testString() {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("name1", "changfan");
        System.out.println(valueOperations.get("name1"));

        redisTemplate.opsForValue().set("k1", "v1", 10L, TimeUnit.SECONDS);
        System.out.println(valueOperations.get("k1"));

    }

    /*
    操作Hash类型的数据
     */

    @Test
    public void testHash() {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.put("002", "name", "小明");
        hashOperations.put("002", "age", "20");

        System.out.println(hashOperations.get("002", "name"));

        // 获取hash结构中的所有字段
        Set keys = hashOperations.keys("002");
        keys.forEach(System.out::println);

        // 获取hash结构中的所有字段
        List values = hashOperations.values("002");
        values.forEach(System.out::println);
    }


    /*
    操作List类型的数据
     */

    @Test
    public void testList() {
        ListOperations listOperations = redisTemplate.opsForList();
        listOperations.leftPush("mylist", 1);
        listOperations.leftPushAll("mylist", 2, 3, 4);

        List mylist = listOperations.range("mylist", 0, -1);
        mylist.forEach(System.out::println);


        //出队列
        String mylist1 = (String) listOperations.rightPop("mylist");
        System.out.println(mylist1);
    }

    /*
操作set类型的数据
 */
    @Test
    public void testSet() {
        SetOperations setOperations = redisTemplate.opsForSet();
        // 存储
        setOperations.add("myset", "a", "b", "c");

        // 取值
        Set myset = setOperations.members("myset");
        myset.forEach(System.out::println);

        System.out.println("xxxxxxxxxxxxxx");

        // 删除成员
        setOperations.remove("myset", "a", "c");
        Set myset1 = setOperations.members("myset");
        myset1.forEach(System.out::println);

    }

    /*
        操作set类型的数据
    */
    @Test
    public void testZSet() {
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        zSetOperations.add("myZset", "a", 10.0);
        zSetOperations.add("myZset", "b", 11.0);
        zSetOperations.add("myZset", "c", 12.0);


        Set myZset = zSetOperations.range("myZset", 0, -1);
        myZset.forEach(System.out::println);

        System.out.println("xxxxxxxxxxxxxx");

        zSetOperations.incrementScore("myZset", "b", 20);
        Set myZset0 = zSetOperations.range("myZset", 0, -1);
        myZset0.forEach(System.out::println);

        System.out.println("xxxxxxxxxxxxxx");

        zSetOperations.remove("myZset", "a", "b");
        Set myZset1 = zSetOperations.range("myZset", 0, -1);
        myZset1.forEach(System.out::println);

    }


    /*
        通用操作
    */
    @Test
    public void testCommon() {
        // 获取Redis中所有的key
        Set keys = redisTemplate.keys("*");
        keys.forEach(System.out::println);

        // 判断key是否存在
        Boolean name = redisTemplate.hasKey("name1");
        System.out.println("是否存在name的key" + name);

        //删除指定的key
        Boolean name1 = redisTemplate.delete("name1");
        System.out.println("是否成功删除name1");

        // 获取指定的key对应的类型
        DataType myZset = redisTemplate.type("myZset");
        System.out.println("myZset的类型 " + myZset);
    }
}