一、安装redis:

1.下载:

wget http://download.redis.io/releases/redis-3.2.8.tar.gz

 2.解压

tar -zxvf redis-3.2.8.tar.gz

 

3.复制,放到/usr/local目录下

sudo mv ./redis-3.2.8 /usr/local/redis

 

4.进入到redis目录下

cd /usr/local/redis/

 

5.生成

sudo make

 

6.测试,时间会相比长

sudo make test

 

7.安装,将redis的命令安装到usr/local/bin/目录中

sudo make install

 

8.安装成功后,进入usr/local/bin/目录中查阅:

cd /usr/local/bin

 

 金沙注册送58 1

9.将配备文件复制放到/etc/redis目录下:

sudo cp /usr/local/redis/redis.conf /etc/redis/redis.conf

 

 只怕刚初步etc下并未redis目录,要求协调手动创制2个redis文件夹。

以上在第五步的时候也许会遇见这么的标题:

You need tcl 8.5 or newer in order to run the Redis test
make: *** [test] Error 1

 

解决办法:安装tcl 

wget http://downloads.sourceforge.net/tcl/tcl8.6.1-src.tar.gz  
sudo tar xzvf tcl8.6.1-src.tar.gz  -C /usr/local/  
cd  /usr/local/tcl8.6.1/unix/  
sudo ./configure  
sudo make  
sudo make install 

 

一、安装redis:

一、redis简介

 

Redis是一种面向”键/值”对数据类型的内部存款和储蓄器数据库,能够满意大家对海量数据的读写要求。

redis的键只好是字符串

redis的值帮助三种数据类型:

        1:字符串 string

        2:哈希 hash

        3:字符串列表 list

        4:字符串集合 set 不另行(只用于string),严节

        5:有序聚集sorted set ,不另行,有序

        6:HyperLogLog 结构(redis2.8.9版本才有,用来做基数总结的算法。)

特点:

高品质(Redis读的快慢是11W次/s,写的快慢是8.1W次/s)

原子性(保险数据的准头,原子操作,)

从始至终存款和储蓄(三种办法中华VDB/快速照相,AOF/日志)

中央结构(master-slave,负载均衡,高可用)

集群(3.0版本)

 

 

动用:应用在高并发和实时请求的景色。

果壳网和讯

hash:关怀列表,客官列表

string:和讯数,观众数(幸免使用select count(*) from…)

sorted set:TopN,热门和讯

 

金沙注册送58 2

 

redis使用的是c语言实验的

 

Redis 简介

Redis 是截然开源免费的,遵循BSD协议,是三个高质量的key-value数据库。

Redis 与别的 key – value 缓存产品有以下多少个特点:

  • Redis协理数据的持久化,能够将内部存款和储蓄器中的数码保存在磁盘中,重启的时候能够再度加载实行应用。
  • Redis不仅仅支持不难的key-value类型的数量,同时还提供list,set,zset,hash等数据结构的贮存。
  • Redis扶助数据的备份,即master-slave方式的数据备份。

二、 配置redis:

配备新闻在/etc/redis/redis.conf下,打开sudo vi
/etc/redis/redis.conf。

主导配置选项:

绑定ip:bind 127.0.0.1

端口号:port 6379

是还是不是以守护进度运营:daemonize yes  必须改为yes

数据库文件:dbfilename dump.db  

数据库文件存款和储蓄路径:dir
/var/lib/redis  可改可不改,改的话提前创立好文件夹

日志文件:logfile
/var/log/redis/redis-server.log  要求求改,提前成立好文件夹

数据库,默认有16个:database 16

主从复制:slaveof

配置小结:首要更改两块:1,守护进度;2.日志文件路径

1.下载:

二 、环境搭建

Redis 优势

  • 质量极高 – Redis能读的速度是1一千0次/s,写的速度是8一千次/s 。
  • 加上的数据类型 – Redis援救二进制案例的 Strings, Lists, Hashes, Sets
    及 Ordered Sets 数据类型操作。
  • 原子 –
    Redis的富有操作都以原子性的,意思正是依然成功推行也许战败完全不实施。单个操作是原子性的。五个操作也帮助理工程师作,即原子性,通过MULTI和EXEC指令包起来。
  • 添加的特色 – Redis还补助 publish/subscribe, 通告, key 过期等等特色。

三、启动redis:

1.依照配置文件运维redis服务器

sudo redis-server /etc/redis/redis.conf 

 

2.启动redis客户端:

redis-cli

 

3.输入ping命令测试:

127.0.0.1:6379> ping
PONG

 

4.关闭redis服务器:

ps aux|grep redis    # 查看redis进程号
kill -9 pid redis进程号    # 关闭redis服务器

 

5.切换数据库:私下认可有十四个,通过0-15来标识,默许是率先个数据库0号数据库。

select n

 

wget http://download.redis.io/releases/redis-3.2.8.tar.gz

首先安装c的编写翻译环境

yum -y install cpp

yum -y install binutils

yum -y install glibc

yum -y install glibc-kernheaders

yum -y install glibc-common

yum -y install glibc-devel

yum -y install gcc

yum -y install make

一旦地方的软件都设置之后再实践make命令还报错,就需求在make命令前面加个选项了

make MALLOC=libc

金沙注册送58 3

金沙注册送58 4

 

金沙注册送58 5

金沙注册送58 6

详尽示例,包蕴安装。 

金沙注册送58 7

金沙注册送58 8

 

 

金沙注册送58 9

金沙注册送58 10

 

 

 

金沙注册送58 11

金沙注册送58 12

 

金沙注册送58 13

金沙注册送58 14

 

金沙注册送58 15

金沙注册送58 16

 

金沙注册送58 17

金沙注册送58 18

 

 

Redis与别的key-value存款和储蓄有哪些两样?

  • Redis有着进一步复杂的数据结构并且提供对她们的原子性操作,这是二个差异于别的数据库的升高路径。Redis的数据类型都以按照基本数据结构的还要对程序员透明,无需实行额外的空洞。
  • Redis运转在内部存款和储蓄器中但是足以持久化到磁盘,所以在对分歧数量集举办高效读写时索要权衡内部存款和储蓄器,因为数据量不可能当先硬件内部存款和储蓄器。在内部存款和储蓄器数据库方面包车型地铁另三个独到之处是,比较在磁盘上等同的纷纷的数据结构,在内部存款和储蓄器中操作起来卓殊不难,那样Redis能够做过多里面复杂性很强的工作。同时,在磁盘格式方面他们是严密的以追加的法子发出的,因为他俩并不须求进行任意访问。

