redis-笔记

 

适合处理一般量数据，安全， 银行的钱

 

 

 

 

 

应用：内容缓存，主要用于处理大量数据的高访问负载

Redis替代MongoDB

 

 

 

Redis应用场景：

1.关系型数据库的缓存作用

 

2.任务队列

 

3.大量数据运算

 

 

 

 

ps -ef | grep -i redis

 

 

Redis使用的是键值对 保存数据。hashmap

Key:全部都是字符串

Value:五种数据类型String hash   list set 有序set

 

 

 

key名：自定义，key名不要过长，否则影响使用效率。

不要太短，最好有意义。理论上会影响，先查短的

 

4.reids命令-String命令【重点】

字符串类型是redis中最为基础，常用的数据存储类型，字符串在redis中是二进制安全，这便意味着该类型存入和获取的数据相同。在redis中字符串类型的value最多容纳的数据长度是512M.

二进制安全和数据安全是没有关系的。Mysql-关系型数据库，二进制不安全。（乱码丢失数据）。

Redis:

 

mysql

 

 

 

Value 为String  

常用基本命令：set(赋值get取值del删除

 

扩展命令（不常用，了解）：

 

Value为string的使用环境：保存json格式的字符串

 

 

Value -：hash

 

赋值：hset  取值：hmget  删除：del

 

 

Keys * 查询所有的key

 

Jedis

讲到jedis，先来看看redis， redis是当今基本所有互联网产品都在使用的一种提供键值对形式的内存数据库。之所以说是内存数据库，是因为redis基于内存的读取和写入相比传统的数据库基于磁盘IO快上数倍。于是乎redis在现在的应用中使用的非常广泛。主要的作用在于：
1、提供缓存服务，存储访问频率高的热数据防止穿透到数据库
2、在分布式系统中可以作为实现分布式锁的一种实现方案
...
那jedis就是集成了redis的一些命令操作，封装了redis的java客户端。提供了连接池管理。一般不直接使用jedis，而是在其上在封装一层，作为业务的使用。如果用spring的话，可以看看spring 封装的 redis

 

 

 

 

Jedis连接池

 

 

 

 

工具类

 

 

 

Value类型：linkedList

 

为什么redis选取了链表？

Redis操作中，最多的操作是进行元素的增删

链表的元素增删效率高，根据索引取值效率低

使用环境：

1.做大数据集合的增删

2.用户任务队列

 

赋值：lpush rpush   取值：lrange删除：lpop rpop

 

 

 

 

 

 

 

 

 

 

 

4.Value类型：set  -   hashset

redis操作中，涉及到两个大数据集合的并集，交集，差集运算。

 

赋值：sadd key values[value1,vale2]:向set中添加数据，如果该key的值已有则不会重复添加。

取值：smembers key：获取set中所有的成员

sismember key member:判断参数中指定的成员是否再该set中，1表示存在，0表示不存在或者该key本身不存在。(无论集合中有多少元素都可以极速的返回结果)

删值：srem key members [member1,member2]:删除set中指定的成员remove

 

差集运算：sdiff交集运算：sinter  并集运算：sunion

 

 

 

 

 

5.value类型：：-有序set（了解）

应用场景：专门用来做排行榜

 

 

赋值：zadd  查看：zscore  删值：zrem

 

 

 

Redis通用命令（重点）

 

查看：

Keys pattern(模式)：获取所有与pattern匹配的key,返回所有与该key匹配的keys.

*表示任意0个或多个任意字符

？表示任意一个字符

keys * 查询所有的key

 

 

删除：

del  exists

 

 

 

 

5.应用场景与命令：

subsribe channel: 订阅新闻/频道  subscribe mychat 订阅mychat这个频道

Psubsribe  channel*:批量订阅频道，例：psubsribe s*,订阅以“s”开头的频道。

Publish channel content :：在指定的频道中发布消息 Publish(发行) mychat‘today is a newday’

 

 

 

 

 

 

redis持久化（重要）

持久化：把数据保存在硬盘上。

Redis数据存在内存中：，所有的增删改查，数据都是在内存上进行操作，高效丶断电数据就会丢失，所以提供持久化操作来保存数据在硬盘上。

Mysql数据存在硬盘中：读写速度慢于内存，断电数据依然存在

 

 

 

 

 

 

 

七 redis学习笔记之持久化

      redis是一个支持持久化的内存数据库，也就是说redis需要经常将内存中的数据同步到磁盘来保证持久化。redis支持两种持久化方式，一种是Snapshotting（快照）也是默认方式，另一种是Append-only file（缩写aof）的方式。下面分别介绍

Snapshotting
       快照是默认的持久化方式。这种方式是就是将内存中数据以快照的方式写入到二进制文件中,默认的文件名为dump.rdb。可以通过配置设置自动做快照持久化的方式。我们可以配置redis在n秒内如果超过m个key被修改就自动做快照，下面是默认的快照保存配置

save 900 1  #900秒内如果超过1个key被修改，则发起快照保存
save 300 10 #300秒内容如超过10个key被修改，则发起快照保存
save 60 10000

下面介绍详细的快照保存过程

1.redis调用fork,现在有了子进程和父进程。

2. 父进程继续处理client请求，子进程负责将内存内容写入到临时文件。由于os的写时复制机制（copy on write)父子进程会共享相同的物理页面，当父进程处理写请求时os会为父进程要修改的页面创建副本，而不是写共享的页面。所以子进程的地址空间内的数 据是fork时刻整个数据库的一个快照。

