您的位置:首页 > 数据库 > Redis

Redis安装+Redis持久化配置+jedis基本命令+demo(ubuntu下)

2016-06-04 12:00 941 查看

      Redis配置使用

一、Redis下载

$ wget http://download.redis.io/releases/redis-3.2.0.tar.gz $ tar xzf redis-3.2.0.tar.gz
$ cd redis-3.2.0
$ make PREFIX=/usr/local/redis install #安装到指定目录中

二、Redis配置

2.1、使用Redis启动脚本设置开机自启动

redis_init_script 位于/usr/local/redis/redis/utils

redis_init_script是Redis自带的开机启动配置文件

文件内容如下:

#大致浏览下该启动脚本,发现redis习惯性用监听的端口名作为配置文件等命名,我们后面也遵循这个约定。
#redis服务器监听的端口
REDISPORT=6379
#服务端所处位置,在make install后默认存放与`/usr/local/bin/redis-server`,如果未make install则需要修改该路径,下同。
EXEC=/usr/local/bin/redis-server
#客户端位置
CLIEXEC=/usr/local/bin/redis-cli
#Redis的PID文件位置
PIDFILE=/var/run/redis_${REDISPORT}.pid
#配置文件位置,需要修改
CONF="/etc/redis/${REDISPORT}.conf"

2.2、将redis.conf 文件放到 /etc/redis 下面

   

#创建redis文件夹
mkdir /etc/redis
#改名为6379.conf
cp redis.conf /etc/redis/6379.conf

2.3、将启动脚本复制到 /etc/init.d 目录下,本例将启动脚本命令为redisd

cp redis_init_script /etc/init.d/redisd

2.4、设置为开机启动项

     (1) sudo  apt-get  install  sysv-rc-conf

      (2)sudo  sysv-rc-conf  redisd  on

      (3) 把 redis的bin目录 加入到环境变量

                   export PATH=/usr/local/redis/bin:$PATH

2.5、Redis 启动 关闭 基本命令

       2. 5.1、没有配置开机启动脚本(我们上面配置了开机启动脚本)

              我们首先要进入到 redis/bin 目录下

          2. 5.1.1   Redis启动命令:. /redis-server   /etc/6379.conf   #启动redis并指定配置文件。

            2.5.1.2  #查看redis是否开启成功

                         ps -ef | grep redis

                         sudo netstat -tunpl | grep 6379

               2.5.1.3  Redis进入客户端命令:. /redis-cli

               2.5.1.4  退出客户端命令:quit

                2.5.1.5  关闭 redis

                         pkill redis-server

                         ./redis-cli  shutdown

          2.5.2、设置了开机启动脚本,执行了(2.1-2.4步)

                 redis启动:service redisd start

                 进入客户端:redis-cli

                 redis关闭:service redisd stop

三、Redis 持久化配置

         3.1、修改 redis.conf 文件 (我们复制了一份改名6379.conf,我们此处修改6379.conf,

                此处和我们的 redis_init_script 中的路径有关系)

           3.1.1  #禁用rdb方式

             #save 900 1

             #save 300 10

             #save 60 10000

          3.1.2   #开启aof模式

               appendonly   yes  #开启 aof 模式

                appendfsync everysec  #每秒更新一次

          3.1.3   #指定 rdb文件、appendonly.aof 文件存放位置

                 dir /usr/local/redis/redis/redisdata

          3.1.4    #appendonly.aof默认名字

                  appendfilename "appendonly.aof"

四、java操作Redis

Jedis:

  Jedis是Redis官方推出的一款面向Java的客户端,提供了很多接口供Java语言调用。可以在Redis官网下载,当然还有一些开源爱好者提供的客户端,如Jredis、SRP等等,推荐使用Jedis。

 

