redis安装

最新推荐文章于 2024-05-14 14:06:23 发布

linsa_pursuer

最新推荐文章于 2024-05-14 14:06:23 发布

阅读量227

点赞数

分类专栏：开发工具安装及配置

开发工具安装及配置专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Redis 安装

1、Redis的数据类型：

　　字符串、列表（lists）、集合（sets）、有序集合（sorts sets）、哈希表（hashs）

2、Redis和memcache相比的独特之处：

　　（1）redis可以用来做存储（storge）、而memcache是来做缓存（cache）。这个特点主要是因为其有“持久化”功能

　　（2）存储的数据有“结构”，对于memcache来说，存储的数据，只有一种类型——“字符串”，而redis则可以存储字符串、链表、集合、有序集合、哈序结构

3、持久化的两种方式：

　　Redis将数据存储于内存中，或被配置为使用虚拟内存。

　　实现数据持久化的两种方式：（1）使用截图的方式，将内存中的数据不断写入磁盘（性能高，但可能会引起一定程度的数据丢失）

　　　　　　　　　　　　　　　（2）使用类似mysql的方式，记录每次更新的日志

4、Redis的主从同步：对提高读取性能非常有益

5、Redis服务端的默认端口是6379

Window 下安装

下载地址：https://github.com/MSOpenTech/redis/releases。

Redis 支持 32 位和 64 位。这个需要根据你系统平台的实际情况选择，这里我们下载 Redis-x64-xxx.zip压缩包到 C 盘，解压后，将文件夹重新命名为redis。

打开一个 cmd 窗口使用cd命令切换目录到 C:\redis 运行 redis-server.exe redis.windows.conf 。

如果想方便的话，可以把 redis 的路径加到系统的环境变量里，这样就省得再输路径了，后面的那个 redis.windows.conf 可以省略，如果省略，会启用默认的。输入之后，会显示如下界面：

Redis 安装

这时候另启一个cmd窗口，原来的不要关闭，不然就无法访问服务端了。

切换到redis目录下运行 redis-cli.exe -h 127.0.0.1 -p 6379 。

设置键值对 set myKey abc

取出键值对 get myKey

Redis 安装

Linux 下安装

下载地址：http://redis.io/download，下载最新文档版本。

本教程使用的最新文档版本为 2.8.17，下载并安装：

$ wget http://download.redis.io/releases/redis-2.8.17.tar.gz
$ tar xzf redis-2.8.17.tar.gz
$ cd redis-2.8.17
$ make://download.redis.io/releases/redis-2.8.17.tar.gz
$ tar xzf redis-2.8.17.tar.gz
$ cd redis-2.8.17
$ make

make完后 redis-2.8.17目录下会出现编译后的redis服务程序redis-server,还有用于测试的客户端程序redis-cli,两个程序位于安装目录 src 目录下：

下面启动redis服务.

$ cd src
$ ./redis-server./redis-server

注意这种方式启动redis 使用的是默认配置。也可以通过启动参数告诉redis使用指定配置文件使用下面命令启动。

$ cd src
$ ./redis-server redis.conf./redis-server redis.conf

redis.conf是一个默认的配置文件。我们可以根据需要使用自己的配置文件。

启动redis服务进程后，就可以使用测试客户端程序redis-cli和redis服务交互了。比如：

$ cd src
$ ./redis-cli
redis> set foo bar
OK
redis> get foo
"bar"./redis-cli
redis> set foo bar
OK
redis> get foo
"bar"

Ubuntu 下安装

在 Ubuntu 系统安装 Redi 可以使用以下命令:

$sudo apt-get update
$sudo apt-get install redis-server-get update
$sudo apt-get install redis-server

启动 Redis

$ redis-server-server

查看 redis 是否启动？

$ redis-cli-cli

以上命令将打开以下终端：

redis 127.0.0.1:6379>127.0.0.1:6379>

127.0.0.1 是本机 IP ，6379 是 redis 服务端口。现在我们输入 PING 命令。

redis 127.0.0.1:6379> ping
PONG127.0.0.1:6379> ping
PONG

以上说明我们已经成功安装了redis。

Redis 简介

Redis 配置

笔记列表

   chenming

  203***5172@qq.com

  参考地址

Mac 下安装

1. 官网http://redis.io/ 下载最新的稳定版本,这里是3.2.0

2. sudo mv 到 /usr/local/