3.当子进程将快照写入临时文件完毕后，用临时文件替换原来的快照文件，然后子进程退出。

client 也可以使用save或者bgsave命令通知redis做一次快照持久化。save操作是在主线程中保存快照的，由于redis是用一个主线程来处理所有client的请求，这种方式会阻塞所有client请求。所以不推荐使用。另一点需要注意的是，每次快照持久化都是将内存数据完整写入到磁盘一次，并不 是增量的只同步脏数据。如果数据量大的话，而且写操作比较多，必然会引起大量的磁盘io操作，可能会严重影响性能。

另外由于快照方式是在一定间隔时间做一次的，所以如果redis意外down掉的话，就会丢失最后一次快照后的所有修改。如果应用要求不能丢失任何修改的话，可以采用aof持久化方式。下面介绍

Append-only file
    
aof 比快照方式有更好的持久化性，是由于在使用aof持久化方式时,redis会将每一个收到的写命令都通过write函数追加到文件中(默认是appendonly.aof)。当redis重启时会通过重新执行文件中保存的写命令来在内存中重建整个数据库的内容。当然由于os会在内核中缓存write做的修改，所以可能不是立即写到磁盘上。这样aof方式的持久化也还是有可能会丢失部分修改。不过我们可以通过配置文件告诉redis我们想要 通过fsync函数强制os写入到磁盘的时机。有三种方式如下（默认是：每秒fsync一次）

appendonly yes              //启用aof持久化方式
# appendfsync always      //每次收到写命令就立即强制写入磁盘，最慢的，但是保证完全的持久化，不推荐使用
appendfsync everysec     //每秒钟强制写入磁盘一次，在性能和持久化方面做了很好的折中，推荐
# appendfsync no    //完全依赖os，性能最好,持久化没保证

aof 的方式也同时带来了另一个问题。持久化文件会变的越来越大。例如我们调用incr test命令100次，文件中必须保存全部的100条命令，其实有99条都是多余的。因为要恢复数据库的状态其实文件中保存一条set test 100就够了。为了压缩aof的持久化文件。redis提供了bgrewriteaof命令。收到此命令redis将使用与快照类似的方式将内存中的数据 以命令的方式保存到临时文件中，最后替换原来的文件。具体过程如下

1. redis调用fork，现在有父子两个进程
2. 子进程根据内存中的数据库快照，往临时文件中写入重建数据库状态的命令
3.父进程继续处理client请求，除了把写命令写入到原来的aof文件中。同时把收到的写命令缓存起来。这样就能保证如果子进程重写失败的话并不会出问题。
4.当子进程把快照内容写入已命令方式写到临时文件中后，子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件。
5.现在父进程可以使用临时文件替换老的aof文件，并重命名，后面收到的写命令也开始往新的aof文件中追加。

需要注意到是重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件,这点和快照有点类似。

 

 

***redis的优点

1  Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，zset，hash等数据结构的存储。

2  Redis支持数据的备份，即master-slave模式的数据备份。

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

抛开这些，可以深入到Redis内部构造去观察更加本质的区别，理解Redis的设计。

在Redis中，并不是所有的数据都一直存储在内存中的。这是和Memcached相比一个最大的区别。

