博客分类：
Java操作redis
Java操作redis很简单。创建一个普通的Java工程。然后导入redis依赖的jar包。jar包我已经上传了。
1.入门级的demo
package com.bjsxt.
import redis.clients.jedis.J
public class RedisDemo {
public static Jedis getJedis(){
Jedis jedis =
jedis = new Jedis(FinalCollention.IP, 6379);
//redis服务器的ip和端口
jedis.auth(FinalCollention.PASSWORD);
//连接redis的密码
public void test(){
Jedis jedis =
jedis = getJedis();
jedis.incr("test");
long dbsize = jedis.dbSize();
System.out.println("数据库大小："+dbsize);
System.out.println("测试test的值："+jedis.get("test"));
}catch(Exception e){
e.printStackTrace();
if(jedis != null){
jedis.disconnect();
public static void main(String[] args) {
RedisDemo demo = new RedisDemo();
demo.test();
如果出现Java无法连接redis的异常，主要有三个方面的问题：
1.Java运行的主机ping一下redis服务器所在主机，看能否ping通
2.关闭redis服务器所在主机的防火墙
3.打开redis安装目录下的redis.conf文件。注释掉：bind 127.0.0.1这句话
# Accept connections on the specified port, default is 6379.
# If port 0 is specified Redis will not listen on a TCP socket.
# If you want you can bind a single interface, if the bind option is not
# specified all the interfaces will listen for incoming connections.
# bind 127.0.0.1
"redis.conf" 597L, 25667C written
特别说明：后面的实例，我就不使用try--catch了，但是自己写时一定要记着关闭连接
2.Java操作redis的各种数据结构
package com.bjsxt.
import java.util.HashM
import java.util.L
import java.util.M
import redis.clients.jedis.J
public class RedisDataTypeDemo {
public static Jedis getJedis(){
Jedis jedis =
jedis = new Jedis(FinalCollention.IP, 6379);
//redis服务器的ip和端口
jedis.auth(FinalCollention.PASSWORD);
//连接redis的密码
* @title demoKey
* @description 测试Key
* @author hadoop
public void demoKey(){
Jedis jedis = RedisDataTypeDemo.getJedis();
System.out.println("查看键为aa的是否存在："+jedis.exists("aa"));
System.out.println("查看键为aa的类型："+jedis.type("aa"));
System.out.println("随机获得一个key："+jedis.randomKey());
System.out.println("将aa重命名为bb："+jedis.rename("aa", "bb"));
System.out.println("删除bb："+jedis.del("bb"));
//从上面的方法可以看出，redis提供的接口方法名和redis-cli客户端提供的方法名是一样的，所以，只要对redis客户端的命令熟悉，那么Java操作redis就不是问题
* @title demoString
* @description 测试String
* @author hadoop
public void demoString(){
Jedis jedis = RedisDataTypeDemo.getJedis();
System.out.println("设置name："+jedis.set("name", "小花"));
System.out.println("设置name1："+jedis.set("name1", "小花1"));
System.out.println("设置那么2："+jedis.set("name2", "小花2"));
System.out.println("设置name，如果存在返回0："+jedis.setnx("name", "小花哈哈"));
System.out.println("获取key为name和name1的value值："+jedis.mget("name","name1"));
System.out.println("自增1："+jedis.incr("index"));
System.out.println("自增1："+jedis.incr("index"));
System.out.println("自增2："+jedis.incrBy("count", 2));
System.out.println("自增2："+jedis.incrBy("count", 2));
System.out.println("递减1："+jedis.decr("count"));
System.out.println("递减2："+jedis.decrBy("index",2));
System.out.println("在name后面添加String："+jedis.append("name", ",我爱你"));
System.out.println("获取key为name的值："+jedis.get("name"));
* @title demoList
* @description 测试list数据类型
* @author hadoop
public void demoList(){
Jedis jedis = RedisDataTypeDemo.getJedis();
//在头添加
jedis.lpush("list", "hadoop","hbase","hive","pig","zookeeper");
//在末尾添加
jedis.rpush("list", "java","struts");
//返回长度
jedis.llen("list");
List&String& list = jedis.lrange("list", 0, -1);
for (String string : list) {
System.out.println(string);
* @title demoSet
* @description 测试set数据类型
* @author hadoop
public void demoSet(){
Jedis jedis = RedisDataTypeDemo.getJedis();
jedis.sadd("city", "北京","上海","重启","武汉");
System.out.println("取出最上面的："+jedis.spop("city"));
System.out.println("随机取出一个值"+jedis.srandmember("city"));
jedis.sadd("city2", "北京","武汉","河北","张家界","辽林");
System.out.println("交集："+jedis.sinter("city","city1"));
System.out.println("并集："+jedis.sunion("city","city1"));
System.out.println("差集："+jedis.sdiff("city","city1"));
* @title demoMap
* @description 测试map数据类型
* @author hadoop
public void demoMap(){
Jedis jedis = RedisDataTypeDemo.getJedis();
jedis.hset("Mcity", "c1", "北京");
System.out.println("取值："+jedis.hget("city", "c1"));
Map&String,String& mcity = new HashMap&String, String&();
mcity.put("c1", "桂林");
mcity.put("c2", "天津");
mcity.put("c3", "合肥");
jedis.hmset("Mcity2", mcity);
List&String& list =
jedis.hmget("Mcity2", "c1","c2","c3");
for (String string : list) {
System.out.println(string);
System.out.println(jedis.hlen("Mcity2"));
public static void main(String[] args) {
RedisDataTypeDemo rdr = new RedisDataTypeDemo();
rdr.demoKey();
rdr.demoList();
rdr.demoMap();
rdr.demoSet();
rdr.demoString();
3.Java操作redis的管道
package com.bjsxt.
import redis.clients.jedis.J
import redis.clients.jedis.P
public class RedisPipelineDemo {
public static Jedis getJedis(){
Jedis jedis =
jedis = new Jedis(FinalCollention.IP, 6379);
//redis服务器的ip和端口
jedis.auth(FinalCollention.PASSWORD);
//连接redis的密码
public void hasPipeline(){
Jedis jedis = RedisPipelineDemo.getJedis();
System.out.println("开始："+System.currentTimeMillis());
Pipeline pl = jedis.pipelined();
for(int i = 0 ; i & 1000 ; i++){
pl.incr("testPL");
pl.sync();
System.out.println("开始："+System.currentTimeMillis());
public void noPipeline(){
Jedis jedis = RedisPipelineDemo.getJedis();
System.out.println("开始："+System.currentTimeMillis());
for(int i = 0 ; i & 1000 ; i++){
jedis.incr("testPL");
System.out.println("开始："+System.currentTimeMillis());
4.redis事务
package com.bjsxt.
import java.util.L
import redis.clients.jedis.J
import redis.clients.jedis.T
public class RedisTXDemo {
public static Jedis getJedis(){
Jedis jedis =
jedis = new Jedis(FinalCollention.IP, 6379);
//redis服务器的ip和端口
jedis.auth(FinalCollention.PASSWORD);
//连接redis的密码
* @title txDemo
* @description 没有异常的事务
* @author hadoop
public void txDemo(){
Jedis jedis = getJedis();
//开启事务
Transaction tx = jedis.multi();
tx.set("txcity", "beijin");
tx.sadd("hi", "abc");
tx.get("txcity");
List&Object& objs = tx.exec();
for (Object object : objs) {
System.out.println(object.toString());
* @title txHasExDemo
* @description 含有异常的事务
* @author hadoop
public void txHasExDemo(){
Jedis jedis = getJedis();
//开启事务
Transaction tx = jedis.multi();
tx.set("txcity1", "beijin");
tx.sadd("hi1", "abc");
int i = 1/0;
tx.get("txcity1");
List&Object& objs = tx.exec();
for (Object object : objs) {
System.out.println(object.toString());
public static void main(String[] args) {
RedisTXDemo redisTXDemo = new RedisTXDemo();
redisTXDemo.txDemo();
redisTXDemo.txHasExDemo();
从上面的方法可以看出，redis提供的接口方法名和redis-cli客户端提供的方法名是一样的，所以，只要对redis客户端的命令熟悉，那么Java操作redis就不是问题
(136.2 KB)
下载次数: 101
问一下& 我想把 数据库查询结果集放到redis来储存 如何操作比如 select * from user where username = 'admin'这一条的结果集，在ORM中，得到的是List&User&这样操作吗 jedis.lpush("users", users.toArray());但貌似只能传String类型啊这种情况怎么处理& LZ想这种表结构，我认为最好采用set来保存数据。你的user表肯定有主键，假设主键是uid。表中也有字段，假设含有：username，age。那么查询到了数据List&User& users。使用jedis.hset(uid, "uname",uname);
jedis.hset(uid, "age",age);这样不就可以把表中的数据采用行列倒置的方法保存起来了嘛。 List&User& us = new ArrayList&User&();
for(User temp : us){
jedis.hset(temp.getUid(), "uname",temp.getUserName());
jedis.hset(temp.getUid(), "age",temp.getAge());
}采用唯一键Uid作为set的Key，这样也不会出现key重复的情况
浏览: 220596 次
来自: 北京
浏览量：5971
浏览量：21092
浏览量：11426
浏览量：19602
浏览量：8436
，一直读你的文章，写的真好
博主你好。我这有点问题始终没搞明白。关于继承的在父模块定义了依 ...
java实现excel的导入导出，也可是用插件进行实现的，Pa ...
如何创建空的mave项目，用eclipse建的时候，选择哪个类 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Java中使用Jedis操作redis
package com.
import java.util.HashM
import java.util.I
import java.util.L
import java.util.M
import org.junit.B
import org.junit.T
import redis.clients.jedis.J
public class TestRedis {
public void setup() {
//连接redis服务器，192.168.0.100:6379
jedis = new Jedis(&192.168.0.100&, 6379);
//权限认证
jedis.auth(&admin&);
* redis存储字符串
public void testString() {
//-----添加数据----------
jedis.set(&name&,&xinxin&);//向key--&name中放入了value--&xinxin
System.out.println(jedis.get(&name&));//执行结果：xinxin
jedis.append(&name&, & is my lover&); //拼接
System.out.println(jedis.get(&name&));
jedis.del(&name&);
//删除某个键
System.out.println(jedis.get(&name&));
//设置多个键值对
jedis.mset(&name&,&liuling&,&age&,&23&,&qq&,&476777XXX&);
jedis.incr(&age&); //进行加1操作
System.out.println(jedis.get(&name&) + &-& + jedis.get(&age&) + &-& + jedis.get(&qq&));
* redis操作Map
public void testMap() {
//-----添加数据----------
Map map = new HashMap();
map.put(&name&, &xinxin&);
map.put(&age&, &22&);
map.put(&qq&, &123456&);
jedis.hmset(&user&,map);
//取出user中的name，执行结果:[minxr]--&注意结果是一个泛型的List
//第一个参数是存入redis中map对象的key，后面跟的是放入map中的对象的key，后面的key可以跟多个，是可变参数
List rsmap = jedis.hmget(&user&, &name&, &age&, &qq&);
System.out.println(rsmap);
//删除map中的某个键值
jedis.hdel(&user&,&age&);
System.out.println(jedis.hmget(&user&, &age&)); //因为删除了，所以返回的是null
System.out.println(jedis.hlen(&user&)); //返回key为user的键中存放的值的个数2
System.out.println(jedis.exists(&user&));//是否存在key为user的记录 返回true
System.out.println(jedis.hkeys(&user&));//返回map对象中的所有key
System.out.println(jedis.hvals(&user&));//返回map对象中的所有value
Iterator iter=jedis.hkeys(&user&).iterator();
while (iter.hasNext()){
String key = iter.next();
System.out.println(key+&:&+jedis.hmget(&user&,key));
* jedis操作List
public void testList(){
//开始前，先移除所有的内容
jedis.del(&java framework&);
System.out.println(jedis.lrange(&java framework&,0,-1));
//先向key java framework中存放三条数据
jedis.lpush(&java framework&,&spring&);
jedis.lpush(&java framework&,&struts&);
jedis.lpush(&java framework&,&hibernate&);
//再取出所有数据jedis.lrange是按范围取出，
// 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有
System.out.println(jedis.lrange(&java framework&,0,-1));
jedis.del(&java framework&);
jedis.rpush(&java framework&,&spring&);
jedis.rpush(&java framework&,&struts&);
jedis.rpush(&java framework&,&hibernate&);
System.out.println(jedis.lrange(&java framework&,0,-1));
* jedis操作Set
public void testSet(){
jedis.sadd(&user&,&liuling&);
jedis.sadd(&user&,&xinxin&);
jedis.sadd(&user&,&ling&);
jedis.sadd(&user&,&zhangxinxin&);
jedis.sadd(&user&,&who&);
//移除noname
jedis.srem(&user&,&who&);
System.out.println(jedis.smembers(&user&));//获取所有加入的value
System.out.println(jedis.sismember(&user&, &who&));//判断 who 是否是user集合的元素
System.out.println(jedis.srandmember(&user&));
System.out.println(jedis.scard(&user&));//返回集合的元素个数
public void test() throws InterruptedException {
//jedis 排序
//注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）
jedis.del(&a&);//先清除数据，再加入数据进行测试
jedis.rpush(&a&, &1&);
jedis.lpush(&a&,&6&);
jedis.lpush(&a&,&3&);
jedis.lpush(&a&,&9&);
System.out.println(jedis.lrange(&a&,0,-1));// [9, 3, 6, 1]
System.out.println(jedis.sort(&a&)); //[1, 3, 6, 9]
//输入排序后结果
System.out.println(jedis.lrange(&a&,0,-1));
public void testRedisPool() {
RedisUtil.getJedis().set(&newname&, &中文测试&);
System.out.println(RedisUtil.getJedis().get(&newname&));
redis连接池
package com.
import redis.clients.jedis.J
import redis.clients.jedis.JedisP
import redis.clients.jedis.JedisPoolC
public final class RedisUtil {
//Redis服务器IP
private static String ADDR = &192.168.0.100&;
//Redis的端口号
private static int PORT = 6379;
//访问密码
private static String AUTH = &admin&;
//可用连接实例的最大数目，默认值为8；
//如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_IDLE = 200;
//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
private static int MAX_WAIT = 10000;
private static int TIMEOUT = 10000;
//在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
private static boolean TEST_ON_BORROW =
private static JedisPool jedisPool =
* 初始化Redis连接池
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxActive(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWait(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
} catch (Exception e) {
e.printStackTrace();
* 获取Jedis实例
public synchronized static Jedis getJedis() {
if (jedisPool != null) {
Jedis resource = jedisPool.getResource();
} catch (Exception e) {
e.printStackTrace();
* 释放jedis资源
* @param jedis
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.returnResource(jedis);
MongoDB和Redis区别
MongoDB更类似Mysql，支持字段索引、游标操作，其优势在于查询功能比较强大，擅长查询JSON数据，能存储海量数据，但是不支持事务。
Mysql在大数据量时效率显著下降，MongoDB更多时候作为关系的一种替代。
内存管理机制
Redis数据全部存在内存，定期写入磁盘，当内存不够时，可以选择指定的LRU算法删除数据。
MongoDB数据存在内存，由linuxmmap实现，当内存不够时，只将热点数据放入内存，其他数据存在磁盘。
支持的数据结构
Redis支持的数据结构丰富，包括string hash list set zset 等。
MongoDB数据结构比较单一，但是支持丰富的数据表达，索引，最类似关系型数据库，支持的查询语言非常丰富。
memcache 卖么凯奇的set
在使用缓存的时候，redis比memcached具有更多的优势，并且支持更多的数据类型
no里的redis数据库，，not only sql
Jedis 是 Redis 官方首选的
客户端开发包。
string hash list set zset 五种 serialize
RW-R-R，第一部分RW代表当前用户具有读写的权限。第二部分的R代表当前用户所在的用户组中其他成员只有读得权限，最后一个R
表示额外的其他用户只有读得权限。
二者性能都比较高，应该说都不会是瓶颈。
二者均支持持久化。
MongoDB集群技术比较成熟，Redis从3.0开始支持集群。
不适用场景
? 需要使用复杂sql的操作
? 事务性系统
从以下几个维度，对 redis、memcache、mongoDB 做了对比。
都比较高，性能对我们来说应该都不是瓶颈。
总体来讲，TPS
方面 redis 和 memcache 差不多，要大于 mongodb。
2、操作的便利性 memcache 数据结构单一。（key-value） redis 丰富一些，数据操作方面，redis 更好一些，较少的网络 IO 次数，同时还提供 list，set， hash 等数据结构的存储。 mongodb 支持丰富的数据表达，索引，最类似关系型数据库，支持的查询语言非常丰富。
3、内存空间的大小和数据量的大小 redis 在 2.0 版本后增加了自己的 VM 特性，突破物理内存的限制；可以对 key value 设置过 期时间（类似 memcache） memcache 可以修改最大可用内存,采用 LRU 算法。Memcached 代理软件 magent，比如建立 10 台 4G 的 Memcache 集群，就相当于有了 40G。 magent -s 10.1.2.1 -s 10.1.2.2:11211 -b 10.1.2.3:14000 mongoDB 适合大数据量的存储，依赖操作系统 VM 做内存管理，吃内存也比较厉害，服务 不要和别的服务在一起。
4、可用性（单点问题） 对于单点问题， redis，依赖客户端来实现分布式读写；主从复制时，每次从节点重新连接主节点都要依赖整 个快照,无增量复制，因性能和效率问题， 所以单点问题比较复杂；不支持自动 sharding,需要依赖程序设定一致 hash 机制。 一种替代方案是，不用 redis 本身的复制机制，采用自己做主动复制（多份存储），或者改成 增量复制的方式（需要自己实现），一致性问题和性能的权衡 Memcache 本身没有数据冗余机制，也没必要；对于故障预防，采用依赖成熟的 hash 或者环 状的算法，解决单点故障引起的抖动问题。 mongoDB 支持 master-slave,replicaset（内部采用 paxos 选举算法，自动故障恢复）,auto sharding 机制，对客户端屏蔽了故障转移和切分机制。
5、可靠性（持久化） 对于数据持久化和数据恢复， redis 支持（快照、AOF）：依赖快照进行持久化，aof 增强了可靠性的同时，对性能有所影 响 memcache 不支持，通常用在做缓存,提升性能； MongoDB 从 1.8 版本开始采用 binlog 方式支持持久化的可靠性
6、数据一致性（事务支持） Memcache 在并发场景下，用 cas 保证一致性redis 事务支持比较弱，只能保证事务中的每个操作连续执行 mongoDB 不支持事务
7、数据分析 mongoDB 内置了数据分析的功能(mapreduce),其他不支持
8、应用场景 redis：数据量较小的更性能操作和运算上 memcache：用于在动态系统中减少数据库负载，提升性能;做缓存，提高性能（适合读多写 少，对于数据量比较大，可以采用 sharding） MongoDB:主要解决海量数据的访问效率问题。 表格比较： memcache redis 类型 内存数据库 内存数据库 数据类型 在定义 value 时就要固定数据类型 不需要 有字符串，链表，集 合和有序集合 虚拟内存 不支持 支持 过期策略 支持 支持 分布式 magent master-slave，一主一从或一主多从 存储数据安全 不支持 使用 save 存储到 dump.rdb 中 灾难恢复 不支持 append only file(aof)用于数据恢复 性能
1、类型&&memcache 和 redis 都是将数据存放在内存，所以是内存数据库。当然，memcache 也可用于缓存其他东西，例如图片等等。
2、 数据类型&&Memcache 在添加数据时就要指定数据的字节长度,而 redis 不需要。
3、 虚拟内存&&当物理内存用完时，可以将一些很久没用到的 value 交换到磁盘。
4、 过期策略&&memcache 在 set 时就指定，例如 set key1 0 0 8,即永不过期。Redis 可以通 过例如 expire 设定，例如 expire name 10。
5、 分布式&&设定 memcache 集群，利用 magent 做一主多从;redis 可以做一主多从。都可 以一主一从。
6、 存储数据安全&&memcache 断电就断了，数据没了；redis 可以定期 save 到磁盘。
7、 灾难恢复&&memcache 同上，redis 丢了后可以通过 aof 恢复。【JAVAWEB学习笔记】27_Redis：在Linux上的安装、Jedis和常用命令
来源：博客园
一、Redis简介1．关于关系型数据库和nosql数据库关系型数据库是基于关系表的数据库，最终会将数据持久化到磁盘上，而nosql数据
库是基于特殊的结构，并将数据存储到内存的数据库。从性能上而言，nosql数据库 要优于关系型数据库，从安全性上而言关系型数据库要优于nosql数据库，所以在实
际开发中一个项目中nosql和关系型数据库会一起使用，达到性能和安全性的双保证。 2．为什么要使用Redis 1）易扩展
2）大数据量提高性能
3）多样灵活的数据模型
3．redis在Linux上的安装1）安装redis编译的c环境，yum install gcc-c++2）将redis-2.6.16.tar.gz上传到Linux系统中3）解压到/usr/local下
tar -xvf redis-2.6.16.tar.gz -C /usr/local4）进入redis-2.6.16目录 使用make命令编译redis5）在redis-2.6.16目录中 使用make PREFIX=/usr/local/redis install命令安装
redis到/usr/local/redis中6）拷贝redis-2.6.16中的redis.conf到安装目录redis的bin中7）启动redis 在bin下执行命令redis-server redis.conf8）如需远程连接redis，需配置redis端口6379在linux防火墙中开发/sbin/iptables -I INPUT -p tcp --dport 6379 -j ACCEPT/etc/rc.d/init.d/iptables save 启动后看到如上欢迎页面，但此窗口不能关闭，窗口关闭就认为redis也关闭了解决方案：可以通过修改配置文件配置redis后台启动，即服务器启动了但不会创建控制台窗口将redis.conf文件中的daemonize从no修改成yes表示后台启动 使用命令查看6379端口是否启动ps -ef | grep redis在bin下面使用./redis-cli进入客户端 8）通过后台启动后怎么关闭？
二、使用java去操作Redis 三、Redis的常用命令redis是一种高级的key-value的存储系统其中的key是字符串类型，尽可能满足如下几点：1）key不要太长，最好不要操作1024个字节，这不仅会消耗内存还会降低查找效率2）key不要太短，如果太短会降低key的可读性3）在项目中，key最好有一个统一的命名规范（根据企业的需求）其中value
支持五种数据类型：1）字符串型 string2）字符串列表 lists3）字符串集合 sets4）有序字符串集合 sorted sets5）哈希类型 hashs 我们对Redis的学习，主要是对数据的存储，下面将来学习各种Redis的数据类型的存储操作：
1．存储字符串string字符串类型是Redis中最为基础的数据存储类型，它在Redis中是二进制安全的，这便意味着该类型可以接受任何格式的数据，如JPEG图像数据或Json对象描述信息等。
在Redis中字符串类型的Value最多可以容纳的数据长度是512M
1）set key value：设定key持有指定的字符串value，如果该key存在则进行覆盖操作。总是返回”OK”2）get key：获取key的value。如果与该key关联的value不是String类型，redis
将返回错误信息，因为get命令只能用于获取String value；如果该key不存在，返 回null。
3）getset key value：先获取该key的值，然后在设置该key的值。
4）incr key：将指定的key的value原子性的递增1.如果该key不存在，其初始值
为0，在incr之后其值为1。如果value的值不能转成整型，如hello，该操作将执
行失败并返回相应的错误信息。5）decr key：将指定的key的value原子性的递减1.如果该key不存在，其初始值
为0，在incr之后其值为-1。如果value的值不能转成整型，如hello，该操作将执
行失败并返回相应的错误信息。
6）incrby key increment：将指定的key的value原子性增加increment，如果该
key不存在，器初始值为0，在incrby之后，该值为increment。如果该值不能转成
整型，如hello则失败并返回错误信息7）decrby key decrement：将指定的key的value原子性减少decrement，如果
该key不存在，器初始值为0，在decrby之后，该值为decrement。如果该值不能 转成整型，如hello则失败并返回错误信息
8）append key value：如果该key存在，则在原有的value后追加该值；如果该 key
不存在，则重新创建一个key/value
2．存储lists类型在Redis中，List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表一样，我们可以在其头部(left)和尾部(right)添加新的元素。在插入时，如果该键并不存在，Redis将为该键创建一个新的链表。与此相反，如果链表中所有的元素均被移除，那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是。
从元素插入和删除的效率视角来看，如果我们是在链表的两头插入或删除元素，这将会是非常高效的操作，即使链表中已经存储了百万条记录，该操作也可以在常量时间内完成。然而需要说明的是，如果元素插入或删除操作是作用于链表中间，那将会是非常低效的。相信对于有良好数据结构基础的开发者而言，这一点并不难理解。
1）lpush key value1 value2...：在指定的key所关联的list的头部插入所有的
values，如果该key不存在，该命令在插入的之前创建一个与该key关联的空链
表，之后再向该链表的头部插入数据。插入成功，返回元素的个数。2）rpush key value1、value2…：在该list的尾部添加元素3）lrange key start end：获取链表中从start到end的元素的值，start、end可
为负数，若为-1则表示链表尾部的元素，-2则表示倒数第二个，依次类推…
4）lpushx key value：仅当参数中指定的key存在时（如果与key管理的list中没
有值时，则该key是不存在的）在指定的key所关联的list的头部插入value。5）rpushx key value：在该list的尾部添加元素
6）lpop key：返回并弹出指定的key关联的链表中的第一个元素，即头部元素。7）rpop key：从尾部弹出元素。 8）rpoplpush resource destination：将链表中的尾部元素弹出并添加到头部 9）llen key：返回指定的key关联的链表中的元素的数量。
10）lset key index value：设置链表中的index的脚标的元素值，0代表链表的头元
素，-1代表链表的尾元素。
11）lrem key count value：删除count个值为value的元素，如果count大于0，从头向尾遍历并删除count个值为value的元素，如果count小于0，则从尾向头遍历并删除。如果count等于0，则删除链表中所有等于value的元素。
12）linsert key before|after pivot value：在pivot元素前或者后插入value这个元素。
3．存储sets类型在Redis中，我们可以将Set类型看作为没有排序的字符集合，和List类型一样，我们也可以在该类型的数据值上执行添加、删除或判断某一元素是否存在等操作。需要 说明的是，这些操作的时间是常量时间。Set可包含的最大元素数是。和List类型不同的是，Set集合中不允许出现重复的元素。和List类型相比，Set类 型在功能上还存在着一个非常重要的特性，即在服务器端完成多个Sets之间的聚合计 算操作，如unions、intersections和differences。由于这些操作均在服务端完成， 因此效率极高，而且也节省了大量的网络IO开销
?1）sadd key value1、value2…：向set中添加数据，如果该key的值已有则不会
重复添加?2）smembers key：获取set中所有的成员?3）scard key：获取set中成员的数量
?4）sismember key member：判断参数中指定的成员是否在该set中，1表示存
在，0表示不存在或者该key本身就不存在?5）srem key member1、member2…：删除set中指定的成员
6）srandmember key：随机返回set中的一个成员
?7）sdiff sdiff key1 key2：返回key1与key2中相差的成员，而且与key的顺序有关。即返回差集。
?8）sdiffstore destination key1 key2：将key1、key2相差的成员存储在destination上
?9）sinter key[key1,key2…]：返回交集。?10）sinterstore destination key1 key2：将返回的交集存储在destination上
?11）sunion key1、key2：返回并集。
?12）sunionstore destination key1 key2：将返回的并集存储在destination上
4．存储sortedsetSorted-Sets和Sets类型极为相似，它们都是字符串的集合，都不允许重复的成员出现在一个Set中。它们之间的主要差别是Sorted-Sets中的每一个成员都会有一个分 数(score)与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序。然而需要额外指出的是，尽管Sorted-Sets中的成员必须是唯一的，但是分数(score) 却是可以重复的。在Sorted-Set中添加、删除或更新一个成员都是非常快速的操作，其时间复杂度为 集合中成员数量的对数。由于Sorted-Sets中的成员在集合中的位置是有序的，因此，
即便是访问位于集合中部的成员也仍然是非常高效的。事实上，Redis所具有的这一
特征在很多其它类型的数据库中是很难实现的，换句话说，在该点上要想达到和Redis
同样的高效，在其它数据库中进行建模是非常困难的。例如：游戏排名、微博热点话题等使用场景。
?1）zadd key score member score2 member2 …：将所有成员以及该成员的
分数存放到sorted-set中?2）zcard key：获取集合中的成员数量
?3）zcount key min max：获取分数在[min,max]之间的成员?zincrby key increment member：设置指定成员的增加的分数。?zrange key start end [withscores]：获取集合中脚标为start-end的成员，[withscores]参数表明返回的成员包含其分数。?zrangebyscore key min max [withscores] [limit offset count]：返回分数在[min,max]的成员并按照分数从低到高排序。[withscores]：显示分数；[limit offset count]：offset，表明从脚标为offset的元素开始并返回count个成员。?zrank key member：返回成员在集合中的位置。?zrem key member[member…]：移除集合中指定的成员，可以指定多个成员。?zscore key member：返回指定成员的分数
5．存储hashRedis中的Hashes类型可以看成具有String Key和String Value的map容器。所以该类型非常适合于存储值对象的信息。如Username、Password和Age等。如果 Hash中包含很少的字段，那么该类型的数据也将仅占用很少的磁盘空间。每一个Hash可以存储个键值对。
?1）hset key field value：为指定的key设定field/value对（键值对）。?2）hgetall key：获取key中的所有filed-vaule
?3）hget key field：返回指定的key中的field的值
?4）hmset key fields：设置key中的多个filed/value?5）hmget key fileds：获取key中的多个filed的值?6）hexists key field：判断指定的key中的filed是否存在?7）hlen key：获取key所包含的field的数量?8）hincrby key field increment：设置key中filed的值增加increment，如：age
增加20 总结：1、nosql2、redis安装----linux（重点）3、jedis（重点）4、redis的数据操作类型 5种 (了解) --- string和hash5、redis的其他
免责声明：本站部分内容、图片、文字、视频等来自于互联网，仅供大家学习与交流。相关内容如涉嫌侵犯您的知识产权或其他合法权益，请向本站发送有效通知，我们会及时处理。反馈邮箱&&&&。
学生服务号
在线咨询，奖学金返现，名师点评，等你来互动