3. sudo tar -zxf redis-3.2.0.tar 解压文件

4. 进入解压后的目录 cd redis-3.2.0

5. sudo make test 测试编译

6. sudo make install
chenming
   chenming

  203***5172@qq.com

  参考地址
5个月前 (06-30)
mengjun

813***532@qq.com

mac 下安装也可以使用 homebrew，homebrew 是 mac 的包管理器。

1、执行 brew install redis

2、启动 redis，可以使用后台服务启动 brew services start redis。或者直接启动：redis-server /usr/local/etc/redis.conf

Redis的配置

　　daemonize：如需要在后台运行，把该项的值改为yes

　　pdifile：把pid文件放在/var/run/redis.pid，可以配置到其他地址

　　bind：指定redis只接收来自该IP的请求，如果不设置，那么将处理所有请求，在生产环节中最好设置该项

　　port：监听端口，默认为6379

　　timeout：设置客户端连接时的超时时间，单位为秒

　　loglevel：等级分为4级，debug，revbose，notice和warning。生产环境下一般开启notice

　　logfile：配置log文件地址，默认使用标准输出，即打印在命令行终端的端口上

　　database：设置数据库的个数，默认使用的数据库是0

　　save：设置redis进行数据库镜像的频率

　　rdbcompression：在进行镜像备份时，是否进行压缩

　　dbfilename：镜像备份文件的文件名

　　dir：数据库镜像备份的文件放置的路径

　　slaveof：设置该数据库为其他数据库的从数据库

　　masterauth：当主数据库连接需要密码验证时，在这里设定

　　requirepass：设置客户端连接后进行任何其他指定前需要使用的密码

　　maxclients：限制同时连接的客户端数量

　　maxmemory：设置redis能够使用的最大内存

　　appendonly：开启appendonly模式后，redis会把每一次所接收到的写操作都追加到appendonly.aof文件中，当redis重新启动时，会从该文件恢复出之前的状态

　　appendfsync：设置appendonly.aof文件进行同步的频率

　　vm_enabled：是否开启虚拟内存支持

　　vm_swap_file：设置虚拟内存的交换文件的路径

　　vm_max_momery：设置开启虚拟内存后，redis将使用的最大物理内存的大小，默认为0

　　vm_page_size：设置虚拟内存页的大小

　　vm_pages：设置交换文件的总的page数量

　　vm_max_thrrads：设置vm IO同时使用的线程数量

基本操作：

1）连接操作命令
   quit：关闭连接（connection）
   auth：简单密码认证
   help cmd：查看cmd帮助，例如：help quit

   2）持久化
   save：将数据同步保存到磁盘
   bgsave：将数据异步保存到磁盘
   lastsave：返回上次成功将数据保存到磁盘的Unix时戳
   shundown：将数据同步保存到磁盘，然后关闭服务

   3）远程服务控制
   info：提供服务器的信息和统计
   monitor：实时转储收到的请求
   slaveof：改变复制策略设置
   config：在运行时配置Redis服务器

   4）对value操作的命令
   exists(key)：确认一个key是否存在
   del(key)：删除一个key
   type(key)：返回值的类型
   keys(pattern)：返回满足给定pattern的所有key
   randomkey：随机返回key空间的一个
   keyrename(oldname, newname)：重命名key
   dbsize：返回当前数据库中key的数目
   expire：设定一个key的活动时间（s）
   ttl：获得一个key的活动时间
   select(index)：按索引查询
   move(key, dbindex)：移动当前数据库中的key到dbindex数据库
   flushdb：删除当前选择数据库中的所有key
   flushall：删除所有数据库中的所有key

   5）String
   set(key, value)：给数据库中名称为key的string赋予值value
   get(key)：返回数据库中名称为key的string的value
   getset(key, value)：给名称为key的string赋予上一次的value
   mget(key1, key2,…, key N)：返回库中多个string的value
   setnx(key, value)：添加string，名称为key，值为value
   setex(key, time, value)：向库中添加string，设定过期时间time
   mset(key N, value N)：批量设置多个string的值
   msetnx(key N, value N)：如果所有名称为key i的string都不存在
   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的子串

   6）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之间的元素
   ltrim(key, start, end)：截取名称为key的list
   lindex(key, index)：返回名称为key的list中index位置的元素
   lset(key, index, value)：给名称为key的list中index位置的元素赋值
   lrem(key, count, value)：删除count个key的list中值为value的元素
   lpop(key)：返回并删除名称为key的list中的首元素
   rpop(key)：返回并删除名称为key的list中的尾元素
   blpop(key1, key2,… key N, timeout)：lpop命令的block版本。
   brpop(key1, key2,… key N, timeout)：rpop的block版本。
   rpoplpush(srckey, dstkey)：返回并删除名称为srckey的list的尾元素，