Spring Data Redis

  SDR是Spring官方推出,可以算是Spring框架集成Redis操作的一个子框架,封装了Redis的很多命令,可以很方便的使用Spring操作Redis数据库,Spring对很多工具都提供了类似的集成,如Spring Data MongDB…

  这三个究竟有什么区别呢?可以简单的这么理解,Redis是用ANSI C写的一个基于内存的Key-Value数据库,而Jedis是Redis官方推出的面向Java的Client,提供了很多接口和方法,可以让Java操作使用Redis,而Spring Data Redis是对Jedis进行了封装,集成了Jedis的一些命令和方法,可以与Spring整合。在后面的配置文件(redis-context.xml)中可以看到,Spring是通过Jedis类来初始化connectionFactory的

4.1、此处我们用jedis

maven 下载需要的库,配置pom.xml

<dependency>

            <groupId>redis.clients</groupId>

            <artifactId>jedis</artifactId>

            <version>2.8.1</version>

        </dependency>

        <dependency>

            <groupId>commons-pool</groupId>

            <artifactId>commons-pool</artifactId>

            <version>1.6</version>

        </dependency>

4.2、Redis基本数据类型

4.2.1.对value操作的命令

     exists(key):确认一个key是否存在

     del(key):删除一个key

     type(key):返回值的类型

     keys(pattern):返回满足给定pattern的所有key

     randomkey:随机返回key空间的一个key

     rename(oldname, newname):将key由oldname重命名为newname,若newname存在则删除newname表示的key

     dbsize:返回当前数据库中key的数目

     expire:设定一个key的活动时间(s)

     ttl:获得一个key的活动时间

     select(index):按索引查询

     move(key, dbindex):将当前数据库中的key转移到有dbindex索引的数据库

     flushdb:删除当前选择数据库中的所有key

     flushall:删除所有数据库中的所有key

4.2.2.对String操作的命令

     set(key, value):给数据库中名称为key的string赋予值value

     get(key):返回数据库中名称为key的string的value

     getset(key, value):给名称为key的string赋予上一次的value

     mget(key1, key2,…, key N):返回库中多个string(它们的名称为key1,key2…)的value

     setnx(key, value):如果不存在名称为key的string,则向库中添加string,名称为key,值为value

     setex(key, time, value):向库中添加string(名称为key,值为value)同时,设定过期时间time

     mset(key1, value1, key2, value2,…key N, value N):同时给多个string赋值,名称为key i的string赋值value i

     msetnx(key1, value1, key2, value2,…key N, value N):如果所有名称为key i的string都不存在,则向库中添加string,名称           key i赋值为value i

     incr(key):名称为key的string增1操作

     incrby(key, integer):名称为key的string增加integer

     decr(key):名称为key的string减1操作

     decrby(key, integer):名称为key的string减少integer

     append(key, value):名称为key的string的值附加value

     substr(key, start, end):返回名称为key的string的value的子串

4.2.3.对List操作的命令

     rpush(key, value):在名称为key的list尾添加一个值为value的元素

     lpush(key, value):在名称为key的list头添加一个值为value的 元素

     llen(key):返回名称为key的list的长度

     lrange(key, start, end):返回名称为key的list中start至end之间的元素(下标从0开始,下同)

     ltrim(key, start, end):截取名称为key的list,保留start至end之间的元素

     lindex(key, index):返回名称为key的list中index位置的元素

     lset(key, index, value):给名称为key的list中index位置的元素赋值为value

     lrem(key, count, value):删除count个名称为key的list中值为value的元素。count为0,删除所有值为value的元素,count>0      从头至尾删除count个值为value的元素,count<0从尾到头删除|count|个值为value的元素。

     lpop(key):返回并删除名称为key的list中的首元素

     rpop(key):返回并删除名称为key的list中的尾元素

     blpop(key1, key2,… key N, timeout):lpop 命令的block版本。即当timeout为0时,若遇到名称为key i的list不存在或该list为空,则命令结束。如果 timeout>0,则遇到上述情况时,等待timeout秒,如果问题没有解决,则对key i+1开始的list执行pop操作。

     brpop(key1, key2,… key N, timeout):rpop的block版本。参考上一命令。

     rpoplpush(srckey, dstkey):返回并删除名称为srckey的list的尾元素,并将该元素添加到名称为dstkey的list的头部