④ 、redis的数量操作:

1.redis的积存格式为key-value格式。key是字符串类型,value的品类有5种:string、hash、list、set、zset。

2.redis中有关键的宽广的操作:

2.1翻看左右的键:keys *

2.2翻看某些键是不是存在,存在重返1不设有重临0:exists
key1

2.3查看键的值对应的数据类型:type
key1

2.4删减键值对:del key1 key2

2.5设置键的晚点时间,假如没有点名默许向来留存:expire
key seconds

2.6查看键的可行时间:ttl key1

2.7清空数据库:flushall

3.string类型的基本操作:

3.1保存

  • set key value  保存单个键值对
  • mset key1 value1 key2
    value2  保存多少个键值对
  • setex key seconds
    value  设置键值和过期时间
  • append key value追加值

3.2获取

  • get key  获取单个
  • mget key1 key2  获取三个

3.3删除

  • del key

4 hash类型的基本操作:

4.1保存

hset key field value    #设置单个属性
hmset key field1 value1 field2 value2 ...    #设置多个属性

 

4.2获取

hkeys key    # 获取指定键的所有属性
hget key field    # 获取单个属性的值
hmget key field1 field2 ...    # 获取多个属性的值
hvals key    # 获取所有属性的值

 

4.3删除

del key    # 删除整个hash的键和值
hdel key field1 field2 ...    # 删除属性和属性对应的值

 

4.4关于hash类型的个体知道:

能够将hash类型掌握为用来存款和储蓄对象:

金沙注册送58 19

 

 5。list类型的基本操作:

5.1保存

lpush key value1 value2 ...    #从左侧依次插入数据
rpush key value1 value2 ...    #从右侧依次插入数据
linsert key before或after 现有元素 新元素    #从指定元素的前或后插入新元素

 

 5.2获取

lrange key start stop    

 

 start、stop为因素的下标索引,从右边开头,第四个要素为0,-1标识最终三个成分。获取具有的因素:lrange
key 0 -1

5.3刨除钦命成分

lrem key count value

 

 将列表中前count次面世的值为value的元素移除。

count > 0: 从头到尾移除

count < 0: 从尾到头移除

count = 0: 移除全数

 6.set类型的基本操作

天性:严节集聚、成分唯一性不另行、没有改动操作

6.八日增成分

sadd key member1 member2 ...

 

 6.2获得成分

smembers key    # 返回所有元素

 

6.3剔除钦点成分

srem key member1 member2 ...

 

 

 7.zset类型的数目操作

特征:有序聚集、成分唯一性不另行、没有改动操作、每一种元素都会涉嫌一个double类型的权重,根据权重从小到大排列

7.1增加

zadd key score1 member1 score2 member2 ...

 

7.2获取

zrange key start stop  # 根据索引获取

zrangebyscore key min max  # 获取权重在min和max之间的数据
zscore key member  # 返回成员member的score值

 

7.3删除

zrem key member1 member2 ...    # 删除指定元素
zremrangebyscore key min max    #删除权重在指定范围的元素

2.解压

redis安装配置(单机)

redis官网:

解压:tar -zxvf redis-2.8.19.tar.gz

编译、安装

make

make
install(将redis-3.0.0/src目录下边包车型地铁可执行文件拷贝到/usr/local/bin目录上边,成效是在任何目录下实施脚本不需求钦定相对路径可能供给切换来路径才能实行脚本,也正是添加环境变量(将src配置到PATH))

 

加压缩后,执行make命令编译redis

金沙注册送58 20

make install

金沙注册送58 21

 

拷贝配置文件

cp redis/redis.conf /etc/

金沙注册送58 22

修改配置文件redis.conf

金沙注册送58 23

daemonize yes(后台运营)

金沙注册送58 24

logfile /usr/local/redis/log(后台运维的日记文件存放路径)

金沙注册送58 25

 

启动

redis-server /etc/redis.conf [–port 6379]

金沙注册送58 26

金沙注册送58 27

金沙注册送58 28

redis客户端(client,连接受当地的数据库)

redis 数据类型

Redis支持各样数据类型:string(字符串),hash(哈希),list(列表),set(集合)及zset(sorted
set:有序聚集)。

五 、redis与python进行互动:

 1.在虚拟环境中装置redis包:

pip install redis

 

 2.调用模块:

from redis import StrictRedis

 

 3.成立对象:

sr = StrictRedis(host='localhost', port=6379, db=0)  # 默认就是这样的值,不写也行。

 

 4.用sr那些目的操作redis,将redis中的命令当作函数让sr调用就ok。

tar -zxvf redis-3.2.8.tar.gz

redis-cli [-h 127.0.0.1] [-p 6379]

金沙注册送58 29

金沙注册送58 30

-h(连接的是哪3个数据库)-p(是端口号)

金沙注册送58 31

关闭

redis-cli shutdown

 

金沙注册送58 32

 

 

 

 

 

别的途径都可以调用bin目录下的shell脚本,

金沙注册送58 33

金沙注册送58 34目录下边

金沙注册送58 35

(启动)redis-server

金沙注册送58 36

金沙注册送58 37

 

 

 

金沙注册送58, 

maven依赖

<dependencies>
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.4.2</version>
    </dependency>
</dependencies>

6、Django框架中session存储到redis中的配置

默许情形下session是储存在数据库中的,不过当用session保存用户的气象时,用户频仍的拜访服务器,会叠加数据库的下压力,也会骤降用户访问的进度。为了缓解那个题材将session存款和储蓄到redis中。

先是种配备格局:(不行使Django中session默许的仓库储存方式,直接将session存款和储蓄的地点安顿到redis中)

# 1.在虚拟环境中安装包
pip install django-redis-sessions==0.5.6

# 2.在Django项目的settings文件中增加下面的配置
SESSION_ENGINE = 'redis_sessions.session'
SESSION_REDIS_HOST = 'localhost'
SESSION_REDIS_PORT = 6379
SESSION_REDIS_DB = 2
SESSION_REDIS_PASSWORD = ''
SESSION_REDIS_PREFIX = 'session'

 

 第三种配备方式:(先将Django中的缓存设置为redis,然后将session的囤积地方设置为Django的缓存中)

#1.先在虚拟环境中安装包
pip install django_redis

#2. 设置redis作为django的缓存设置
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        # 把这里缓存你的redis服务器ip和port
        "LOCATION": "redis://172.16.179.142:6379/12",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}

# 3.设置redis存储django的session信息
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"

 

3.复制,放到/usr/local目录下

daemonize yes(后台运营)