Redis只会缓存所有的 key的信息，如果Redis发现内存的使用量超过了某一个阀值，将触发swap的操作，Redis根据“swappability = age*log(size_in_memory)”计算出哪些key对应的value需要swap到磁盘。然后再将这些key对应的value持久化到磁盘中，同时在内存中清除。这种特性使得Redis可以 保持超过其机器本身内存大小的数据。当然，机器本身的内存必须要能够保持所有的key，毕竟这些数据是不会进行swap操作的。同时由于Redis将内存 中的数据swap到磁盘中的时候，提供服务的主线程和进行swap操作的子线程会共享这部分内存，所以如果更新需要swap的数据，Redis将阻塞这个 操作，直到子线程完成swap操作后才可以进行修改。

**98. redis能把内存空间交换进磁盘中吗

Redis利用swap文件将数据从内存转移到磁盘。

http://blog.csdn.net/nvnh7553/article/details/50107971

如果你打开虚拟内存功能，当内存用尽时, Redis就会把那些不经常使用的数据存储到磁盘。
如果Redis里的虚拟内存被禁了，他就会用上操作系统的虚拟内存(交换内存)，同时性能急剧下降。
你可以配置maxmemory参数，来避免Redis默认再分配更多的内存。

http://www.dewen.net.cn/q/242

**

103. redis做缓存是分布式存的？不同的服务器上存的数据是否重复？guava cache呢？是否重复？不同的机器存的数据不同

由于redis是单点，项目中需要使用，必须自己实现分布式。

分布式实现：通过key做一致性哈希，实现key对应redis结点的分布。

http://www.open-open.com/lib/view/open1384603154712.html

Mysql是适合海量数据存储的，然后通过Memcached将一些常用的数据进行缓存，加快访问速度。

当数据量不断的增大的时候，进行切表，拆表的，Memcached也需要不断的跟着扩容，Memcached和Mysql的数据一致性的问题，Memcached数据命中率低或者Down机，大量的访问就会穿透到数据库，这时候Mysql可能会无法支撑。

          Redis使用最佳方式是全部数据in-memory。

          Redis更多场景是作为Memcached的替代者来使用。

         当需要除key/value之外的更多数据类型支持时，使用Redis更合适。

         当存储的数据不能被剔除时，使用Redis更合适。

http://blog.csdn.net/bemavery/article/details/47061663

 

redis在spring中的配置及java代码实现 

1、建一个redis.properties属性文件

# Redis Setting

redis.addr = 127.0.0.1

redis.port = 6379

redis.auth = master

 

redis.maxIdle = 200

redis.maxActive = 1024

redis.maxWait = 10000

redis.timeOut = 10000

redis.testOnBorrow = true

 

2、新建一个RedisUtil.java文件，

public class RedisUtilimplements Serializable{

    

    private static final long serialVersionUID = -1149678082569464779L;

 

    //Redis服务器IP

    private static String addr;

    

    //Redis的端口号

    private static int port;

    

    //访问密码

    private static String auth;

    

    //可用连接实例的最大数目，默认值为8；

    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。

    private static int maxActive;

    

    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。

    private static int maxIdle;

    

    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；

    private static int maxWait;

    

    private static int timeOut;

    

    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；

    private static boolean testOnBorrow;

    

    public static Jedis jedis;//非切片额客户端连接

    

    public static JedisPool jedisPool;//非切片连接池

    

    public static ShardedJedis shardedJedis;//切片额客户端连接

    

    public static ShardedJedisPool shardedJedisPool;//切片连接池

    

    /**

     * 初始化非切片池

     */

    private static void initialPool()

    {

        // 池基本配置

        JedisPoolConfig config = new JedisPoolConfig();

        config.setMaxTotal(maxActive);

        config.setMaxIdle(maxIdle);

        config.setMaxWaitMillis(maxWait);

        config.setTestOnBorrow(testOnBorrow);

        jedisPool = new JedisPool(config, addr, port);

    }

3、在spring-servlet.xml配置文件中

<context:component-scanbase-package="cn.com.taiji.sample.config.web" />

    <context:property-placeholderlocation="file:#{systemProperties['webapp.sample']}/WEB-INF/conf/redis.properties" />

      

    <beanid="redisUtil" class="cn.com.taiji.sample.utils.RedisUtil">

        <propertyname="addr"><value>${redis.addr}</value></property>

        <propertyname="port"><value>${redis.port}</value></property>

        <propertyname="auth"><value>${redis.auth}</value></property>

        <propertyname="maxIdle"><value>${redis.maxIdle}</value></property>

        <propertyname="maxActive"><value>${redis.maxActive}</value></property>