4.2.4.对Set操作的命令

     sadd(key, member):向名称为key的set中添加元素member

     srem(key, member) :删除名称为key的set中的元素member

     spop(key) :随机返回并删除名称为key的set中一个元素

     smove(srckey, dstkey, member) :将member元素从名称为srckey的集合移到名称为dstkey的集合

     scard(key) :返回名称为key的set的基数

     sismember(key, member) :测试member是否是名称为key的set的元素

     sinter(key1, key2,…key N) :求交集

     sinterstore(dstkey, key1, key2,…key N) :求交集并将交集保存到dstkey的集合

     sunion(key1, key2,…key N) :求并集

     sunionstore(dstkey, key1, key2,…key N) :求并集并将并集保存到dstkey的集合

     sdiff(key1, key2,…key N) :求差集

     sdiffstore(dstkey, key1, key2,…key N) :求差集并将差集保存到dstkey的集合

     smembers(key) :返回名称为key的set的所有元素

     srandmember(key) :随机返回名称为key的set的一个元素

4.2.5.对zset(sorted set)操作的命令

     zadd(key, score, member):向名称为key的zset中添加元素member,score用于排序。如果该元素已经存在,则根据score更新该元素的顺序。

     zrem(key, member) :删除名称为key的zset中的元素member

     zincrby(key, increment, member) :如果在名称为key的zset中已经存在元素member,则该元素的score增加increment;否则向集合中添加该元素,其score的值为increment

     zrank(key, member) :返回名称为key的zset(元素已按score从小到大排序)中member元素的rank(即index,从0开始),若没有member元素,返回“nil”

     zrevrank(key, member) :返回名称为key的zset(元素已按score从大到小排序)中member元素的rank(即index,从0开始),若没有member元素,返回“nil”

     zrange(key, start, end):返回名称为key的zset(元素已按score从小到大排序)中的index从start到end的所有元素

     zrevrange(key, start, end):返回名称为key的zset(元素已按score从大到小排序)中的index从start到end的所有元素

     zrangebyscore(key, min, max):返回名称为key的zset中score >= min且score <= max的所有元素

     zcard(key):返回名称为key的zset的基数

     zscore(key, element):返回名称为key的zset中元素element的score

     zremrangebyrank(key, min, max):删除名称为key的zset中rank >= min且rank <= max的所有元素

     zremrangebyscore(key, min, max) :删除名称为key的zset中score >= min且score <= max的所有元素

     zunionstore / zinterstore(dstkeyN, key1,…,keyN, WEIGHTS w1,…wN, AGGREGATE SUM|MIN|MAX):对N个zset求并集和交集,并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score,在进行AGGREGATE运算前,都要乘以对于的WEIGHT参数。如果没有提供WEIGHT,默认为1。默认的AGGREGATE是SUM,即结果集合中元素的score是所有集合对应元素进行
SUM运算的值,而MIN和MAX是指,结果集合中元素的score是所有集合对应元素中最小值和最大值。

4.2.6.对Hash操作的命令

     hset(key, field, value):向名称为key的hash中添加元素field<—>value

     hget(key, field):返回名称为key的hash中field对应的value

     hmget(key, field1, …,field N):返回名称为key的hash中field i对应的value

     hmset(key, field1, value1,…,field N, value N):向名称为key的hash中添加元素field i<—>value i

     hincrby(key, field, integer):将名称为key的hash中field的value增加integer

     hexists(key, field):名称为key的hash中是否存在键为field的域

     hdel(key, field):删除名称为key的hash中键为field的域

     hlen(key):返回名称为key的hash中元素个数

     hkeys(key):返回名称为key的hash中所有键

     hvals(key):返回名称为key的hash中所有键对应的value

     hgetall(key):返回名称为key的hash中所有的键(field)及其对应的value

4.3、demo

package com.ciri.cache;

import java.util.ArrayList;

import java.util.List;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

import redis.clients.jedis.JedisShardInfo;

import redis.clients.jedis.ShardedJedis;

import redis.clients.jedis.ShardedJedisPool;

/**

 * Created by guo on 16-6-1.

 */

public class RedisTest {

    /**

     * 非切片客户端链接

     */

    private Jedis jedis;