Jedis API 操作示例

sudo mv ./redis-3.2.8 /usr/local/redis

logfile /usr/local/redis/log(日志文件)

 

 

 

 

 

 

 

Jedis 连接池

连接Jedis线程安全单列格局可布置八个redis数据源的连接池。

public class JedisApi {

    private static final Logger LOG = LoggerFactory.getLogger(JedisApi.class);

    private volatile static JedisApi jedisApi;

    /**
     * 保存多个连接源
     */
    private static Map<String, JedisPool> poolMap = new HashMap<String, JedisPool>();

    private JedisApi() {
    }

    /**
     * @Description: jedisPool 池
     * @Param: [ip, port]
     * @return: redis.clients.jedis.JedisPool
     * @Author: imdalai
     * @Date: 2018/1/15
     */
    private static JedisPool getPool(String ip, int port) {

        try {
            String key = ip + ":" + port;
            JedisPool pool = null;
            if (!poolMap.containsKey(key)) {
                JedisPoolConfig config = new JedisPoolConfig();
                config.setMaxIdle(RedisConfig.MAX_IDLE);
                config.setMaxTotal(RedisConfig.MAX_ACTIVE);
                //  在获取连接的时候检查有效性, 默认false
                config.setTestOnBorrow(true);
                //  在空闲时检查有效性, 默认false
                config.setTestOnReturn(true);
                pool = new JedisPool(config, ip, port, RedisConfig.TIME_OUT);
                poolMap.put(key, pool);
            } else {
                pool = poolMap.get(key);
            }
            return pool;
        } catch (Exception e) {
            LOG.error("init jedis pool failed ! " + e.getMessage(), e);
        }
        return null;
    }

    /**
     * @Description: 线程安全单列模式
     * @Param: []
     * @return: JedisApi
     * @Author: imdalai
     * @Date: 2018/1/15
     */
    public static JedisApi getRedisApi() {

        if (jedisApi == null) {
            synchronized (JedisApi.class) {
                if (jedisApi == null) {
                    jedisApi = new JedisApi();
                }
            }
        }
        return jedisApi;
    }

    /**
     * @Description: 获取一个jedis连接
     * @Param: [ip, port]
     * @return: redis.clients.jedis.Jedis
     * @Author: imdalai
     * @Date: 2018/1/15
     */
    public Jedis getRedis(String ip, int port) {
        Jedis jedis = null;
        int count = 0;
        while (jedis == null && count <= RedisConfig.RETRY_NUM) {
            try {
                jedis = getPool(ip, port).getResource();
            } catch (Exception e) {
                LOG.error("get redis failed ! " + e.getMessage(), e);
                count++;
            }
        }
        return jedis;
    }

    /**
     * @Description: 释放jedis到jedisPool中
     * @Param: [jedis, ip, port]
     * @return: void
     * @Author: imdalai
     * @Date: 2018/1/15
     */
    public void closeRedis(Jedis jedis) {

        if (jedis != null) {
            try {
                jedis.close();
            } catch (Exception e) {
                LOG.error("colse jedis failed ! " + e.getMessage(), e);
            }
        }
    }
}

4.进入到redis目录下

查进程ps –ef|grep redis

 

停止

金沙注册送58 38

终止后需求重新起动才能进来

金沙注册送58 39

 

 

键(key)

