Redis入门以及应用场景j以及数据类型和工具类等

NOSQL

NOSQL=not only sql 泛指非关系型数据库

随着WEB的发展关系型数据库已经满不如不了

- High performance高并发读写
- Huge Storage 海量数据的高效率存储和访问
- High Scalability&& High Avialability高可扩展性（关系型数据库横向扩展困难）和高可用性

Redis

高性能键值对的NOSQL数据库支持键值对类型包括字符串类型、散列类型、列表、集合、有序集合
应用场景 1.缓存2.任务队列3.应用排行榜4.网站访问统计5.数据过期处理6.分布式集群架构中的session分离
安装建议安装在linux服务器上
- 安装gcc环境 redis是C开发的，安装的时候先对下载的源码进行编译，编译依赖gcc环境。如果没有gcc环境需要先安装gcc环境命令：yum install gcc-c++ 根据提示输入y即可
- 安装redis 1.下载好redis上传的root目录下（用MobaXterm_Personal上传）2解压： tar zxvf redis-4.0.11.tar.gz 3.进入解压的文件夹中：make回车进行gcc编译 4.指定路劲进行安装命令：make PREFIX=/usr/local/redis install 安装好后进入发现只有一个bin路劲里面放着一些redis的文件5.拷贝解压路劲下拷贝redis.conf到安装redis的文件夹下这时候不光有bin路劲还有redis.conf配置文件命令：[root@mylinuxcentos redis-4.0.11]# cp redis.conf /usr/local/redis OK 安装完毕
启动关闭Redis

- 进入bin目录 ll命令发现有个redis-server这个就是redis服务器的启动程序了
- [root@mylinuxcentos bin]# ./redis-server 这是前端启动方式：这样启动后我们当前窗口就不能输入命令了 CTR+C停止前端模式那么这样Redis只能关闭了。我们启动Redis一般采用后端启动方式1.修改配置文件进入redis的安装目录找到刚才复制的redis.conf 执行： vim redis.conf i切换编辑模式找到daemonize no 改成daemonize yes 保存退出wq 2.启动加载配置文件[root@mylinuxcentos redis] #./bin/redis-server ./redis.conf 3.通过命令[root@mylinuxcentos redis]# ps -ef |grep -i redis 可以查看redis是否启动以及IP 端口等信息 4.关闭后端启动redis的方法：[root@mylinuxcentos redis]# ./bin/redis-cli shutdown 然后执行查看[root@mylinuxcentos redis]# ps -ef |grep -i redis发现已经关闭强制关闭命令：ps auxf|grep redis |grep -v grep|xargs kill -9 5.如果在linux上通过命令操作redis我们在启动redis-server的同时还需要启动redis-cli

Jedis Redis官网首选的java客户端开发包（和JDBC类似只不过一个连接redis一个连接数据库实际项目中和连接数据库一样都只需要配置配置文件即可）

使用jedis链接linux上Redis并且进行操作之前打开linux服务器上的Redis端口，通过命令打开linux防火墙文件 [root@mylinuxcentos redis]# vim /etc/sysconfig/iptables 截图的最后一行就是打开6379端口然后保存退出。注意这时候需要重启linux防火墙不然不生效 [root@mylinuxcentos redis]# service iptables restart。配置文件中远程连接保护关闭redis.conf中的protected-mode no

Jedis连接操作Redis测试测试代码如下：

package com.liuzhihong.redis_jedis;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
 * @ClassName Redis_Jedis_Test
 * @Description
 * @Author 刘志红
 * @Date 2019/3/9
 **/