    /**

     * 非切片链接池

     */

    private JedisPool jedisPool;

    /**

     * 切片客户端链接

     */

    private ShardedJedis shardedJedis;

    /**

     * 切片链接池

     */

    private ShardedJedisPool shardedJedisPool;

    private String ip = "127.0.0.1";

    /**

     * 构造函数

     */

    public RedisTest() {

        initialPool();

        initialShardedPool();

        shardedJedis = shardedJedisPool.getResource();

        jedis = jedisPool.getResource();

    }

    private void initialPool() {

        // 池基本配置

        JedisPoolConfig config = new JedisPoolConfig();

        //config.(20);

        config.setMaxIdle(5);

        config.setMaxWaitMillis(1000l);

        config.setTestOnBorrow(false);

        jedisPool = new JedisPool(config, ip, 6379);

    }

    /**

     * 初始化切片池

     */

    private void initialShardedPool() {

        // 池基本配置

        JedisPoolConfig config = new JedisPoolConfig();

        //config.setMaxActive(20);

        config.setMaxIdle(5);

        config.setMaxWaitMillis(1000l);

        config.setTestOnBorrow(false);

        // slave链接

        List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();

        shards.add(new JedisShardInfo(ip, 6379, "master"));

        // 构造池

        shardedJedisPool = new ShardedJedisPool(config, shards);

    }

    public void show() {

        // key检测

        testKey();

        // string检测

        testString();

        // list检测

        testList();

        // set检测

        testSet();

        // sortedSet检测

        testSortedSet();

        // hash检测

        testHash();

        shardedJedisPool.returnResource(shardedJedis);

    }

    private void testKey() {

        System.out.println("=============key==========================");

        // 清空数据

        System.out.println(jedis.flushDB());

        System.out.println(jedis.echo("foo"));

        // 判断key否存在

        System.out.println(shardedJedis.exists("foo"));

        shardedJedis.set("key", "values");

        System.out.println(shardedJedis.exists("key"));

    }

    private void testString() {

        System.out.println("=============String==========================");

        // 清空数据

        System.out.println(jedis.flushDB());

        // 存储数据

        shardedJedis.set("foo", "bar");

        System.out.println(shardedJedis.get("foo"));

        // 若key不存在,则存储

        shardedJedis.setnx("foo", "foo not exits");

        System.out.println(shardedJedis.get("foo"));

        // 覆盖数据

        shardedJedis.set("foo", "foo update");

        System.out.println(shardedJedis.get("foo"));

        // 追加数据

        shardedJedis.append("foo", " hello, world");

        System.out.println(shardedJedis.get("foo"));

        // 设置key的有效期,并存储数据

        shardedJedis.setex("foo", 2, "foo not exits");

        System.out.println(shardedJedis.get("foo"));

        try {

            Thread.sleep(3000);

        } catch (InterruptedException e) {

        }

        System.out.println(shardedJedis.get("foo"));

        // 获取并更改数据

        shardedJedis.set("foo", "foo update");

        System.out.println(shardedJedis.getSet("foo", "foo modify"));

        // 截取value的值

        System.out.println(shardedJedis.getrange("foo", 1, 3));

        System.out.println(jedis.mset("mset1", "mvalue1", "mset2", "mvalue2",

                "mset3", "mvalue3", "mset4", "mvalue4"));

        System.out.println(jedis.mget("mset1", "mset2", "mset3", "mset4"));

        System.out.println(jedis.del(new String[] { "foo", "foo1", "foo3" }));

    }

    private void testList() {

        System.out.println("=============list==========================");

        // 清空数据

        System.out.println(jedis.flushDB());

        // 添加数据

        shardedJedis.lpush("lists", "vector");

        shardedJedis.lpush("lists", "ArrayList");

        shardedJedis.lpush("lists", "LinkedList");

        // 数组长度

        System.out.println(shardedJedis.llen("lists"));

        // 排序

//      System.out.println(shardedJedis.sort("lists"));

        // 字串

        System.out.println(shardedJedis.lrange("lists", 0, 3));

        // 修改列表中单个值

        shardedJedis.lset("lists", 0, "hello list!");

        // 获取列表指定下标的值

        System.out.println(shardedJedis.lindex("lists", 1));

        // 删除列表指定下标的值

        System.out.println(shardedJedis.lrem("lists", 1, "vector"));

        // 删除区间以外的数据

        System.out.println(shardedJedis.ltrim("lists", 0, 1));

        // 列表出栈

        System.out.println(shardedJedis.lpop("lists"));

        // 整个列表值

        System.out.println(shardedJedis.lrange("lists", 0, -1));

    }