public static void testKey() {
    System.out.println("====key功能展示====");
    try {
        jedis.select(0);
        System.out.println("清除数据:" + jedis.flushDB());
        System.out.println("判断某个键是否存在:" + jedis.exists("1"));
        System.out.println("新增{1,a}键值对:" + jedis.set("1", "a"));
        System.out.println(jedis.exists("1"));
        System.out.println("新增{2,b}键值对:" + jedis.set("2", "b"));
        System.out.println("系统中所有的键如下:" + jedis.keys("*").toString());
        System.out.println("删除键 1:" + jedis.del("1"));
        System.out.println("判断键 1是否存在:" + jedis.exists("1"));
        System.out.println("设置键 2的过期时间为5s:" + jedis.expire("2", 5));
        TimeUnit.SECONDS.sleep(2);
        System.out.println("查看键 2的剩余生存时间:" + jedis.ttl("2"));
        System.out.println("移除键 2的生存时间:" + jedis.persist("2"));
        System.out.println("查看键 2的剩余生存时间:" + jedis.ttl("2"));
        System.out.println("查看键 2所存储的值的类型:" + jedis.type("2"));
        System.out.println("查看键 2的值:" + jedis.get("2"));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

出口结果:

====key成效显示====
裁撤数据:OK
判定有个别键是或不是留存:false
新增{1,a}键值对:OK
true
新增{2,b}键值对 :OK
系统中具有的键如下:[1, 2]
删除键 1:1
判定键 1是不是留存:false
设置键 2的超时时间为5s:1
查看键 2的剩下生存时间:3
移除键 2的生活时间:1
查看键 2的盈余生存时间:-1
查看键 2所蕴藏的值的门类:string
查看键 2的值:b

cd /usr/local/redis/

叁 、redis的特色【多数据库】

当先45%据库

每一种数据库对外都以以四个从0开始的递增数字命名,不辅助自定义的    

redis私下认可辅助14个数据库,能够透过修改databases参数来修改这一个暗中同意值

redis暗中同意选用的是0号数据库

SELECT 数字: 能够切换数据库

四个数据库之间并不是完全隔离的,flushall

 

 

 

0-15,修改配置文件(修改数值)

 

金沙注册送58 40

 

金沙注册送58 41

数据库之间是互相隔绝的

金沙注册送58 42

清空全部的数据库(停掉那个命令)

金沙注册送58 43

 

字符串、整型和浮点数

string是redis最中心的花色,你能够领略成与Memcached一模一样的档次,一个key对应一个value。

string类型是二进制安全的。意思是redis的string能够包涵别的数据。比如jpg图片可能种类化的目标。

string类型是Redis最宗旨的数据类型,2个键最大能积存512MB。

字符串

public static void testString() {
    try {
        jedis.select(1);
        jedis.flushDB();
        System.out.println("====字符串功能展示====");
        System.out.println("增:");
        System.out.println(jedis.set("a", "1"));
        System.out.println(jedis.set("b", "2"));
        System.out.println(jedis.set("c", "3"));
        System.out.println("删除键 a:" + jedis.del("a"));
        System.out.println("获取键 a:" + jedis.get("a"));
        System.out.println("修改键 b:" + jedis.set("b", "bChanged"));
        System.out.println("获取键 b 的值:" + jedis.get("b"));
        System.out.println("在键 c后面加入值:" + jedis.append("c", "End"));
        System.out.println("获取键 c的值:" + jedis.get("c"));
        System.out.println("增加多个键值对:" + jedis.mset("key01", "value01", "key02", "value02", "key03", "value03"));
        System.out.println("获取多个键值对:" + jedis.mget("key01", "key02", "key03"));
        System.out.println("获取多个键值对:" + jedis.mget("key01", "key02", "key03", "key04"));
        System.out.println("删除多个键值对:" + jedis.del(new String[]{"key01", "key02"}));
        System.out.println("获取多个键值对:" + jedis.mget("key01", "key02", "key03"));

        jedis.flushDB();
        System.out.println("新增键值对防止覆盖原先值:");
        System.out.println(jedis.setnx("key001", "value001"));
        System.out.println(jedis.setnx("key002", "value002"));
        System.out.println(jedis.setnx("key002", "value002-new"));
        System.out.println("获取键key001的值:" + jedis.get("key001"));
        System.out.println("获取键key002的值:" + jedis.get("key002"));

        System.out.println("新增键值对并设置有效时间:");
        System.out.println(jedis.setex("key003", 2, "value003"));
        System.out.println("获取键key003的值:" + jedis.get("key003"));
        TimeUnit.SECONDS.sleep(3);
        System.out.println("获取键key003的值:" + jedis.get("key003"));

        System.out.println("获取原值,更新为新值:");
        System.out.println(jedis.getSet("key002", "key2GetSet"));
        System.out.println("获取键key002的值:" + jedis.get("key002"));

        System.out.println("截取key002的值的字符串:" + jedis.getrange("key002", 2, 5));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

出口结果:

====字符串功效体现====
增:
OK
OK
OK
删除键 a:1
获取键 a:null
修改键 b:OK
获取键 b 的值:bChanged
在键 c后边参与值:4
获取键 c的值:3End
追加三个键值对:OK
获得多少个键值对:[value01, value02, value03]
获取多个键值对:[value01, value02, value03, null]
删除五个键值对:2
得到七个键值对:[null, null, value03]
增加产量键值对防备覆盖原先值:
1
1
0
获取键key001的值:value001
获取键key002的值:value002
增加产量键值对并安装有效时间:
OK
获取键key003的值:value003
获取键key003的值:null
得到原值,更新为新值:
value002
获取键key002的值:key2GetSet
截取key002的值的字符串:y2Ge

平头和浮点数

public static void testNumber() {
    try {
        jedis.select(2);
        jedis.flushDB();
        System.out.println("====整数和浮点数功能展示====");
        jedis.set("key001", "1");
        jedis.set("key002", "2");
        jedis.set("key003", "3.3");
        System.out.println("获取键key001的值:" + jedis.get("key001"));
        System.out.println("获取键key002的值:" + jedis.get("key002"));
        System.out.println("将键key001的值+1:" + jedis.incr("key001"));
        System.out.println("获取键key001的值:" + jedis.get("key001"));
        System.out.println("将键key002的值-1:" + jedis.decr("key002"));
        System.out.println("获取键key002的值:" + jedis.get("key002"));
        System.out.println("将key001的值加上整数5:" + jedis.incrBy("key001", 5));
        System.out.println("获取key001的值:" + jedis.get("key001"));
        System.out.println("将key002的值减去整数5:" + jedis.decrBy("key002", 5));
        System.out.println("获取key002的值:" + jedis.get("key002"));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

出口结果:

====整数和浮点数成效展示====
获取键key001的值:1
获取键key002的值:2
将键key001的值+1:2
获取键key001的值:2
将键key002的值-1:1
获取键key002的值:1
将key001的值加上整数5:7
获取key001的值:7
将key002的值减去整数5:-4
获取key002的值:-4

5.生成

④ 、redis基础命令

收获符合规则的键名称

keys 表达式(?,* ,[],\?)

判断二个键是还是不是存在

exists key

删除键

del key

del key1 key2

批量刨除

redis-cli del `redis-cli keys “key*”`

赢得键值的数据类型type

再次来到值也许是那五系列型(string,hash,list,set,zset)

注意:redis不区分命令大小写

 

 

 

List(列表)

Redis
列表是简简单单的字符串列表,根据插入顺序排序。你能够增加3个要素到列表的尾部(左侧)或然底部(右侧)。

public static void testList() {

    jedis.select(3);
    jedis.flushDB();
    System.out.println("====列表list功能展示====");
    jedis.lpush("collections", "ArrayList", "LinkedList", "Vector", "Stack", "queue");
    jedis.lpush("collections", "HashMap");
    jedis.lpush("collections", "HashMap");
    jedis.lpush("collections", "HashMap");
    jedis.lpush("collections", "HashMap");
    jedis.lpush("number", "1");
    jedis.lpush("number", "2");
    jedis.lpush("number", "3");
    // -1 代表倒数第一个
    System.out.println("collections 的内容:" + jedis.lrange("collections", 0, -1));
    System.out.println("collections区间0-2内容:" + jedis.lrange("collections", 0, 2));
    System.out.println("=================");
    // 删除列表指定的值 ,第二个参数为删除的个数(有重复时),后add进去的值先被删,类似于出栈
    System.out.println("删除指定元素个数:" + jedis.lrem("collections", 2, "HashMap"));
    System.out.println("collections 的内容:" + jedis.lrange("collections", 0, -1));
    System.out.println("删除区间0-4以外的数据:" + jedis.ltrim("collections", 0, 4));
    System.out.println("collections 的内容:" + jedis.lrange("collections", 0, -1));
    System.out.println("collections列表出栈(左端):" + jedis.lpop("collections"));
    System.out.println("collections的内容:" + jedis.lrange("collections", 0, -1));
    System.out.println("collections添加元素,从列表右端,与lpush相对应:" + jedis.rpush("collections", "EnumMap"));
    System.out.println("collections的内容:" + jedis.lrange("collections", 0, -1));
    System.out.println("collections列表出栈(右端):" + jedis.rpop("collections"));
    System.out.println("collections的内容:" + jedis.lrange("collections", 0, -1));
    System.out.println("修改collections指定下标1的内容:" + jedis.lset("collections", 1, "LinkedArrayList"));
    System.out.println("collections的内容:" + jedis.lrange("collections", 0, -1));
    System.out.println("=================");
    System.out.println("collections的长度:" + jedis.llen("collections"));
    System.out.println("获取collections下标为2的元素:" + jedis.lindex("collections", 2));
    System.out.println("=================");
    jedis.lpush("sortedList", "3", "6", "2", "0", "7", "4");
    System.out.println("sortedList排序前:" + jedis.lrange("sortedList", 0, -1));
    System.out.println(jedis.sort("sortedList"));
    System.out.println("sortedList排序后:" + jedis.lrange("sortedList", 0, -1));

    System.out.println("");  
}

输出结果:

====列表list作用体现====
collections 的内容:[HashMap, HashMap, HashMap, HashMap, queue,
Stack, Vector, LinkedList, ArrayList]
collections区间0-2内容:[HashMap, HashMap, HashMap]
=================
除去钦点成分个数:2
collections 的内容:[HashMap, HashMap, queue, Stack, Vector,
LinkedList, ArrayList]
删除区间0-4以外的数码:OK
collections 的内容:[HashMap, HashMap, queue, Stack, Vector]
collections列表出栈(左端):HashMap
collections的内容:[HashMap, queue, Stack, Vector]
collections添法郎素,从列表右端,与lpush相对应:5
collections的内容:[HashMap, queue, Stack, Vector, EnumMap]
collections列表出栈(右端):EnumMap
collections的内容:[HashMap, queue, Stack, Vector]
修改collections钦定下标1的情节:OK
collections的内容:[HashMap, LinkedArrayList, Stack, Vector]
=================
collections的长度:4
获取collections下标为2的元素:Stack
================
sortedList排序前:[4, 7, 0, 2, 6, 3]
[0, 2, 3, 4, 6, 7]
sortedList排序后:[4, 7, 0, 2, 6, 3]

sudo make

keys *(查询全部的键,*是通配符)

金沙注册送58 44

keys crxy*

 

key crxy?

金沙注册送58 45

\?(转义字符查询问号)

集合(Set)

Redis的Set是string类型的冬季集聚。

集合是通过哈希表达成的,所以添加,删除,查找的复杂度都以O(1)。

public static void testSet() {
    try {
        jedis.select(4);
        jedis.flushDB();
        System.out.println("========测试集合(set)=========");
        System.out.println("集合set添加数据:" + jedis.sadd("setElement", "e1", "e7", "e3", "e6", "e0", "e4"));
        System.out.println(jedis.sadd("setElement", "e6"));
        System.out.println("setElement的所有元素:" + jedis.smembers("setElement"));
        System.out.println("删除元素e0:" + jedis.srem("setElement", "e0"));
        System.out.println("setElement的所有元素:" + jedis.smembers("setElement"));
        System.out.println("删除两个元素e7和e6:" + jedis.srem("setElement", "e7", "e6"));
        System.out.println("setElement的所有元素为:" + jedis.smembers("setElement"));
        System.out.println("随机的移除集合中的一个元素:" + jedis.spop("setElement"));
        System.out.println("随机的移除集合中的一个元素:" + jedis.spop("setElement"));
        System.out.println("setElement的所有元素为:" + jedis.smembers("setElement"));
        System.out.println("setElement中包含元素的个数:" + jedis.scard("setElement"));
        System.out.println("e3是否在setElement中:" + jedis.sismember("setElement", "e3"));
        System.out.println("e1是否在setElement中:" + jedis.sismember("setElement", "e1"));

        System.out.println("=================");
        System.out.println(jedis.sadd("setElement1", "e1", "e2", "e4", "e3", "e0", "e8", "e7", "e5"));
        System.out.println(jedis.sadd("setElement2", "e1", "e2", "e4", "e3", "e0", "e8"));
        System.out.println("将setElement1中删除e1并存入setElement3中:" + jedis.smove("setElement1", "setElement3", "e1"));
        System.out.println("将setElement1中删除e2并存入setElement3中:" + jedis.smove("setElement1", "setElement3", "e2"));
        System.out.println("setElement1中的元素:" + jedis.smembers("setElement1"));
        System.out.println("setElement3中的元素:" + jedis.smembers("setElement3"));

        System.out.println("集合运算:");
        System.out.println("setElement1中的元素:" + jedis.smembers("setElement1"));
        System.out.println("setElement2中的元素:" + jedis.smembers("setElement2"));
        System.out.println("setElement1和setElement2的交集:" + jedis.sinter("setElement1", "setElement2"));
        System.out.println("setElement1和setElement2的并集:" + jedis.sunion("setElement1", "setElement2"));
        // setElement1中有,setElement2中没有
        System.out.println("setElement1和setElement2的差集:" + jedis.sdiff("setElement1", "setElement2"));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出结果:

========测试集合(set)=========
集合set添加多少:6
0
setElement的保有因素:[e3, e6, e1, e7, e0, e4]
删除成分e0:1
setElement的富有因素:[e6, e3, e1, e7, e4]
除去两个要素e7和e6:2
setElement的有着因素为:[e3, e1, e4]
随便的移除集合中的多个成分:e3
随机的移除集合中的2个要素:e4
setElement的具有因素为:[e1]
setElement中带有成分的个数:1
e3是否在setElement中:false
e1是否在setElement中:true
=================
8
6
将setElement1中删除e1并存入setElement3中:1
将setElement1中删除e2并存入setElement3中:1
setElement第11中学的成分:[e5, e8, e3, e7, e0, e4]
setElement3中的成分:[e1, e2]
聚拢运算:
setElement第11中学的成分:[e5, e8, e3, e7, e0, e4]
setElement第22中学的成分:[e3, e4, e2, e8, e1, e0]
setElement1和setElement2的交集:[e3, e4, e8, e0]
setElement1和setElement2的并集:[e5, e8, e3, e1, e7, e0, e2, e4]
setElement1和setElement2的差集:[e5, e7]

6.测试,时间会相比长

查询键是还是不是存在exists crxy

 

 

金沙注册送58 46

 

hash

Redis hash 是一个键值(key=>value)对聚集。

Redis
hash是2个string类型的田野先生和value的映射表,hash越发契合用来存款和储蓄对象。

public static void testHash() {

    try {
        System.out.println("=======集合(Set)=======");
        jedis.select(5);
        jedis.flushDB();
        Map<String, String> map = new HashMap<String, String>();
        map.put("key001", "value001");
        map.put("key002", "value002");
        map.put("key003", "value003");
        jedis.hmset("hash", map);
        jedis.hset("hash", "key004", "value004");
        // return Map<String,String>
        System.out.println("散列hash的所有键值对为:" + jedis.hgetAll("hash"));
        // return Set<String>
        System.out.println("散列hash的所有键为:" + jedis.hkeys("hash"));
        // return List<String>
        System.out.println("散列hash的所有值为:" + jedis.hvals("hash"));
        System.out.println("将key006保存的值加上一个整数,如果key006不存在则添加key006:" + jedis.hincrBy("hash", "key006", 6));
        System.out.println("散列hash的所有键值对为:" + jedis.hgetAll("hash"));
        System.out.println("将key006保存的值加上一个整数,如果key006不存在则添加key006:" + jedis.hincrBy("hash", "key006", 3));
        System.out.println("散列hash的所有键值对为:" + jedis.hgetAll("hash"));
        System.out.println("删除一个或者多个键值对:" + jedis.hdel("hash", "key002"));
        System.out.println("散列hash的所有键值对为:" + jedis.hgetAll("hash"));
        System.out.println("散列hash中键值对的个数:" + jedis.hlen("hash"));
        System.out.println("判断hash中是否存在key002:" + jedis.hexists("hash", "key002"));
        System.out.println("判断hash中是否存在key003:" + jedis.hexists("hash", "key003"));
        System.out.println("获取hash中的值:" + jedis.hmget("hash", "key003"));
        System.out.println("获取hash中的值:" + jedis.hmget("hash", "key003", "key004"));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

出口结果:

=======集合(Set)=======
散列hash的具有键值对为:{key004=value004, key003=value003,
key002=value002, key001=value001}
散列hash的全体键为:[key004, key003, key002, key001]
散列hash的全部值为:[value001, value003, value002, value004]
将key006保存的值加上贰个整数,如若key006不设有则添加key006:6
散列hash的具备键值对为:{key004=value004, key003=value003, key006=6,
key002=value002, key001=value001}
将key006保存的值加上贰个平头,就算key006不存在则添加key006:9
散列hash的装有键值对为:{key004=value004, key003=value003, key006=9,
key002=value002, key001=value001}
除去三个要么多个键值对:1
散列hash的有着键值对为:{key004=value004, key003=value003, key006=9,
key001=value001}
散列hash中键值对的个数:4
看清hash中是不是存在key002:false
看清hash中是还是不是存在key003:true
获取hash中的值:[value003]
获取hash中的值:[value003, value004]

sudo make test

删除键

(integer(整数),再次来到值是2,表明成功删除3个)

 

金沙注册送58 47

在外场执行key *操作

金沙注册送58 48

 

在外界批量去除知足某个规则的键,反引号执行命令并收获再次来到值,也正是先实施redis-cli,进入后再实行删除

金沙注册送58 49

 

将下令传给脚本执行

收获键的项目 金沙注册送58 50

 

 

redis的help命令

“help @<group>” to get a list of
commands in <group>

 

“help <command>” for help on
<command>

 

“help <tab>” to get a list of
possible help topics

 

“quit” to exit

 

金沙注册送58 51

 

 

列出的通令都是足以操作string类型的

金沙注册送58 52

 

按tab补全命令(小技巧)

金沙注册送58 53

 

 

一如既往聚集

zset(sorted set:有序聚集)
Redis zset 和 set 一样也是string类型成分的聚集,且不允许再一次的分子。
今非昔比的是各类成分都会波及二个double类型的分数。redis就是通过分数来为汇集中的成员进行从小到大的排序。

zset的成员是唯一的,但分数(score)却得以另行。

public static void testSortSet() {

    try {
        System.out.println("=======有序集合=======");
        jedis.select(6);
        jedis.flushDB();
        Map<String, Double> map = new HashMap<String, Double>();
        map.put("key2", 1.2);
        map.put("key3", 4.0);
        map.put("key4", 5.0);
        map.put("key5", 0.2);
        System.out.println(jedis.zadd("zset", 3, "key1"));
        System.out.println(jedis.zadd("zset", map));
        System.out.println("zset中的所有元素:" + jedis.zrange("zset", 0, -1));
        System.out.println("zset中的所有元素:" + jedis.zrangeWithScores("zset", 0, -1));
        System.out.println("zset中的所有元素:" + jedis.zrangeByScore("zset", 0, 100));
        System.out.println("zset中的所有元素:" + jedis.zrangeByScoreWithScores("zset", 0, 100));
        System.out.println("zset中key2的分值:" + jedis.zscore("zset", "key2"));
        System.out.println("zset中key2的排名:" + jedis.zrank("zset", "key2"));
        System.out.println("删除zset中的元素key3:" + jedis.zrem("zset", "key3"));
        System.out.println("zset中的所有元素:" + jedis.zrange("zset", 0, -1));
        System.out.println("zset中元素的个数:" + jedis.zcard("zset"));
        System.out.println("zset中分值在1-4之间的元素的个数:" + jedis.zcount("zset", 1, 4));
        System.out.println("key2的分值加上5:" + jedis.zincrby("zset", 5, "key2"));
        System.out.println("key3的分值加上4:" + jedis.zincrby("zset", 4, "key3"));
        System.out.println("zset中的所有元素:" + jedis.zrange("zset", 0, -1));

        System.out.println("");

    } catch (Exception e) {
        e.printStackTrace();
    }
}

出口结果:

=======有序集合=======
1
4
zset中的全数因素:[key5, key2, key1, key3, key4]
zset中的全体因素:[[[107, 101, 121, 53],0.2], [[107, 101, 121,
50],1.2], [[107, 101, 121, 49],3.0], [[107, 101, 121,
51],4.0], [[107, 101, 121, 52],5.0]]
zset中的全体因素:[key5, key2, key1, key3, key4]
zset中的全体因素:[[[107, 101, 121, 53],0.2], [[107, 101, 121,
50],1.2], [[107, 101, 121, 49],3.0], [[107, 101, 121,
51],4.0], [[107, 101, 121, 52],5.0]]
zset中key2的分值:1.2
zset中key2的排名:1
删除zset中的成分key3:1
zset中的全体因素:[key5, key2, key1, key4]
zset桐月素的个数:4
zset中分值在1-4中间的要素的个数:2
key2的分值加上5:6.2
key3的分值加上4:4.0
zset中的全数因素:[key5, key1, key3, key4, key2]

7.安装,将redis的通令安装到usr/local/bin/目录中

⑤ 、redis数据类型之string

字符串类型是redis中最大旨的数据类型,它能储存任何情势的剧情,包括二进制数据,甚至是一张图纸(二进制内容)。2个字符串类型的值存款和储蓄的最大容积是1GB

命令

set/get(setnx)

mset/mget

incr/decr/incrby/decrby/incrbyfloat

append(string键,假如储存的是2.1,能够认为那是个字符串,它能够变换为integer也许float类型)

strlen(查看值的长短)

可到官网查阅

 

命令

set/get(setnx)

mset/mget(设置四个键值/查看多少个键值)

金沙注册送58 54

 

setnx会判断是还是不是处在(set直接赋值,不会判断值是或不是留存)

金沙注册送58 55

 

 

incr(每便递扩大1,前提是值是数字类型,若不是则会报错)

金沙注册送58 56

 

 

递减删除1(decr)

金沙注册送58 57

 

历次递扩充几incrby

金沙注册送58 58

 

能够是小数和负数

金沙注册送58 59

 

拼接append,获取字符串长度(strlen)

金沙注册送58 60

 

6表示字符串的长短

 

 

参考

http://www.runoob.com/redis/redis-tutorial.html
redisAPI不难利用
API整理原处-朱小斯

sudo make install

陆 、redis数据类型之hash

hash类型的值存款和储蓄了字段和字段值的投射,字段值只好是字符串,不支持别的数据类型。hash类型的键至多能够储存2^32-贰个字段。

hash类型适合储存对象:如图:1-1和1-2

redis能够为其余键增减字段而不影响别的键

命令

hset/hget/hmset/hmget/hgetall(hsetnx)

hexists,判断键中的属性是还是不是留存

hincrby(hash类型没有hincr命令)

hdel

hkeys/hvals

hlen(获取键中包涵多少个字段)

 

 

 

 

金沙注册送58 61

key=value

(键=值)

 

金沙注册送58 62

hset(储存)user:100(那是个有意义键名,用户:用户ID,方便未来查找),hget(查询)

金沙注册送58 63

 

hmset(同时安装多少个性情),hmget(同时询问七个属性)Gender0、1性别是男或女

金沙注册送58 64

hsetnx(假使有就创办,不然不创建)

金沙注册送58 65

 

递增操作

hincrby

 

金沙注册送58 66

(hdel)删除有些字段

hget(查询键值)

金沙注册送58 67

 

金沙注册送58 68

 

 

exists user:100(通用查询键是或不是存在)

 

8.安装成功后,进入usr/local/bin/目录中查阅:

七 、redis数据类型之list

list是1个平稳的字符串列表,列表内部贯彻是行使双向链表(linked
list)完成的。

list还能够看成队列使用(后边讲)

2个列表类型的键最多能容纳2^32-三个要素。

命令

lpush/rpush/lpop/rpop

llen/lrange(-1表示最后多个因素的岗位,-2倒数11遍之个要素)

lrem(lrem key count value)count分为两种情景

count > 0 : 从表头先河向表尾搜索,移除与 value 相等的要素,数量为
count 。

count < 0 : 从表尾开端向表头搜索,移除与 value 相等的成分,数量为
count 的相对值。

count = 0 : 移除表中持有与 value 相等的值。

lindex(查询内定角标数据)

lset(修改内定角标的要素)

ltrim(截取)

linsert before|after(向内定成分前后插入成分)

rpoplpush:将成分从1个列表转到另二个列表

 

 

Lpush是左侧插入,rpush是从列表右边插入数据

金沙注册送58 69

 

lpop(从列表左边弹出成分,弹出后正是去除列表中的成分),rpop(从列表左侧弹出成分)

金沙注册送58 70

 

负数正是取得最终三个要素的角标(当不可能获知list里面有稍许个成分时,-1正是最终三个因素的角标)

金沙注册送58 71

 

llen list是收获列表成分的长短

 

金沙注册送58 72

 

lrem list 2
a(正数,从列表的左侧起首查找,将正数个因素删掉,负数便是从左侧查找,删除相对值个成分)

金沙注册送58 73

lrem list -1 a右侧

金沙注册送58 74

lrem list 0 a(倘若是0就会去除全部因素)

金沙注册送58 75

 

lset修改钦赐角标的值

金沙注册送58 76

ltrim截取

金沙注册送58 77

插入

金沙注册送58 78

金沙注册送58 79

金沙注册送58 80

 

金沙注册送58 81

 

cd /usr/local/bin

捌 、redis数据类型之set

set集合中的成分都以不重复的,严节的,贰个集合类型键能够储存至多
2^23-1(long类型的最大值)个因素

set集合类型和list列表类型的相似之处,如图:2-1所示

命令

sadd/smembers/srem/sismember

sdiff/sinter(交集)/sunion(并集)

sdiffstore/sinterstore/sunionstore

scard(获取集合长度)/spop(随机从集合中取出并删除2个要素)

srandmember key [count]

倘诺 count 为正数,且低于集合基数,那么命令归来二个包蕴 count
个因素的数组,数组中的成分各分歧。假使 count
大于等于集合基数,那么重回整个集合。

万一 count 为负数,那么命令归来多个数组,数组中的成分恐怕会再也出现反复,而数组的长短为 count
的相对值。

 

金沙注册送58 82

sadd set a(随机插入a成分到set名称的集纳)smembers
set(获取集合里面包车型大巴享有的要素,成分是冬日,冬辰的)

金沙注册送58 83

Srem set a
b(删除集合里面包车型地铁少数因素)(判断集合是还是不是留存有些成分,重返值1/0(存在/不存在))

金沙注册送58 84

 

sdiff set
set1(求集合set有的成分而集合set1却从不的成分,集合顺序沟通改变求值也会调换)

金沙注册送58 85

 

sinter(求交集,集合顺序不影响)

金沙注册送58 86

并集

金沙注册送58 87

sunionstore aaa set set1 (将set和set1 并集储存在aaa)

金沙注册送58 88

 

金沙注册送58 89

 

金沙注册送58 90

 

srandmember set1
2(从集合中随机再次回到一个元素,2是正数,再次来到值小于等于集合成分数量,成分值不另行)

 

金沙注册送58 91

负数取的因素大概再也

金沙注册送58 92

 

金沙注册送58 93

9.将配置文件复制放到/etc/redis目录下:

sudo cp /usr/local/redis/redis.conf /etc/redis/redis.conf

只怕刚初始etc下没有redis目录,须要协调手动创立1个redis文件夹。

上述在第5步的时候大概会遭遇这样的题材:

You need tcl 8.5 or newer in order to run the Redis testmake: *** [test] Error 1

消除办法:安装tcl

wget http://downloads.sourceforge.net/tcl/tcl8.6.1-src.tar.gz 
sudo tar xzvf tcl8.6.1-src.tar.gz -C /usr/local/ 
cd /usr/local/tcl8.6.1/unix/ 
sudo ./configure 
sudo make 
sudo make install

二、 配置redis:

配备新闻在/etc/redis/redis.conf下,打开sudo vi /etc/redis/redis.conf。

基本配置选项:

绑定ip:bind 127.0.0.1

端口号:port 6379

是否以守护进程运营:daemonize yes  必须改为yes

数据库文件:dbfilename dump.db  

数据库文件存款和储蓄路径:dir
/var/lib/redis  可改可不改,改的话提前创设好文件夹

日志文件:logfile
/var/log/redis/redis-server.log  要求求改,提前创设好文件夹

数据库,默认有16个:database 16

主从复制:slaveof

配置小结:主要更改两块:1,守护进度;2.日志文件路径

三、启动redis:

1.依据计划文件运营redis服务器

sudo redis-server /etc/redis/redis.conf 

2.启动redis客户端:

redis-cli

3.输入ping命令测试:

127.0.0.1:6379> pingPONG

4.关闭redis服务器:

ps aux|grep redis # 查看redis进程号kill -9 pid redis进程号 # 关闭redis服务器

5.切换数据库:私下认可有18个,通过0-15来标识,暗中认可是第②个数据库0号数据库。

select n

④ 、redis的数额操作:

1.redis的蕴藏格式为key-value格式。key是字符串类型,value的体系有5种:string、hash、list、set、zset。

2.redis中关于键的普遍的操作:

   2.1翻看左右的键:keys *

   2.2翻看有些键是还是不是留存,存在重回1不存在再次来到0:exists key1

   2.3查看键的值对应的数据类型:type key1

   2.4去除键值对:del key1 key2

   2.5设置键的超时时间,如若没有点名暗中认可平昔存在:expire key seconds

   2.6查看键的灵光时间:ttl key1

   2.7清空数据库:flushall

3.string类型的基本操作:

3.1保存

set key value  保存单个键值对 mset key1 value1 key2
value2  保存多少个键值对 setex key seconds value  设置键值和过期时间
append key value追加值

3.2获取

get key  获取单个 mget key1 key2  获取多少个

3.3删除

del key

4 hash类型的基本操作:

4.1保存

hset key field value #设置单个属性

hmset key field1 value1 field2 value2 ... #设置多个属性

4.2获取

hkeys key # 获取指定键的所有属性
hget key field # 获取单个属性的值
hmget key field1 field2 ... # 获取多个属性的值
hvals key # 获取所有属性的值

4.3删除

del key # 删除整个hash的键和值
hdel key field1 field2 ... # 删除属性和属性对应的值

4.4关于hash类型的私家知道:

能够将hash类型精晓为用来储存对象:

金沙注册送58 94

5 list类型的基本操作:

5.1保存

lpush key value1 value2 ... #从左侧依次插入数据
rpush key value1 value2 ... #从右侧依次插入数据
linsert key before或after 现有元素 新元素 #从指定元素的前或后插入新元素

5.2获取

lrange key start stop 

start、stop为成分的下标索引,从左边开头,第二个因素为0,-1标识最终贰个要素。获取具有的要素:lrange
key 0 -1

5.3刨除钦点成分

lrem key count value

将列表中前count次出现的值为value的要素移除。

count > 0: 从头到尾移除

count < 0: 从尾到头移除

count = 0: 移除全部

6.set门类的基本操作

本性:冬天汇聚、成分唯一性不另行、没有改动操作

6.1充实元素

sadd key member1 member2 ...

6.2得到成分

smembers key # 返回所有元素

6.3剔除钦点成分

srem key member1 member2 ...

7.zset类型的数额操作

特征:有序聚集、成分唯一性不另行、没有改动操作、每种成分都会涉嫌一个double类型的权重,依据权重从小到大排列

7.1增加

zadd key score1 member1 score2 member2 ...

7.2获取

zrange key start stop  # 根据索引获取

zrangebyscore key min max  # 获取权重在min和max之间的数据
zscore key member  # 返回成员member的score值

7.3删除

zrem key member1 member2 ... # 删除指定元素
zremrangebyscore key min max #删除权重在指定范围的元素

伍 、redis与python进行互动:

1.在虚拟环境中装置redis包:

pip install redis

2.调用模块:

from redis import StrictRedis

3.成立对象:

sr = StrictRedis(host='localhost', port=6379, db=0)  # 默认就是这样的值,不写也行。

4.用sr这么些目的操作redis,将redis中的命令当作函数让sr调用就ok。

6、Django框架中session存款和储蓄到redis中的配置

默许情状下session是储存在数据库中的,不过当用session保存用户的境况时,用户频繁的拜访服务器,会附加数据库的下压力,也会稳中有降用户访问的快慢。为了化解这么些难点将session存款和储蓄到redis中。

先是种配备格局:(不应用Django中session默许的储存格局,直接将session存款和储蓄的地方安插到redis中)

# 1.在虚拟环境中安装包
pip install django-redis-sessions==0.5.6

# 2.在Django项目的settings文件中增加下面的配置
SESSION_ENGINE = 'redis_sessions.session'
SESSION_REDIS_HOST = 'localhost'
SESSION_REDIS_PORT = 6379
SESSION_REDIS_DB = 2
SESSION_REDIS_PASSWORD = ''
SESSION_REDIS_PREFIX = 'session'

其次种配备情势:(先将Django中的缓存设置为redis,然后将session的蕴藏地点设置为Django的缓存中)

#1.先在虚拟环境中安装包
pip install django_redis

#2. 设置redis作为django的缓存设置
CACHES = {
 "default": {
  "BACKEND": "django_redis.cache.RedisCache",
  # 把这里缓存你的redis服务器ip和port
  "LOCATION": "redis://172.16.179.142:6379/12",
  "OPTIONS": {
   "CLIENT_CLASS": "django_redis.client.DefaultClient",
  }
 }
}

# 3.设置redis存储django的session信息
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"

以上那篇Django中redis的应用办法(包蕴安装、配置、运转)就是我分享给大家的全体内容了,希望能给我们1个参阅,也指望我们多多辅助脚本之家。

您或者感兴趣的稿子:

  • NoSQL和Redis简介及Redis在Windows下的装置和利用教程
  • Windows下Redis的安装使用图解
  • redis安装、配置、使用和redis
    php扩大安装教程
  • Redis的Python客户端redis-py安装使用表明文书档案
  • Windows下Redis的装置使用教程
  • python安装与应用redis的方法
  • python中redis的设置和使用
  • Windows下安装Redis及使用Python操作Redis的方法
  • C#
    Redis学习连串(一)Redis下载安装使用
  • linux安装配置及运用redis
  • Redis安装与使用方法小结

相关文章

网站地图xml地图