　　　　　　　　　　　　　　并将该元素添加到名称为dstkey的list的头部

   7）Set
   sadd(key, member)：向名称为key的set中添加元素member
   srem(key, member) ：删除名称为key的set中的元素member
   spop(key) ：随机返回并删除名称为key的set中一个元素
   smove(srckey, dstkey, member) ：移到集合元素
   scard(key) ：返回名称为key的set的基数
   sismember(key, member) ：member是否是名称为key的set的元素
   sinter(key1, key2,…key N) ：求交集
   sinterstore(dstkey, (keys)) ：求交集并将交集保存到dstkey的集合
   sunion(key1, (keys)) ：求并集
   sunionstore(dstkey, (keys)) ：求并集并将并集保存到dstkey的集合
   sdiff(key1, (keys)) ：求差集
   sdiffstore(dstkey, (keys)) ：求差集并将差集保存到dstkey的集合
   smembers(key) ：返回名称为key的set的所有元素
   srandmember(key) ：随机返回名称为key的set的一个元素

   8）Hash
   hset(key, field, value)：向名称为key的hash中添加元素field
   hget(key, field)：返回名称为key的hash中field对应的value
   hmget(key, (fields))：返回名称为key的hash中field i对应的value
   hmset(key, (fields))：向名称为key的hash中添加元素field
   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

//验证密码，如果没有设置密码这段代码省略

jedis.auth("password"); 



jedis.connect();//连接

jedis.disconnect();//断开连接



Set<String> keys = jedis.keys("*"); //列出所有的key

Set<String> keys = jedis.keys("key"); //查找特定的key

 



//移除给定的一个或多个key,如果key不存在,则忽略该命令. 

jedis.del("key1");

jedis.del("key1","key2","key3","key4","key5");



//移除给定key的生存时间(设置这个key永不过期)
jedis.persist("key1"); 

//检查给定key是否存在
jedis.exists("key1"); 

//将key改名为newkey,当key和newkey相同或者key不存在时,返回一个错误
jedis.rename("key1", "key2");

//返回key所储存的值的类型。 
//none(key不存在),string(字符串),list(列表),set(集合),zset(有序集),hash(哈希表) 
jedis.type("key1");

//设置key生存时间，当key过期时，它会被自动删除。 
jedis.expire("key1", 5);//5秒过期 
 


//字符串值value关联到key。 
jedis.set("key1", "value1"); 

//将值value关联到key，并将key的生存时间设为seconds(秒)。 
jedis.setex("foo", 5, "haha"); 

//清空所有的key
jedis.flushAll();

//返回key的个数 
jedis.dbSize();

//哈希表key中的域field的值设为value。 
jedis.hset("key1", "field1", "field1-value"); 
jedis.hset("key1", "field2", "field2-value"); 

Map map = new HashMap(); 
map.put("field1", "field1-value"); 
map.put("field2", "field2-value"); 
jedis.hmset("key1", map); 


//返回哈希表key中给定域field的值 
jedis.hget("key1", "field1");

//返回哈希表key中给定域field的值(多个)
List list = jedis.hmget("key1","field1","field2"); 
for(int i=0;i<list.size();i++){ 
   System.out.println(list.get(i)); 
} 

//返回哈希表key中所有域和值
Map<String,String> map = jedis.hgetAll("key1"); 
for(Map.Entry entry: map.entrySet()) { 
   System.out.print(entry.getKey() + ":" + entry.getValue() + "\t"); 
} 

//删除哈希表key中的一个或多个指定域
jedis.hdel("key1", "field1");
jedis.hdel("key1", "field1","field2");

//查看哈希表key中，给定域field是否存在。 
jedis.hexists("key1", "field1");

//返回哈希表key中的所有域
jedis.hkeys("key1");

//返回哈希表key中的所有值
jedis.hvals("key1");



//将值value插入到列表key的表头。 
jedis.lpush("key1", "value1-0"); 
jedis.lpush("key1", "value1-1"); 
jedis.lpush("key1", "value1-2"); 