        <propertyname="maxWait"><value>${redis.maxWait}</value></property>

        <propertyname="timeOut"><value>${redis.timeOut}</value></property>

        <propertyname="testOnBorrow"><value>${redis.testOnBorrow}</value></property>

    </bean>  

<context:property-placeholderlocation="" />指的是redis.properties的文件路径。
到此，redis的spring配置就已经完成了。

 

 

redis在java项目中的使用 

在上一篇文章中已经讲了redis的spring配置，这篇将会描述redis在java项目中的使用。

redis存储形式都是key-value（键值对），按照存储的内容分为两种，一种是存简单数据，即数字，字符串等，可以用string-value的形式存储；另一种是存对象、集合等，最好用序列化的方式来存储。

1、存储简单数据

try {

    Jedis jedis = new Jedis();

    jedis.set("name", "JackGSmith");

} catch (Exception e) {

    //如果缓存连不上，则不处理

    System.out.println("登录无法更新该用户缓存");

}

 

从redis缓存中获取key为“name”的值，使用jedis.get("name"),用一个String变量接收即可。

2、存储对象、集合

存对象集合用序列化的方式存储，用反序列化的方式取值。存储的key和value都是转化成字节码的形式。

先定义一个抽象类：SerializeTranscoder.java,

public abstract class SerializeTranscoder {

      

      public abstract byte[] serialize(Object value);

      

      public abstract Object deserialize(byte[] in)throws IOException;

      

      public void close(Closeable closeable) {

        if (closeable != null) {

          try {

            closeable.close();

          } catch (Exception e) {

              e.printStackTrace();

          }

        }

      }

}

再建一个序列化的类，ObjectTranscoder.java，继承上面这个抽象类，该类是用来序列化存储对象用的

public class ObjectTranscoder<Mextends Serializable> extends SerializeTranscoder{

 

    @SuppressWarnings("unchecked")

      @Override

      public byte[] serialize(Object value) {

        if (value == null) {  

          throw new NullPointerException("Can't serialize null");  

        }  

        byte[] result = null;  

        ByteArrayOutputStream bos = null;  

        ObjectOutputStream os = null;  

        try {  

          bos = new ByteArrayOutputStream();  

          os = new ObjectOutputStream(bos);

          M m = (M) value;

          os.writeObject(m);  

          os.close();  

          bos.close();  

          result = bos.toByteArray();  

        } catch (IOException e) {  

          throw new IllegalArgumentException("Non-serializable object", e);  

        } finally {  

          close(os);  

          close(bos);  

        }  

        return result;  

      }

接着在新建一个ListTranscoder.java文件，用来序列化存储List（集合）对象，基本同上

 

public class ListTranscoder<Mextends Serializable> extends SerializeTranscoder {

 

    @SuppressWarnings("unchecked")

    public List<M> deserialize(byte[] in)throws IOException {

        List<M> list = new ArrayList<>();

        ByteArrayInputStream bis = null;

        ObjectInputStream is = null;

        try {

          if (in != null) {

            bis = new ByteArrayInputStream(in);

            is = new ObjectInputStream(bis);

            while (true) {

              M m = (M)is.readObject();

              if (m == null) {

                break;

              }

              list.add(m);

            }

            is.close();

            bis.close();

          }

      } catch (Exception e) {  

        //  e.printStackTrace();

      }  finally {

          is.close();

          bis.close();

        }

        return  list;

      }

现在，就可以用序列化的方式存储对象或集合了：

try {

    Jedis jedis = new Jedis();

    List<SystemNotice> noticeList = systemNoticeManager.listQuery(noticeQModel);

    if(noticeList.size()>0 && noticeList != null){

    ListTranscoder<SystemNotice> listTranscoder = new ListTranscoder<SystemNotice>();

    jedis.set(loginUser.getId().getBytes(), listTranscoder.serialize(noticeList));

    }

} catch (Exception e) {

    //如果缓存连不上，则不处理

    System.out.println("登录无法更新该用户缓存");

}

存的key使用用户id，所以取出list就很简单了：

try {

 Jedis jedis = new Jedis();

 byte[] list = jedis.get(loginUser.getId().getBytes());

 ListTranscoder<SystemNotice> listTranscoder = new ListTranscoder<SystemNotice>();

 List<SystemNotice> newList = listTranscoder.deserialize(list);try {

 responseJson(JsonTools.toJsonStr(newList), response);

 } catch (IOException e) {

    e.printStackTrace();

 }

}