public class Redis_Jedis_Test {
    //直接连接方式
    @Test
    public void test_Jedis() {
        Jedis jedis = new Jedis("192.168.241.130", 6379);
        jedis.set("key1", "value1");
        System.out.println(jedis.get("key1"));
        jedis.close();
    }
    //连接池连接方式
    @Test
    public void test_jedis_pool(){
        JedisPoolConfig config=new JedisPoolConfig();
        //连接池配置信息
        config.setMaxTotal(30);
        config.setMaxIdle(10);
        //.....
        JedisPool jedisPool=null;
        Jedis jedis=null;
        try {
             jedisPool=new JedisPool(config,"192.168.241.130",6379);
             jedis = jedisPool.getResource();
            jedis.set("key2", "value2");
            System.out.println(jedis.get("key2"));
        } finally {
            jedis.close();
            jedisPool.close();
        }
    }
}

View Code

Redis在项目中的使用和RedisUtil

转自：https://www.cnblogs.com/zeng1994/p/03303c805731afc9aa9c60dbbd32a323.html

其实现在就可以在代码中注入RedisTemplate，为啥可以直接注入呢？先看下源码吧。下面为RedisAutoConfiguration

package org.springframework.boot.autoconfigure.data.redis;

import java.net.UnknownHostException;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

}

View Code

上面为springboot为Redis自动配置一个RedisTemplate,但是这个bean的泛型是<Object,Object>使用起来不方便，而且自动配置中没有设置数据存到redis时候 key value的序列化方式，因为上面的RedisTemplate的Bean使用了@ConditionalOnMissingBean注解，我们可以通过自己的配置配置文件生成一个<String,Object>的RedisTemplate让上面的RedisTemplate不实例化。

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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class RedisConfig {

 

 @Bean

 @SuppressWarnings("all")

 public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

     RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();

     template.setConnectionFactory(factory);

     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);

     StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

     // key采用String的序列化方式

     template.setKeySerializer(stringRedisSerializer);

     // hash的key也采用String的序列化方式

     template.setHashKeySerializer(stringRedisSerializer);

     // value序列化方式采用jackson

     template.setValueSerializer(jackson2JsonRedisSerializer);

     // hash的value序列化方式采用jackson

     template.setHashValueSerializer(jackson2JsonRedisSerializer);

     template.afterPropertiesSet();

     return template;

 }


}

View Code

RedisUtil 　

package com.liuzhihong.springboot_mybatis_redis.redis;
import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.TimeUnit;


import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Component;

import org.springframework.util.CollectionUtils;

@Component

public final class RedisUtil {



    @Autowired

    private RedisTemplate<String, Object> redisTemplate;


    // =============================common============================

    /**

     * 指定缓存失效时间

     * @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;

        }

    }


    /**

     * 根据key 获取过期时间

     * @param key 键 不能为null

     * @return 时间(秒) 返回0代表为永久有效

     */

    public long getExpire(String key) {

        return redisTemplate.getExpire(key, TimeUnit.SECONDS);

    }


    /**

     * 判断key是否存在

     * @param key 键

     * @return true 存在 false不存在

     */