//返回列表key中指定区间内的元素,区间以偏移量start和stop指定.
//下标(index)参数start和stop从0开始;
//负数下标代表从后开始(-1表示列表的最后一个元素,-2表示列表的倒数第二个元素,以此类推)
List list = jedis.lrange("key1", 0, -1);//stop下标也在取值范围内(闭区间)
for(int i=0;i<list.size();i++){ 
   System.out.println(list.get(i)); 
} 

//返回列表key的长度。 
jedis.llen("key1")



//将member元素加入到集合key当中。 
jedis.sadd("key1", "value0"); 
jedis.sadd("key1", "value1"); 

//移除集合中的member元素。 
jedis.srem("key1", "value1"); 

//返回集合key中的所有成员。 
Set set = jedis.smembers("key1"); 

//判断元素是否是集合key的成员
jedis.sismember("key1", "value2")); 

//返回集合key的元素的数量
jedis.scard("key1");
 
//返回一个集合的全部成员，该集合是所有给定集合的交集
jedis.sinter("key1","key2")
 
//返回一个集合的全部成员，该集合是所有给定集合的并集
jedis.sunion("key1","key2")

//返回一个集合的全部成员，该集合是所有给定集合的差集
jedis.sdiff("key1","key2");

当一个类实现了Serializable接口(该接口仅为标记接口,不包含任何方法定义),表示该类可以序列化.序列化的目的是将一个实现了Serializable接口的对象转换成一个字节序列,可以。把该字节序列保存起来(例如:保存在一个文件里),以后可以随时将该字节序列恢复为原来的对象。甚至可以将该字节序列放到其他计算机上或者通过网络传输到其他计算机上恢复，只要该计算机平台存在相应的类就可以正常恢复为原来的对象。实现：要序列化一个对象，先要创建某些OutputStream对象，然后将其封装在一个ObjectOutputStream对象内，再调用writeObject()方法即可序列化一个对象；反序列化也类似。
注意：使用对象流写入到文件是不仅要保证该对象是序列化的，而且该对象的成员对象也必须是序列化的

方法太多为了方便全部序列化成byte来存储，utils如下：

[java] view plain copy

