Redis的基本操作

1.Redis简介

Redis是一款基于内存的key-value结构数据库，它的主要优点有以下几点：

• 基于内存存储，读写性能高
• 适合存储热点数据
• 企业应用广泛

其结构为：

key	value
id	101

这种为Redis的存储结构。

2.Redis的常用数据类型

Redis存储的是key-value结构的数据，其中key为字符串类型，value有常用的五种数据类型，所有Redis的数据类型更多是相对于value所说。

value的这五种常用类型如下：

• 字符串类型 String
• 哈希 hash
• 列表 List
• 集合 Set
• 有序集合 ZSet

这五种类型大概如下图格式：

其中哈希类似Java中的hashMap集合，列表类似Java中的LinkedList，集合类似Java中的HashSet集合，且无序，有序集合类似Java中的TreeSet。

3.Redis的常用命令

以下命令均可在Redis客户端执行

1.字符串操作命令

set key value     //设置key值和value值
get key           //根据指定key值获取value值
setex key seconds value     //设置key值的value秒后过期
setnx key value       //只有在key值不存在的时候才能设置，存在则无效。

2.哈希操作命令

hset key field value         //添加或设置对应的哈希键值对
hget key field        //根据key和哈希的键获取值
hdel key field        //删除对应的哈希键值对
hkeys key       //获取哈希表中的所有键
hvals key       //获取哈希表中的所有值

3.列表操作命令

lpush key value1 [value2]         //将一个或多个值插入列表
lrange key start stop            //获取指定范围内的元素
rpop key                        //移除并获取列表最后一个元素
len key                          //获取列表长度

4.集合操作命令

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

5.有序集合操作命令

ZADD key score1 member1 [score2 member2]//向有序集合添加一个或多个成员
ZRANGE key start stop [WITHSCORES]//通过索引区间返回有序集合中指定区间内的成员
ZINCRBY key increment member//有序集合中对指定成员的分数加上增量 increment
ZREM key member [member ..]//移除有序集合中的一个或多个成员

6.通用操作命令

KEYS pattern //查找所有符合给定惯式（patern）的key
EXISTS key //检查给定 key 是否存在
TYPE key //返回 key 所储存的值的类型
DEL key //该命令用于在key存在且删除这个key

4.Springboot配置Redis

redis的Java客户端包括Jedis，Lettuce，Spring Data Redis，我们在Springboot项目中使用易于集成的Spring Data Redis。

以下就是在Springboot项目中如何使用Redis

1.导入SpringDataRedis的Maven坐标

<dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

2.配置Redis的数据源

spring:
  redis:
    host: localhost
    port: 6379
    database: 0

3.编写配置类，创还能RedisTemplate对象

@Configuration
@Slf4j
public class RedisConfiguration {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        log.info("创建RedisTemplate");
        RedisTemplate redisTemplate = new RedisTemplate();
        //设置Redis连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置RedisTemplate序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

4.使用RedisTemplate操作Redis对象

public class SpringDataRedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testSpringDataRedis(){
        System.out.println(redisTemplate);
        //字符串类型Redis的操作对象
        ValueOperations ops = redisTemplate.opsForValue();
        //List类型的操作对象
        ListOperations listOperations = redisTemplate.opsForList();
        //Hash类型的操作对象
        HashOperations ops1 = redisTemplate.opsForHash();
        //set类型的操作对象
        SetOperations setOperations = redisTemplate.opsForSet();
        //ZSET类型的操作对象
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
    }

    */
/**
     * 操作字符串类型的数据
     *//*

    @Test
    public void testString(){
        //set get setex setnx
        redisTemplate.opsForValue().set("city","北京");
        String city = (String) redisTemplate.opsForValue().get("city");
        System.out.println(city);
        redisTemplate.opsForValue().set("code","1234",3, TimeUnit.MINUTES);
        redisTemplate.opsForValue().setIfAbsent("lock","1");
        redisTemplate.opsForValue().setIfAbsent("lock","2");
    }

    */
/**
     * 操作哈希类型的数据
     *//*

    @Test
    public void testHash(){
        //hset, hget,hdel,hkeys,hvals
        HashOperations ops = redisTemplate.opsForHash();
        ops.put("100","name","xiaoming");
        ops.put("100","age","22");
        String name = (String) ops.get("100", "name");
        System.out.println(name);
        Set keys = ops.keys("100");
        System.out.println(keys);
        List values = ops.values("100");
        System.out.println(values);
        ops.delete("100","age");
    }

    */
/**
     * 操作列表类型的数据
     *//*

    @Test
    public void testList(){
        //lpush,lrange,rpop,llen
        ListOperations ops = redisTemplate.opsForList();
        ops.leftPushAll("mylist","a","b","c");
        ops.leftPush("mylist","d");
        List mylist = ops.range("mylist", 0, -1);
        System.out.println(mylist);
        ops.rightPop("mylist");
        Long size = ops.size("mylist");
        System.out.println(size);
    }


    */
/**
     * 操作集合类型的数据
     *//*

    @Test
    public void testSet(){
        //sadd, smembers,scard,sinter,sunion,srem
        SetOperations setOperations = redisTemplate.opsForSet();
        setOperations.add("set1","a","b",'c','d');
        setOperations.add("set2","a","b",'x','y');
        Set set1 = setOperations.members("set1");
        System.out.println(set1);
        Long size = setOperations.size("set1");
        System.out.println(size);
        Set intersect = setOperations.intersect("set1", "set2");
        System.out.println(intersect);
        Set union = setOperations.union("set1", "set2");
        System.out.println(union);
        setOperations.remove("set1","a","b");
    }

    */
/**
     * 操作有序集合类型的数据
     *//*

    @Test
    public void testZset(){
        //zadd,zrange,zincrby,zrem
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
        zSetOperations.add("zset1","a",10);
        zSetOperations.add("zset1","b",12);
        zSetOperations.add("zset1","c",9);

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

        zSetOperations.incrementScore("zset1","c",10);

        zSetOperations.remove("zset1","a","b");

    }

    */
/**
     * 通用命令操作
     *//*

    @Test
    public void testCommon(){
        //keys,exists,type,del
        Set keys = redisTemplate.keys("*");
        System.out.println(keys);
        System.out.println("=======================");
        Boolean name = redisTemplate.hasKey("name");
        Boolean set1 = redisTemplate.hasKey("set1");
        System.out.println(name);
        System.out.println(set1);
        System.out.println("======================");
        for (Object key : keys) {
            DataType type = redisTemplate.type(key);
            System.out.println(type);
        }
        redisTemplate.delete("mylist");
    }
}

5.总结

Redis的五种类型主要是对Redis值的操作，对Redis键的操作主要集中在通用命令上，其中最重要的是如何在Springboot项目中使用并且操作Redis，应从使用Java分装的Redis操作类，到连接到Redis服务器，再讲该类配置到该项目中使用，最后使用该类进行具体的操作。