自学redis

redis简介

什么是redis

Redis:REmote DIctionary Server(远程字典服务器)

是完全开源免费的，用C语言编写的，遵守BSD协议，

是一个高性能的(key/value)分布式内存数据库，基于内存运行

并支持持久化的NoSQL数据库，是当前最热门的NoSql数据库之一,

也被人们称为数据结构服务器

 

作用：

1:内存存储和持久化：redis支持异步将内存中的数据写到硬盘上，同时不影响继续服务

2:取最新N个数据的操作，如：可以将最新的10条评论的ID放在Redis的List集合里面

3:模拟类似于HttpSession这种需要设定过期时间的功能

4:发布、订阅消息系统

5:定时器、计数器

 

特点：

1: Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用

2: Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储

3:Redis支持数据的备份，即master-slave模式的数据备份

 

如何获取redis

1: http://redis.io/

2: http://www.redis.cn/

 

安装和配置

1：安装过程（redis被默认安装到了/usr/local/bin 下）

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

$ tar xzf redis-5.0.3.tar.gz

$ cd redis-5.0.3

$ make

 

安装过程可能出现的问题：

如果make出现问题提示gcc之类的异常是因为我们的linux上没有安装gcc

make[3]: 进入目录“/opt/redis-3.0.4/deps/hiredis”

gcc -std=c99 -pedantic -c -O3 -fPIC  -Wall -W -Wstrict-prototypes -Wwrite-strings -g -ggdb  net.c

make[3]: gcc：命令未找到

make[3]: *** [net.o] 错误 127

make[3]: 离开目录“/opt/redis-3.0.4/deps/hiredis”

make[2]: *** [hiredis] 错误 2

make[2]: 离开目录“/opt/redis-3.0.4/deps”

make[1]: [persist-settings] 错误 2 (忽略)

    CC adlist.o

/bin/sh: cc: 未找到命令

make[1]: *** [adlist.o] 错误 127

make[1]: 离开目录“/opt/redis-3.0.4/src”

make: *** [all] 错误 2

 

CentOS默认没有安装gcc，这会导致我们无法make成功。使用yum安装：

yum -y install gcc

 

make时报如下错误：

zmalloc.h:50:31: error: jemalloc/jemalloc.h: No such file or directory

zmalloc.h:55:2: error: #error "Newer version of jemalloc required"

make[1]: *** [adlist.o] Error 1