package com.cslo.info.server.service;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import com.alibaba.fastjson.JSON;
import com.cslo.common.beans.CommonConstant;
import com.cslo.common.email.beans.EmailRecip;
@Slf4j
@Data
public class RedisUtil {
private JedisPool pool = ;
/*最大有效期*/
private static final int EXPIRETIME_MONTH = 60 * 60 * 24 * 30;
/**
* 构造函数
* @param hosts
* @param port
*/
public RedisUtil(String hosts, String port) {
int maxIdle = 20;
int maxTotal = 50;
int timeOut = 5000;
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(maxIdle);
jedisPoolConfig.setMaxTotal(maxTotal);
pool = new JedisPool(jedisPoolConfig, hosts, Integer.parseInt(port), timeOut);
}
/**
* 功能说明: 获取实例
* @return
*/
private Jedis getJedis() {
return pool.getResource();
}
/**
* 功能说明: 资源释放
* @param jedis
*/
private void returnResource(Jedis jedis) {
if (jedis != ) {
pool.returnResource(jedis);
}
}
/**
*
* 功能说明: 插入json格式数据
* @param key
* @param value
*/
public void putJson(String key, Object value) {
putJson(key, value, EXPIRETIME_MONTH);
}
/**
*
* 功能说明: 存放二进制序列化的对象
* @param key
* @param value
* @param expire
*/
public void putObj(String key, Object value, int expire) {
Jedis jedis = ;
try {
jedis = getJedis();
jedis.set(key.getBytes(), serialize(value));
jedis.expire(key, expire);
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
}
/**
*
* 功能说明: 获取对象
* @param key
* @return
*/
@SuppressWarnings("unchecked")
public <T> T getObj(String key) {
Jedis jedis = ;
T data = ;
try {
jedis = getJedis();
data = (T) unserialize(jedis.get(key.getBytes()));
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
return data;
}
/**
*
* 功能说明: 删除对象
* @param key
* @return
*/
public Object delObj(String key) {
Jedis jedis = ;
Object data = ;
try {
jedis = getJedis();
jedis.del(key.getBytes());
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
return data;
}
/**
*
* 功能说明: 插入json格式数据
* @param key
* @param value
* @param expire
*/
public void putJson(String key, Object value, int expire) {
Jedis jedis = ;
try {
jedis = getJedis();
jedis.set(key, JSON.toJSONString(value));
jedis.expire(key, expire);
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
}
/**
* 功能说明: 获取对象
* @param key
* @return
*/
public String getJson(String key) {
Jedis jedis = ;
try {
jedis = getJedis();
return jedis.get(key);
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
return ;
}
public <T> T getJson(String key, Class<T> clazz) {
String result = getJson(key);
if (result != ) {
return JSON.parseObject(result, clazz);
}
return ;
}
/**
* 功能说明: 插入数据
* @param key
* @param value
*/
public void put(String key, Serializable value) {
put(key, value, EXPIRETIME_MONTH);
}
/**
* 功能说明: 插入数据，指定过期时间
* @param key
* @param value
* @param expire 过期时间
*/
public void put(String key, Serializable value, int expire) {
Jedis jedis = ;
try {
jedis = getJedis();
byte[] keyb = serialize(key);
jedis.set(keyb, serialize(value));
jedis.expire(keyb, expire);
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
}
/**
* 功能说明: 获取对象
* @param key
* @return
*/
public Object get(String key) {
Jedis jedis = ;
Object data = ;
try {
jedis = getJedis();
data = unserialize(jedis.get(serialize(key)));
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
return data;
}
/**
* 功能说明: 获取key的剩余生存时间
* @param key
* @return
*/
public Long getExpireTime(Serializable key) {
Jedis jedis = ;
Long time = 0l;
try {
jedis = getJedis();
time = jedis.ttl(serialize(key));
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
return time;
}
/**
* 功能说明: 判断key是否存在
* @param key
* @return
*/
public boolean existKey(Serializable key) {
Jedis jedis = ;
boolean flag = true;
try {
jedis = getJedis();
flag = jedis.exists(serialize(key));
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
return flag;
}
/**
* 功能说明: 设置超时时间
* @param key
* @param expire
*/
public void expireKey(Serializable key, int expire) {
Jedis jedis = ;
try {
jedis = getJedis();
jedis.expire(serialize(key), expire);
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
}
/**
* 功能说明: 删除对象
* @param key
* @return
*/
public Object del(Serializable key) {
Jedis jedis = ;
Object data = ;
try {
jedis = getJedis();
jedis.del(serialize(key));
} catch (Exception e) {
log.error("Redis操作失败{}", e);
} finally {
returnResource(jedis);
}
return data;
}
/**
* 序列化
*
* @param object
* @return
*/
private byte[] serialize(Object object) {
ObjectOutputStream obi = ;
ByteArrayOutputStream bai = ;
try {
bai = new ByteArrayOutputStream();
obi = new ObjectOutputStream(bai);
obi.writeObject(object);
byte[] byt = bai.toByteArray();
return byt;
} catch (IOException e) {
e.printStackTrace();
}
return ;
}
/**
* 反序列化
*
* @param bytes
* @return
*/
private Object unserialize(byte[] bytes) {
ByteArrayInputStream bais = ;
try {
// 反序列化
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {
}
return ;
}
public static void main(String[] args) throws InterruptedException {
String hosts = "127.0.0.1";
String port = "6379";
RedisUtil rm = new RedisUtil(hosts, port);
/* rm.existKey("fsdgfgsdghfds");
System.out.println("-----" + rm.getExpireTime("fsdgfgsdghfds"));
System.out.println("-----" + rm.get("fsdgfgsdghfds"));*/
/* List<EmailRecip> list = new ArrayList<EmailRecip>();
EmailRecip vo = new EmailRecip();
vo.setAdressType("test");
vo.setEmailAdress("66666");
list.add(vo);
rm.putObj("rrrr", list, 100);
List<EmailRecip> o = (List<EmailRecip>)rm.getObj("obj");
System.out.println(o.get(0).getAdressType());*/
/* String key = "rrteerqw2222";
rm.put(key, "123456");
System.out.println(rm.get(key));
System.out.println("当前剩余时间-----"+rm.getExpireTime(key));*/
/* Thread.sleep(5000);
System.out.println("sleep后剩余时间-----"+rm.getExpireTime(key));
rm.put(key, "123456");
System.out.println("重置后剩余时间-----"+rm.getExpireTime(key));*/
}
}