    public boolean hasKey(String key) {

        try {

            return redisTemplate.hasKey(key);

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 删除缓存

     * @param key 可以传一个值 或多个

     */

    @SuppressWarnings("unchecked")

    public void del(String... key) {

        if (key != null && key.length > 0) {

            if (key.length == 1) {

                redisTemplate.delete(key[0]);

            } else {

                redisTemplate.delete(CollectionUtils.arrayToList(key));

            }

        }

    }


    // ============================String=============================

    /**

     * 普通缓存获取

     * @param key 键

     * @return 值

     */

    public Object get(String key) {

        return key == null ? null : redisTemplate.opsForValue().get(key);

    }


    /**

     * 普通缓存放入

     * @param key 键

     * @param value 值

     * @return true成功 false失败

     */

    public boolean set(String key, Object value) {

        try {

            redisTemplate.opsForValue().set(key, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }


    }


    /**

     * 普通缓存放入并设置时间

     * @param key 键

     * @param value 值

     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期

     * @return true成功 false 失败

     */

    public boolean set(String key, Object value, long time) {

        try {

            if (time > 0) {

                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);

            } else {

                set(key, value);

            }

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 递增

     * @param key 键

     * @param delta 要增加几(大于0)

     * @return

     */

    public long incr(String key, long delta) {

        if (delta < 0) {

            throw new RuntimeException("递增因子必须大于0");

        }

        return redisTemplate.opsForValue().increment(key, delta);

    }


    /**

     * 递减

     * @param key 键

     * @param delta 要减少几(小于0)

     * @return

     */

    public long decr(String key, long delta) {

        if (delta < 0) {

            throw new RuntimeException("递减因子必须大于0");

        }

        return redisTemplate.opsForValue().increment(key, -delta);

    }


    // ================================Map=================================

    /**

     * HashGet

     * @param key 键 不能为null

     * @param item 项 不能为null

     * @return 值

     */

    public Object hget(String key, String item) {

        return redisTemplate.opsForHash().get(key, item);

    }


    /**

     * 获取hashKey对应的所有键值

     * @param key 键

     * @return 对应的多个键值

     */

    public Map<Object, Object> hmget(String key) {

        return redisTemplate.opsForHash().entries(key);

    }


    /**

     * HashSet

     * @param key 键

     * @param map 对应多个键值

     * @return true 成功 false 失败

     */

    public boolean hmset(String key, Map<String, Object> map) {

        try {

            redisTemplate.opsForHash().putAll(key, map);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * HashSet 并设置时间

     * @param key 键

     * @param map 对应多个键值

     * @param time 时间(秒)

     * @return true成功 false失败

     */

    public boolean hmset(String key, Map<String, Object> map, long time) {

        try {

            redisTemplate.opsForHash().putAll(key, map);

            if (time > 0) {

                expire(key, time);

            }

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 向一张hash表中放入数据,如果不存在将创建

     * @param key 键

     * @param item 项

     * @param value 值

     * @return true 成功 false失败

     */

    public boolean hset(String key, String item, Object value) {

        try {

            redisTemplate.opsForHash().put(key, item, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 向一张hash表中放入数据,如果不存在将创建

     * @param key 键

     * @param item 项

     * @param value 值

     * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间

     * @return true 成功 false失败

     */

    public boolean hset(String key, String item, Object value, long time) {

        try {

            redisTemplate.opsForHash().put(key, item, value);

            if (time > 0) {

                expire(key, time);

            }

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 删除hash表中的值

     * @param key 键 不能为null

     * @param item 项 可以使多个 不能为null

     */

    public void hdel(String key, Object... item) {

        redisTemplate.opsForHash().delete(key, item);

    }


    /**

     * 判断hash表中是否有该项的值

     * @param key 键 不能为null

     * @param item 项 不能为null

     * @return true 存在 false不存在

     */

    public boolean hHasKey(String key, String item) {

        return redisTemplate.opsForHash().hasKey(key, item);

    }


    /**

     * hash递增 如果不存在,就会创建一个 并把新增后的值返回

     * @param key 键

     * @param item 项

     * @param by 要增加几(大于0)

     * @return

     */

    public double hincr(String key, String item, double by) {

        return redisTemplate.opsForHash().increment(key, item, by);

    }


    /**

     * hash递减

     * @param key 键

     * @param item 项

     * @param by 要减少记(小于0)

     * @return

     */

    public double hdecr(String key, String item, double by) {

        return redisTemplate.opsForHash().increment(key, item, -by);

    }


    // ============================set=============================

    /**

     * 根据key获取Set中的所有值

     * @param key 键

     * @return

     */

    public Set<Object> sGet(String key) {

        try {

            return redisTemplate.opsForSet().members(key);

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }


    /**

     * 根据value从一个set中查询,是否存在

     * @param key 键

     * @param value 值

     * @return true 存在 false不存在

     */

    public boolean sHasKey(String key, Object value) {

        try {

            return redisTemplate.opsForSet().isMember(key, value);

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 将数据放入set缓存

     * @param key 键

     * @param values 值 可以是多个

     * @return 成功个数

     */

    public long sSet(String key, Object... values) {

        try {

            return redisTemplate.opsForSet().add(key, values);

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }


    /**

     * 将set数据放入缓存

     * @param key 键

     * @param time 时间(秒)

     * @param values 值 可以是多个

     * @return 成功个数

     */

    public long sSetAndTime(String key, long time, Object... values) {

        try {

            Long count = redisTemplate.opsForSet().add(key, values);

            if (time > 0)

                expire(key, time);

            return count;

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }


    /**

     * 获取set缓存的长度

     * @param key 键

     * @return

     */

    public long sGetSetSize(String key) {

        try {

            return redisTemplate.opsForSet().size(key);

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }


    /**

     * 移除值为value的

     * @param key 键

     * @param values 值 可以是多个

     * @return 移除的个数

     */

    public long setRemove(String key, Object... values) {

        try {

            Long count = redisTemplate.opsForSet().remove(key, values);

            return count;

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }

    // ===============================list=================================


    /**

     * 获取list缓存的内容

     * @param key 键

     * @param start 开始

     * @param end 结束 0 到 -1代表所有值

     * @return

     */

    public List<Object> lGet(String key, long start, long end) {

        try {

            return redisTemplate.opsForList().range(key, start, end);

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }


    /**

     * 获取list缓存的长度

     * @param key 键

     * @return

     */

    public long lGetListSize(String key) {

        try {

            return redisTemplate.opsForList().size(key);

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }


    /**

     * 通过索引 获取list中的值

     * @param key 键

     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推

     * @return

     */

    public Object lGetIndex(String key, long index) {

        try {

            return redisTemplate.opsForList().index(key, index);

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }


    /**

     * 将list放入缓存

     * @param key 键

     * @param value 值

     * @return

     */

    public boolean lSet(String key, Object value) {

        try {

            redisTemplate.opsForList().rightPush(key, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 将list放入缓存

     * @param key 键

     * @param value 值

     * @param time 时间(秒)

     * @return

     */

    public boolean lSet(String key, Object value, long time) {

        try {

            redisTemplate.opsForList().rightPush(key, value);

            if (time > 0)

                expire(key, time);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 将list放入缓存

     * @param key 键

     * @param value 值

     * @return

     */

    public boolean lSet(String key, List<Object> value) {

        try {

            redisTemplate.opsForList().rightPushAll(key, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 将list放入缓存

     *

     * @param key 键

     * @param value 值

     * @param time 时间(秒)

     * @return

     */

    public boolean lSet(String key, List<Object> value, long time) {

        try {

            redisTemplate.opsForList().rightPushAll(key, value);

            if (time > 0)

                expire(key, time);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 根据索引修改list中的某条数据

     * @param key 键

     * @param index 索引

     * @param value 值

     * @return

     */

    public boolean lUpdateIndex(String key, long index, Object value) {

        try {

            redisTemplate.opsForList().set(key, index, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }


    /**

     * 移除N个值为value

     * @param key 键

     * @param count 移除多少个

     * @param value 值

     * @return 移除的个数

     */

    public long lRemove(String key, long count, Object value) {

        try {

            Long remove = redisTemplate.opsForList().remove(key, count, value);

            return remove;

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }

}

View Code　

Redis的几种数据结构实际用法

https://blog.csdn.net/lirongqian123/article/details/79370324

Redis的五大数据类型以及应用场景

转载自：https://www.cnblogs.com/xiaoxi/p/7007695.html

redis数据是key/value方式存储 key的不能太长，也不能太短影响可读性，应该设置一定的规范

一、Redis常用数据类型

Redis最为常用的数据类型主要有以下五种：

String
Hash
List
Set
Sorted set

在具体描述这几种数据类型之前，我们先通过一张图了解下Redis内部内存管理中是如何描述这些不同数据类型的：

首先Redis内部使用一个redisObject对象来表示所有的key和value，redisObject最主要的信息如上图所示：type代表一个value对象具体是何种数据类型，encoding是不同数据类型在redis内部的存储方式，比如：type=string代表value存储的是一个普通字符串，那么对应的encoding可以是raw或者是int，如果是int则代表实际redis内部是按数值型类存储和表示这个字符串的，当然前提是这个字符串本身可以用数值表示，比如:"123" "456"这样的字符串。

这里需要特殊说明一下vm字段，只有打开了Redis的虚拟内存功能，此字段才会真正的分配内存，该功能默认是关闭状态的。通过上图我们可以发现Redis使用redisObject来表示所有的key/value数据是比较浪费内存的，当然这些内存管理成本的付出主要也是为了给Redis不同数据类型提供一个统一的管理接口，实际作者也提供了多种方法帮助我们尽量节省内存使用，我们随后会具体讨论。

二、各种数据类型应用和实现方式

下面我们先来逐一的分析下这五种数据类型的使用和内部实现方式：

1、String

String 数据结构是简单的key-value类型，value其实不仅是String，也可以是数字。

常用命令：get、set、getset、del、incr、decr、incrby、decrby、append等。

应用场景：String是最常用的一种数据类型，普通的key/ value 存储都可以归为此类，即可以完全实现目前 Memcached 的功能，并且效率更高。还可以享受Redis的定时持久化，操作日志及 Replication等功能。除了提供与 Memcached 一样的get、set、incr、decr 等操作外，Redis还提供了下面一些操作：

获取字符串长度
往字符串append内容
设置和获取字符串的某一段内容
设置及获取字符串的某一位（bit）
批量设置一系列字符串的内容

使用场景：常规key-value缓存应用。常规计数: 微博数, 粉丝数。

实现方式：String在redis内部存储默认就是一个字符串，被redisObject所引用，当遇到incr,decr等操作时会转成数值型进行计算，此时redisObject的encoding字段为int。

2、Hash

常用命令：hget,hgetm,hset,hmset,hgetall,hdel,del,hlen 等。

应用场景：

我们简单举个实例来描述下Hash的应用场景，比如我们要存储一个用户信息对象数据，包含以下信息：

用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息，如果用普通的key/value结构来存储，主要有以下2种存储方式：

第一种方式将用户ID作为查找key,把其他信息封装成一个对象以序列化的方式存储，这种方式的缺点是，增加了序列化/反序列化的开销，并且在需要修改其中一项信息时，需要把整个对象取回，并且修改操作需要对并发进行保护，引入CAS等复杂问题。

第二种方法是这个用户信息对象有多少成员就存成多少个key-value对儿，用用户ID+对应属性的名称作为唯一标识来取得对应属性的值，虽然省去了序列化开销和并发问题，但是用户ID为重复存储，如果存在大量这样的数据，内存浪费还是非常可观的。

那么Redis提供的Hash很好的解决了这个问题，Redis的Hash实际是内部存储的Value为一个HashMap，并提供了直接存取这个Map成员的接口，如下图：

也就是说，Key仍然是用户ID, value是一个Map，这个Map的key是成员的属性名，value是属性值，这样对数据的修改和存取都可以直接通过其内部Map的Key(Redis里称内部Map的key为field), 也就是通过 key(用户ID) + field(属性标签) 就可以操作对应属性数据了，既不需要重复存储数据，也不会带来序列化和并发修改控制的问题。很好的解决了问题。

这里同时需要注意，Redis提供了接口(hgetall)可以直接取到全部的属性数据，但是如果内部Map的成员很多，那么涉及到遍历整个内部Map的操作，由于Redis单线程模型的缘故，这个遍历操作可能会比较耗时，而另其它客户端的请求完全不响应，这点需要格外注意。

使用场景：存储部分变更数据，如用户信息等。

实现方式：

上面已经说到Redis Hash对应Value内部实际就是一个HashMap，实际这里会有2种不同实现，这个Hash的成员比较少时Redis为了节省内存会采用类似一维数组的方式来紧凑存储，而不会采用真正的HashMap结构，对应的value redisObject的encoding为zipmap，当成员数量增大时会自动转成真正的HashMap，此时encoding为ht。

3、List

常用命令：lpush,rpush,lpop,rpop,lrange,llen等。

应用场景：

Redis list的应用场景非常多，也是Redis最重要的数据结构之一，比如twitter的关注列表，粉丝列表等都可以用Redis的list结构来实现。

List 就是链表，相信略有数据结构知识的人都应该能理解其结构。使用List结构，我们可以轻松地实现最新消息排行等功能。List的另一个应用就是消息队列，
可以利用List的PUSH操作，将任务存在List中，然后工作线程再用POP操作将任务取出进行执行。Redis还提供了操作List中某一段的api，你可以直接查询，删除List中某一段的元素。

实现方式：

Redis list的实现为一个双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销，Redis内部的很多实现，包括发送缓冲队列等也都是用的这个数据结构。

Redis的list是每个子元素都是String类型的双向链表，可以通过push和pop操作从列表的头部或者尾部添加或者删除元素，这样List即可以作为栈，也可以作为队列。

使用场景：

消息队列系统

使用list可以构建队列系统，使用sorted set甚至可以构建有优先级的队列系统。

比如：将Redis用作日志收集器

实际上还是一个队列，多个端点将日志信息写入Redis，然后一个worker统一将所有日志写到磁盘。

取最新N个数据的操作

记录前N个最新登陆的用户Id列表，超出的范围可以从数据库中获得。

//把当前登录人添加到链表里
ret = r.lpush("login:last_login_times", uid)

//保持链表只有N位
ret = redis.ltrim("login:last_login_times", 0, N-1)

//获得前N个最新登陆的用户Id列表
last_login_list = r.lrange("login:last_login_times", 0, N-1)

比如sina微博：

在Redis中我们的最新微博ID使用了常驻缓存，这是一直更新的。但是我们做了限制不能超过5000个ID，因此我们的获取ID函数会一直询问Redis。只有在start/count参数超出了这个范围的时候，才需要去访问数据库。

我们的系统不会像传统方式那样“刷新”缓存，Redis实例中的信息永远是一致的。SQL数据库（或是硬盘上的其他类型数据库）只是在用户需要获取“很远”的数据时才会被触发，而主页或第一个评论页是不会麻烦到硬盘上的数据库了。

4、Set

常用命令：

sadd,spop,smembers,sunion 等。

应用场景：

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

Set 就是一个集合，集合的概念就是一堆不重复值的组合。利用Redis提供的Set数据结构，可以存储一些集合性的数据。

案例：

在微博应用中，可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。Redis还为集合提供了求交集、并集、差集等操作，可以非常方便的实现如共同关注、共同喜好、二度好友等功能，对上面的所有集合操作，你还可以使用不同的命令选择将结果返回给客户端还是存集到一个新的集合中。

Set是集合，是String类型的无序集合，set是通过hashtable实现的，概念和数学中个的集合基本类似，可以交集，并集，差集等等，set中的元素是没有顺序的。

实现方式：

set 的内部实现是一个 value永远为null的HashMap，实际就是通过计算hash的方式来快速排重的，这也是set能提供判断一个成员是否在集合内的原因。

使用场景：

交集，并集，差集：(Set)

//book表存储book名称

set book:1:name    ”The Ruby Programming Language”

set book:2:name     ”Ruby on rail”

set book:3:name     ”Programming Erlang”

//tag表使用集合来存储数据，因为集合擅长求交集、并集

sadd tag:ruby 1

sadd tag:ruby 2

sadd tag:web 2

sadd tag:erlang 3

//即属于ruby又属于web的书？

 inter_list = redis.sinter("tag.web", "tag:ruby") 

//即属于ruby，但不属于web的书？

 inter_list = redis.sdiff("tag.ruby", "tag:web") 

//属于ruby和属于web的书的合集？

 inter_list = redis.sunion("tag.ruby", "tag:web")

获取某段时间所有数据去重值

这个使用Redis的set数据结构最合适了，只需要不断地将数据往set中扔就行了，set意为集合，所以会自动排重。

5、Sorted Set

常用命令：

zadd,zrange,zrem,zcard等

使用场景：

Redis sorted set的使用场景与set类似，区别是set不是自动有序的，而sorted set可以通过用户额外提供一个优先级(score)的参数来为成员排序，并且是插入有序的，即自动排序。当你需要一个有序的并且不重复的集合列表，那么可以选择sorted set数据结构，比如twitter 的public timeline可以以发表时间作为score来存储，这样获取时就是自动按时间排好序的。

和Set相比，Sorted Set增加了一个权重参数score，使得集合中的元素能够按score进行有序排列，比如一个存储全班同学成绩的Sorted Set，其集合value可以是同学的学号，而score就可以是其考试得分，这样在数据插入集合的时候，就已经进行了天然的排序。另外还可以用Sorted Set来做带权重的队列，比如普通消息的score为1，重要消息的score为2，然后工作线程可以选择按score的倒序来获取工作任务。让重要的任务优先执行。

实现方式：

Redis sorted set的内部使用HashMap和跳跃表(SkipList)来保证数据的存储和有序，HashMap里放的是成员到score的映射，而跳跃表里存放的是所有的成员，排序依据是HashMap里存的score,使用跳跃表的结构可以获得比较高的查找效率，并且在实现上比较简单。

三、Redis实际应用场景

1、显示最新的项目列表

下面这个语句常用来显示最新项目，随着数据多了，查询毫无疑问会越来越慢。

SELECT * FROM foo WHERE ... ORDER BY time DESC LIMIT 10

在Web应用中，“列出最新的回复”之类的查询非常普遍，这通常会带来可扩展性问题。这令人沮丧，因为项目本来就是按这个顺序被创建的，但要输出这个顺序却不得不进行排序操作。类似的问题就可以用Redis来解决。比如说，我们的一个Web应用想要列出用户贴出的最新20条评论。在最新的评论边上我们有一个“显示全部”的链接，点击后就可以获得更多的评论。我们假设数据库中的每条评论都有一个唯一的递增的ID字段。我们可以使用分页来制作主页和评论页，使用Redis的模板，每次新评论发表时，我们会将它的ID添加到一个Redis列表：

LPUSH latest.comments <ID>

我们将列表裁剪为指定长度，因此Redis只需要保存最新的5000条评论：

LTRIM latest.comments 0 5000

每次我们需要获取最新评论的项目范围时，我们调用一个函数来完成（使用伪代码）：

FUNCTION get_latest_comments(start, num_items):  
    id_list = redis.lrange("latest.comments",start,start+num_items - 1)  
    IF id_list.length < num_items  
        id_list = SQL_DB("SELECT ... ORDER BY time LIMIT ...")  
    END  
    RETURN id_list  
END

这里我们做的很简单。在Redis中我们的最新ID使用了常驻缓存，这是一直更新的。但是我们做了限制不能超过5000个ID，因此我们的获取ID函数会一直询问Redis。只有在start/count参数超出了这个范围的时候，才需要去访问数据库。

2、排行榜应用，取TOP N操作

这个需求与上面需求的不同之处在于，取最新N个数据的操作以时间为权重，这个是以某个条件为权重，比如按顶的次数排序，这时候就需要我们的sorted set出马了，将你要排序的值设置成sorted set的score，将具体的数据设置成相应的value，每次只需要执行一条ZADD命令即可。