make[1]: Leaving directory `/data0/src/redis-2.6.2/src'

make: *** [all] Error 2

 

原因是jemalloc重载了Linux下的ANSI C的malloc和free函数。解决办法：make时添加参数。

 

make MALLOC=libc

make之后，会出现一句提示

Hint: To run 'make test' is a good idea ;)

但是不测试，通常是可以使用的。若我们运行make test ，会有如下提示

[devnote@devnote src]$ make test

You need tcl 8.5 or newer in order to run the Redis test

make: ***[test] Error_1

 

解决办法是用yum安装tcl8.5（或去tcl的官方网站http://www.tcl.tk/下载8.5版本，并参考官网介绍进行安装）

yum install tcl

 

Make test

Redis常用操作：

2：启动服务

(1) 根目录下启动

进入redis根目录，下的src目录执行命令:  

./redis-server

(2) 指定redis.conf 方式启动

1:拷贝redis.conf 到任意目录下(备份一下配置文件，不要在源文件上面改动内容)

cp redis.conf  ../

1.1:  修改  127.0.0.1  >>>> 0.0.0.0

2:进入备份的redis.conf文件夹下修改配置文件内容

 daemonize yes  推出并保存

     requirepass 123456

 

 

(3)：使用客户端连接redis服务： redis-cli -p 6379

   

使用 ping指令可以测试客户端和服务器端连接是否正常

 

(4)：关闭 退出 重启

 

  shutdown：关闭

  Exitquit：退出

  Systemctl  restart  redis ：重启redis服务

  Dbsize :查看当前key的数量

  Flushdb :删除当前库中所有的key  

flushall :删除所有库的信息

Info：查看数据库的信息

1. 端口号被占用：  netstat -anp | grep 6379

杀死进程：kill -9  4368

登录的 ./redis-cli

       auth  123456

Redis的常用命令

redis是一种高级的key-value的存储系统

其中的key是字符串类型，尽可能满足如下几点：

1）key不要太长，最好不要操作1024个字节，这不仅会消耗内存还会降低查找 效率

2）key不要太短，如果太短会降低key的可读性

3）在项目中，key最好有一个统一的命名规范（根据企业的需求）

其中value 支持五种数据类型：

1）字符串型 string

2）字符串列表 lists

3）字符串集合 sets

4）有序字符串集合 sorted sets

5）哈希类型 hashs

 

我们对Redis的学习，主要是对数据的存储，下面将来学习各种Redis的数据类型的 存储操作：

 

存储字符串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

 

存储lists类型

在Redis中，List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表 一样，我们可以在其头部(left)和尾部(right)添加新的元素。在插入时，如果该键并不 存在，Redis将为该键创建一个新的链表。与此相反，如果链表中所有的元素均被移 除，那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是 4294967295。

    从元素插入和删除的效率视角来看，如果我们是在链表的两头插入或删除元素，这将 会是非常高效的操作，即使链表中已经存储了百万条记录，该操作也可以在常量时间 内完成。然而需要说明的是，如果元素插入或删除操作是作用于链表中间，那将会是 非常低效的。相信对于有良好数据结构基础的开发者而言，这一点并不难理解。

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这个 元素。 

  

存储sets类型

在Redis中，我们可以将Set类型看作为没有排序的字符集合，和List类型一样，我 们也可以在该类型的数据值上执行添加、删除或判断某一元素是否存在等操作。需要 说明的是，这些操作的时间是常量时间。Set可包含的最大元素数是4294967295。

和List类型不同的是，Set集合中不允许出现重复的元素。和List类型相比，Set类 型在功能上还存在着一个非常重要的特性，即在服务器端完成多个Sets之间的聚合计 算操作，如unions、intersections和differences。由于这些操作均在服务端完成， 因此效率极高，而且也节省了大量的网络IO开销

l2）smembers key：获取set中所有的成员l1）sadd key value1、value2…：向set中添加数据，如果该key的值已有则不会   重复添加

l3）scard key：获取set中成员的数量

l4）sismember key member：判断参数中指定的成员是否在该set中，1表示存   在，0表示不存在或者该key本身就不存在 

l5）srem key member1、member2…：删除set中指定的成员

 6）srandmember key：随机返回set中的一个成员 

l7）sdiff sdiff key1 key2：返回key1与key2中相差的成员，而且与key的顺序有   关。即返回差集。 

l8）sdiffstore destination key1 key2：将key1、key2相差的成员存储在   destination上 

l9）sinter key[key1,key2…]：返回交集。 

l10）sinterstore destination key1 key2：将返回的交集存储在destination上

  

l11）sunion key1、key2：返回并集。

l12）sunionstore destination key1 key2：将返回的并集存储在destination上 

  

存储sortedset

Sorted-Sets和Sets类型极为相似，它们都是字符串的集合，都不允许重复的成员出 现在一个Set中。它们之间的主要差别是Sorted-Sets中的每一个成员都会有一个分 数(score)与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序。然 而需要额外指出的是，尽管Sorted-Sets中的成员必须是唯一的，但是分数(score) 却是可以重复的。

在Sorted-Set中添加、删除或更新一个成员都是非常快速的操作，其时间复杂度为 集合中成员数量的对数。由于Sorted-Sets中的成员在集合中的位置是有序的，因此， 即便是访问位于集合中部的成员也仍然是非常高效的。事实上，Redis所具有的这一 特征在很多其它类型的数据库中是很难实现的，换句话说，在该点上要想达到和Redis 同样的高效，在其它数据库中进行建模是非常困难的。

例如：游戏排名、微博热点话题等使用场景。

l1）zadd key score m setember score2 member2 … ：将所有成员以及该成员的 分数存放到sorted-set中 

l2）zcard key：获取集合中的成员数量

l3）zcount key min max：获取分数在[min,max]之间的成员 

lzincrby key increment member：设置指定成员的增加的分数。

lzrange key start end [withscores]：获取集合中脚标为start-end的成员，[withscores]参数表明返回的成员包含其分数。

lzrangebyscore key min max [withscores] [limit offset count]：返回分数在[min,max]的成员并按照分数从低到高排序。[withscores]：显示分数；[limit offset count]：offset，表明从脚标为offset的元素开始并返回count个成员。

lzrank key member：返回成员在集合中的位置。

lzrem key member[member…]：移除集合中指定的成员，可以指定多个成员。

lzscore key member：返回指定成员的分数

存储hash

Redis中的Hashes类型可以看成具有String Key和String Value的map容器。所 以该类型非常适合于存储值对象的信息。如Username、Password和Age等。如果 Hash中包含很少的字段，那么该类型的数据也将仅占用很少的磁盘空间。每一个Hash 可以存储4294967295个键值对。

  1）hset key field value：为指定的key设定field/value对（键值对）。

  2）hgetall key：获取key中的所有filed-vaule

l3）hget key field：返回指定的key中的field的值 

l4）hmset key fields：设置key中的多个filed/value 

l5）hmget key fileds：获取key中的多个filed的值

l6）hexists key field：判断指定的key中的filed是否存在

l7）hlen key：获取key所包含的field的数量

l8）hincrby key field increment：设置key中filed的值增加increment，如：age 增加20

l

事务控制(https://www.runoob.com/redis/redis-transactions.html)

开启事务：

Multi

提交事务

Exec

回滚事务

Discard

Redis事务不具备原子性，只要是正常执行的指令就会正常执行，遇到错误跳过错误，后面指令继续执行。

 

Java连接redis

Redis不仅是使用命令来操作，现在基本上主流的语言都有客户端代码支持，比如java、C、C#、C++、php、Node.js、Go等。

在官方网站里列一些Java的客户端，有Jedis、Redisson、Jredis、JDBC-Redis、等其中官方推荐使用Jedis和Redisson。 在企业中用的最多的就是Jedis，下面我们就重点学习下Jedis。

Jedis同样也是托管在github上，地址：https://github.com/xetorthio/jedis

 

问题:连接出现超时等问题。

解决办法

(1)在Linux找到你的redis.conf配置文件，到该目录下使用命令：vi 配置文件名

 打开配置,将bind 127.0.0.1 注释掉（最前面加个 #）

原因：bind 127.0.0.1是只允许本机访问，就是只允许Linux虚拟机自己访问，而我们要用Windows去访问，显然它不认得

 

(2)关闭防火墙 6379端口有没有开启

Centos版本命令service iptables stop   关闭，重启Redis服务。

在防火墙中过滤掉这个端口

 

(3)设置连接Redis的密码config set requirepass 123456  123456是设置的密码，Java添加设置密码的部分

添加jar包

MAVEN依赖：

<dependency>

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

<version>2.9.0</version>

</dependency>

单实例连接

@Test

public void testJedis() {

//创建一个Jedis的连接

Jedis jedis = new Jedis("127.0.0.1", 6379);

          //密码认证 如果设置了密码，就需要进行认证

jedis.auth("123456");  

//执行redis命令

jedis.set("mytest", "hello world, this is jedis client!");

//从redis中取值

String result = jedis.get("mytest");

//打印结果

System.out.println(result);

//关闭连接

jedis.close();

}

 

连接池连接

@Test

public void testJedisPool() {

//创建一连接池对象

JedisPool jedisPool = new JedisPool("127.0.0.1", 6379);

//从连接池中获得连接

Jedis jedis = jedisPool.getResource();

        //密码认证 如果设置了密码，就需要进行认证

jedis.auth("123456");

String result = jedis.get("mytest");

System.out.println(result);

//关闭连接

jedis.close();

//关闭连接池

jedisPool.close();

}

 

 

Spring整合redis

添加配置文件

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

 

    <groupId>com.hxh</groupId>

    <artifactId>redis01</artifactId>

    <version>1.0-SNAPSHOT</version>

 

    <properties>

        <spring.version>4.1.3.RELEASE</spring.version>

    </properties>

 

    <dependencies>

        <!-- Spring -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-core</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context-support</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-beans</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-tx</artifactId>

            <version>${spring.version}</version>

        </dependency>

 

        <dependency>

            <groupId>commons-logging</groupId>

            <artifactId>commons-logging</artifactId>

            <version>1.1.3</version>

        </dependency>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-simple</artifactId>

            <version>1.7.5</version>

        </dependency>

        <dependency>

            <groupId>redis.clients</groupId>

            <artifactId>jedis</artifactId>

            <version>2.9.0</version>

        </dependency>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.12</version>

            <scope>test</scope>

        </dependency>

    </dependencies>

</project>

 

 

Spring配置文件

<?xml version="1.0" encoding="UTF-8" ?>

<beans

        xmlns="http://www.springframework.org/schema/beans"

        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

        xmlns:p="http://www.springframework.org/schema/p"

        xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">

    <!-- 创建连接池属性配置 -->

    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">

        <!-- 最大连接数 -->

        <property name="maxTotal" value="10"/>

        <!-- 空闲连接数 -->

        <property name="maxIdle" value="2"/>

        <!-- 设置链接池的连接耗尽时，是否等待 -->

        <property name="blockWhenExhausted" value="true"/>

        <!-- 最大等待时间 -->

        <property name="maxWaitMillis" value="30000"/>

        <!-- 获取到连接时，是否检查链接的有效性 -->

        <property name="testOnBorrow" value="true"/>

    </bean>

 

l <!-- 创建jedispool -->

    <bean id="jedisPool" class="redis.clients.jedis.JedisPool" destroy-method="close">

        <!-- 池的属性 -->

        <constructor-arg name="poolConfig" ref="poolConfig"/>

        <!-- redis主机地址 -->

        <constructor-arg name="host" value="10.10.22.189"/>

        <!-- redis主机端口 -->

        <constructor-arg name="port" value="6379"/>

        <!-- redis密码 -->

        <constructor-arg name="password" value="123456"/>

        <!-- 可以选择redis数据库（要选择数据库，必须开启了密码） -->

        <constructor-arg name="database" value="0"/>

        <!-- 链接超时时间 -->

        <constructor-arg name="timeout" value="30000"/>

    </bean>

</beans>

 

测试代码

public static void main(String[] args) {

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-redis.xml");

        JedisPool pool = context.getBean(JedisPool.class);

        Jedis client = pool.getResource();

 

        client.lpush("l111", "aaa","bbb","ccc","ddd","aaa");

        List<String> list = client.lrange("l111", 0, -1);

        for (String s : list) {

            System.out.println(s);

        }

        client.close();

        pool.close();

    }

 

 

 

 

Redis操作java对象

public class SerializeUtil {

    // 序列化

    public static byte[] serialize(Object object) {

        ObjectOutputStream oos = null;

        ByteArrayOutputStream baos = null;

        byte[] bytes = null;

        try {

            baos = new ByteArrayOutputStream();

            oos = new ObjectOutputStream(baos);

            oos.writeObject(object);

            bytes = baos.toByteArray();

        } catch (Exception e) {

            System.err.println("序列化失败" + e.getMessage());

        }

        return bytes;

    }

 

    // 反序列化

    public static Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {

 

        ByteArrayInputStream bais = null;

        ObjectInputStream ois = null;

        try {

            bais = new ByteArrayInputStream(bytes);

            ois = new ObjectInputStream(bais);

        } catch (Exception e) {

            System.err.println("反序列化失败" + e.getMessage());

        }

        return ois.readObject();

    }

}

 

 

具体操作

jedis.set("user".getBytes(), SerializeUtil.serialize(user));

User userResult = (User) SerializeUtil.deserialize(jedis.get("user".getBytes()));