    private void testSet() {

        System.out.println("=============set==========================");

        // 清空数据

        System.out.println(jedis.flushDB());

        // 添加数据

        shardedJedis.sadd("sets", "HashSet");

        shardedJedis.sadd("sets", "SortedSet");

        shardedJedis.sadd("sets", "TreeSet");

        // 判断value是否在列表中

        System.out.println(shardedJedis.sismember("sets", "TreeSet"));

        ;

        // 整个列表值

        System.out.println(shardedJedis.smembers("sets"));

        // 删除指定元素

        System.out.println(shardedJedis.srem("sets", "SortedSet"));

        // 出栈

        System.out.println(shardedJedis.spop("sets"));

        System.out.println(shardedJedis.smembers("sets"));

        //

        shardedJedis.sadd("sets1", "HashSet1");

        shardedJedis.sadd("sets1", "SortedSet1");

        shardedJedis.sadd("sets1", "TreeSet");

        shardedJedis.sadd("sets2", "HashSet2");

        shardedJedis.sadd("sets2", "SortedSet1");

        shardedJedis.sadd("sets2", "TreeSet1");

        // 交集

        System.out.println(jedis.sinter("sets1", "sets2"));

        // 并集

        System.out.println(jedis.sunion("sets1", "sets2"));

        // 差集

        System.out.println(jedis.sdiff("sets1", "sets2"));

    }

    private void testSortedSet() {

        System.out.println("=============zset==========================");

        // 清空数据

        System.out.println(jedis.flushDB());

        // 添加数据

        shardedJedis.zadd("zset", 10.1, "hello");

        shardedJedis.zadd("zset", 10.0, ":");

        shardedJedis.zadd("zset", 9.0, "zset");

        shardedJedis.zadd("zset", 11.0, "zset!");

        // 元素个数

        System.out.println(shardedJedis.zcard("zset"));

        // 元素下标

        System.out.println(shardedJedis.zscore("zset", "zset"));

        // 集合子集

        System.out.println(shardedJedis.zrange("zset", 0, -1));

        // 删除元素

        System.out.println(shardedJedis.zrem("zset", "zset!"));

        System.out.println(shardedJedis.zcount("zset", 9.5, 10.5));

        // 整个集合值

        System.out.println(shardedJedis.zrange("zset", 0, -1));

    }

    private void testHash() {

        System.out.println("=============hash==========================");

        // 清空数据

        System.out.println(jedis.flushDB());

        // 添加数据

        shardedJedis.hset("hashs", "entryKey", "entryValue");

        shardedJedis.hset("hashs", "entryKey1", "entryValue1");

        shardedJedis.hset("hashs", "entryKey2", "entryValue2");

        // 判断某个值是否存在

        System.out.println(shardedJedis.hexists("hashs", "entryKey"));

        // 获取指定的值

        System.out.println(shardedJedis.hget("hashs", "entryKey"));

        // 批量获取指定的值

        System.out

                .println(shardedJedis.hmget("hashs", "entryKey", "entryKey1"));

        // 删除指定的值

        System.out.println(shardedJedis.hdel("hashs", "entryKey"));

        // 为key中的域 field 的值加上增量 increment

        System.out.println(shardedJedis.hincrBy("hashs", "entryKey", 123l));

        // 获取所有的keys

        System.out.println(shardedJedis.hkeys("hashs"));

        // 获取所有的values

        System.out.println(shardedJedis.hvals("hashs"));

    }

    /**

     * @param args

     */

    public static void main(String[] args) {

        new RedisTest().show();

    }

}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: