精华内容
下载资源
问答
  • 持久化

    千次阅读 2012-12-01 16:39:54
    在说说持久化之前,先谈谈其他的内容: 瞬时状态: 保存在内存的程序数据,程序退出后,数据就消失了,称为瞬时状态。 持久化: 将程序数据在瞬时状态和持久化状态之间转换的机制。 持久状态: 保存在磁盘上的...

    在说说持久化之前,先谈谈其他的内容:

    瞬时状态:

    保存在内存的程序数据,程序退出后,数据就消失了,称为瞬时状态。

    持久化:

    将程序数据在瞬时状态和持久化状态之间转换的机制。

    持久状态:

    保存在磁盘上的程序数据,程序退出后依然存在,称为程序数据的持久状态。

    展开全文
  • @NotEmpty(message = "角色id不能为空",groups = ControllerGroup.class) @Transient private Long[] roleIds;
  • Redis09_持久化之RDB和AOF操作

    万次阅读 2020-09-08 22:12:59
    Redis09_持久化之RDB操作 由于 Redis 是一个内存数据库,读写效率比传统数据库要快的多,但缺点是,一旦断电或者宕机,那么内存数据库中的数据将会全部丢失。 因此Redis提供了将内存数据持久化到硬盘,以及用持久化...

    Redis09_持久化之RDB操作


    Redis 是一个内存数据库,读写效率比传统数据库要快的多,但缺点是,一旦断电或者宕机,那么内存数据库中的数据将会全部丢失。

    因此Redis提供了将内存数据持久化到硬盘,以及用持久化文件来恢复数据库数据的功能。支持以下两种形式的持久化:

    • RDB快照(snapshotting)(默认)
    • AOF(append-only-file)

    RDB快照(snapshotting)

    RDB是在指定时间间隔内把当前内存中的数据集快照写入磁盘,也就是 Snapshot 快照(数据库中所有键值对数据)。恢复时是将快照文件直接读到内存里。

    RDB 有 自动触发手动触发 两种触发方式

    自动触发:在 redis.conf 配置文件中的 SNAPSHOTTING 下有如下默认配置:

    save 900 1			# 表示900秒内数据集存在1次修改则自动触发bgsave
    save 300 10			# 表示300秒内数据集存在10次修改则自动触发bgsave
    save 60 10000		# 表示60秒内数据集存在10000次修改则自动触发bgsave
    
    dbfilename dump.rdb	# 设置快照的文件名
    

    触发规则:

    1. 满足save的规则
    2. 执行了flushall命令
    3. 正常redis关机
    

    恢复rdb文件:

    127.0.0.1:6379> config get dir
    1) "dir"
    2) "/usr/local/bin"
    

    将dump.rdb文件放置在以上目录即可,redis启动时会自动恢复其中的数据。

    RDB适用于大规模的数据恢复和对数据完整性要求不高的场景
    缺点是需要一定的时间间隔进行操作,如果意外宕机,最后一次修改的数据会丢失


    AOF(append-only-file)

    AOF是记录下所有执行过的写操作命令,恢复的时候重新执行(效率低)

    在 redis.conf 配置文件中的 APPEND ONLY MODE 下有如下默认配置:

    appendonly no						#AOF默认是关闭的,开启需要修改为 yes
    appendfilename "appendonly.aof"		#默认生成的文件名为 appendonly.aof
    
    #appendfsync always					#每一次修改都同步,数据的完整性更好
    appendfsync everysec				#每一秒写入一次aof文件,可能会丢失1s的数据
    #appendfsync no						#由操作系统决定同步,效率最高 
    

    如果 appendonly.aof 文件有误将不能成功启动 redis,可以通过 redis-check-aof 工具修复该文件:

    redis-check-aof --fix appendonly.aof
    

    AOF的缺点:
    aof 数据文件一般远远大于 rdb 文件,修复速度慢!
    aof 的运行效率比 rdb 慢

    展开全文
  • RabbitMQ之消息持久化

    万次阅读 多人点赞 2017-03-08 16:53:06
    消息的可靠性是RabbitMQ的一大特色,那么RabbitMQ是如何保证消息可靠性的呢——消息持久化。 为了保证RabbitMQ在退出或者crash等异常情况下数据没有丢失,需要将queue,exchange和Message都持久化。 queue的...

    消息的可靠性是RabbitMQ的一大特色,那么RabbitMQ是如何保证消息可靠性的呢——消息持久化。
    为了保证RabbitMQ在退出或者crash等异常情况下数据没有丢失,需要将queue,exchange和Message都持久化。


    欢迎支持笔者新作:《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》,同时欢迎关注笔者的微信公众号:朱小厮的博客。
    在这里插入图片描述


    欢迎跳转到本文的原文链接:https://honeypps.com/mq/rabbitmq-analysis-of-message-durable/

    queue的持久化

    queue的持久化是通过durable=true来实现的。
    一般程序中这么使用:

    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    channel.queueDeclare("queue.persistent.name", true, false, false, null);
    

    关键的是第二个参数设置为true,即durable=true.

    Channel类中queueDeclare的完整定义如下:

        /**
         * Declare a queue
         * @see com.rabbitmq.client.AMQP.Queue.Declare
         * @see com.rabbitmq.client.AMQP.Queue.DeclareOk
         * @param queue the name of the queue
         * @param durable true if we are declaring a durable queue (the queue will survive a server restart)
         * @param exclusive true if we are declaring an exclusive queue (restricted to this connection)
         * @param autoDelete true if we are declaring an autodelete queue (server will delete it when no longer in use)
         * @param arguments other properties (construction arguments) for the queue
         * @return a declaration-confirm method to indicate the queue was successfully declared
         * @throws java.io.IOException if an error is encountered
         */
        Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                                     Map<String, Object> arguments) throws IOException;
    

    参数说明:

    queue:queue的名称

    exclusive:排他队列,如果一个队列被声明为排他队列,该队列仅对首次申明它的连接可见,并在连接断开时自动删除。这里需要注意三点:1. 排他队列是基于连接可见的,同一连接的不同信道是可以同时访问同一连接创建的排他队列;2.“首次”,如果一个连接已经声明了一个排他队列,其他连接是不允许建立同名的排他队列的,这个与普通队列不同;3.即使该队列是持久化的,一旦连接关闭或者客户端退出,该排他队列都会被自动删除的,这种队列适用于一个客户端发送读取消息的应用场景。

    autoDelete:自动删除,如果该队列没有任何订阅的消费者的话,该队列会被自动删除。这种队列适用于临时队列。

    queueDeclare相关的有4种方法,分别是:

    Queue.DeclareOk queueDeclare() throws IOException;
    Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                                     Map<String, Object> arguments) throws IOException;
    void queueDeclareNoWait(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                                Map<String, Object> arguments) throws IOException;
    Queue.DeclareOk queueDeclarePassive(String queue) throws IOException;
    

    其中需要说明的是queueDeclarePassive(String queue)可以用来检测一个queue是否已经存在。如果该队列存在,则会返回true;如果不存在,就会返回异常,但是不会创建新的队列。


    消息的持久化

    如过将queue的持久化标识durable设置为true,则代表是一个持久的队列,那么在服务重启之后,也会存在,因为服务会把持久化的queue存放在硬盘上,当服务重启的时候,会重新什么之前被持久化的queue。队列是可以被持久化,但是里面的消息是否为持久化那还要看消息的持久化设置。也就是说,重启之前那个queue里面还没有发出去的消息的话,重启之后那队列里面是不是还存在原来的消息,这个就要取决于发生着在发送消息时对消息的设置了。
    如果要在重启后保持消息的持久化必须设置消息是持久化的标识。

    设置消息的持久化:

    channel.basicPublish("exchange.persistent", "persistent", MessageProperties.PERSISTENT_TEXT_PLAIN, "persistent_test_message".getBytes());
    

    这里的关键是:MessageProperties.PERSISTENT_TEXT_PLAIN
    首先看一下basicPublish的方法:

    void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException;
    void basicPublish(String exchange, String routingKey, boolean mandatory, BasicProperties props, byte[] body)
            throws IOException;
    void basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body)
            throws IOException;
    

    exchange表示exchange的名称
    routingKey表示routingKey的名称
    body代表发送的消息体
    有关mandatory和immediate的详细解释可以参考:RabbitMQ之mandatory和immediate.

    这里关键的是BasicProperties props这个参数了,这里看下BasicProperties的定义:

    public BasicProperties(
                String contentType,//消息类型如:text/plain
                String contentEncoding,//编码
                Map<String,Object> headers,
                Integer deliveryMode,//1:nonpersistent 2:persistent
                Integer priority,//优先级
                String correlationId,
                String replyTo,//反馈队列
                String expiration,//expiration到期时间
                String messageId,
                Date timestamp,
                String type,
                String userId,
                String appId,
                String clusterId)
    

    这里的deliveryMode=1代表不持久化,deliveryMode=2代表持久化。

    上面的实现代码使用的是MessageProperties.PERSISTENT_TEXT_PLAIN,那么这个又是什么呢?

    public static final BasicProperties PERSISTENT_TEXT_PLAIN =
        new BasicProperties("text/plain",
                            null,
                            null,
                            2,
                            0, null, null, null,
                            null, null, null, null,
                            null, null);
    

    可以看到这其实就是讲deliveryMode设置为2的BasicProperties的对象,为了方便编程而出现的一个东东。
    换一种实现方式:

    AMQP.BasicProperties.Builder builder = new AMQP.BasicProperties.Builder();
    builder.deliveryMode(2);
    AMQP.BasicProperties properties = builder.build();
    channel.basicPublish("exchange.persistent", "persistent",properties, "persistent_test_message".getBytes());
    

    设置了队列和消息的持久化之后,当broker服务重启的之后,消息依旧存在。单只设置队列持久化,重启之后消息会丢失;单只设置消息的持久化,重启之后队列消失,既而消息也丢失。单单设置消息持久化而不设置队列的持久化显得毫无意义。


    exchange的持久化

    上面阐述了队列的持久化和消息的持久化,如果不设置exchange的持久化对消息的可靠性来说没有什么影响,但是同样如果exchange不设置持久化,那么当broker服务重启之后,exchange将不复存在,那么既而发送方rabbitmq producer就无法正常发送消息。这里博主建议,同样设置exchange的持久化。exchange的持久化设置也特别简单,方法如下:

    Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean durable) throws IOException;
    Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete,
                                       Map<String, Object> arguments) throws IOException;
    Exchange.DeclareOk exchangeDeclare(String exchange, String type) throws IOException;
    Exchange.DeclareOk exchangeDeclare(String exchange,
                                              String type,
                                              boolean durable,
                                              boolean autoDelete,
                                              boolean internal,
                                              Map<String, Object> arguments) throws IOException;
    void exchangeDeclareNoWait(String exchange,
                               String type,
                               boolean durable,
                               boolean autoDelete,
                               boolean internal,
                               Map<String, Object> arguments) throws IOException;
    Exchange.DeclareOk exchangeDeclarePassive(String name) throws IOException;
    

    一般只需要:channel.exchangeDeclare(exchangeName, “direct/topic/header/fanout”, true);即在声明的时候讲durable字段设置为true即可。


    进一步讨论

    1.将queue,exchange, message等都设置了持久化之后就能保证100%保证数据不丢失了嚒?
    答案是否定的。
    首先,从consumer端来说,如果这时autoAck=true,那么当consumer接收到相关消息之后,还没来得及处理就crash掉了,那么这样也算数据丢失,这种情况也好处理,只需将autoAck设置为false(方法定义如下),然后在正确处理完消息之后进行手动ack(channel.basicAck).

    String basicConsume(String queue, boolean autoAck, Consumer callback) throws IOException;
    

    其次,关键的问题是消息在正确存入RabbitMQ之后,还需要有一段时间(这个时间很短,但不可忽视)才能存入磁盘之中,RabbitMQ并不是为每条消息都做fsync的处理,可能仅仅保存到cache中而不是物理磁盘上,在这段时间内RabbitMQ broker发生crash, 消息保存到cache但是还没来得及落盘,那么这些消息将会丢失。那么这个怎么解决呢?首先可以引入RabbitMQ的mirrored-queue即镜像队列,这个相当于配置了副本,当master在此特殊时间内crash掉,可以自动切换到slave,这样有效的保障了HA, 除非整个集群都挂掉,这样也不能完全的100%保障RabbitMQ不丢消息,但比没有mirrored-queue的要好很多,很多现实生产环境下都是配置了mirrored-queue的。还有要在producer引入事务机制或者Confirm机制来确保消息已经正确的发送至broker端,有关RabbitMQ的事务机制或者Confirm机制可以参考:RabbitMQ之消息确认机制(事务+Confirm). 幸亏本文的主题是讨论RabbitMQ的持久化而不是可靠性,不然就一发不可收拾了。RabbitMQ的可靠性涉及producer端的确认机制、broker端的镜像队列的配置以及consumer端的确认机制,要想确保消息的可靠性越高,那么性能也会随之而降,鱼和熊掌不可兼得,关键在于选择和取舍。

    2.消息什么时候刷到磁盘?
    写入文件前会有一个Buffer,大小为1M,数据在写入文件时,首先会写入到这个Buffer,如果Buffer已满,则会将Buffer写入到文件(未必刷到磁盘)。
    有个固定的刷盘时间:25ms,也就是不管Buffer满不满,每个25ms,Buffer里的数据及未刷新到磁盘的文件内容必定会刷到磁盘。
    每次消息写入后,如果没有后续写入请求,则会直接将已写入的消息刷到磁盘:使用Erlang的receive x after 0实现,只要进程的信箱里没有消息,则产生一个timeout消息,而timeout会触发刷盘操作。


    欲了解更多消息中间件的内容,可以关注:消息中间件收录集


    参考资料

    1. RabbitMQ消息队列(三):任务分发机制
    2. RabbitMQ之mandatory和immediate
    3. RabbitMQ之消息确认机制(事务+Confirm)
    4. RabbitMQ持久化机制

    欢迎跳转到本文的原文链接:https://honeypps.com/mq/rabbitmq-analysis-of-message-durable/


    欢迎支持笔者新作:《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》,同时欢迎关注笔者的微信公众号:朱小厮的博客。
    在这里插入图片描述

    展开全文
  • 192.168.117.210:8847 192.168.117.210:8848 192.168.117.210:8849
  • 你不知道的redis三-Redis的持久化机制

    万次阅读 多人点赞 2020-08-20 20:43:30
    一、持久化 我们前两章已经讲了,redis是内存型的数据库,他之所以快是因为数据存储在内存。那么数据存储在内存会有什么问题呢?当然就是当服务重启或者服务器宕机内存数据就被清除,我们就无法访问之前存储的数据...

    目录

     

    一、持久化

    二、RDB持久化方式

    2.1 手动触发

    2.2 RDB持久化命令

    2.3 恢复和异常流程演示

    2.4 RDB持久化的优缺点

    三、AOF持久化

    3.1 AOF持久化原理

    3.2 AOF持久化配置

    3.3 AOF持久化恢复

    四、Redis持久化加载机制顺序


    一、持久化

    我们前两章已经讲了,redis是内存型的数据库,他之所以快是因为数据存储在内存。那么数据存储在内存会有什么问题呢?当然就是当服务重启或者服务器宕机内存数据就被清除,我们就无法访问之前存储的数据了。那么怎么解决这个问题呢?当然就是使用持久化技术

    持久化(Persistence),即把数据(如内存中的对象)保存到可永久保存的存储设备中(如磁盘)。持久化是将程序数据在持久状态和瞬时状态间转换的机制。比如JDBC就是一种持久化机制。文件IO也是一种持久化机制。

    redis也是一个支持持久化的内存数据库,也就是说redis需要经常将内存中的数据同步到磁盘来保证持久化,持久化可以避免因进程退出而造成数据丢失;

    redis支持两种持久化方式,RDBAOF

    二、RDB持久化方式

    RDB持久化把当前进程数据生成快照(.rdb)文件保存到硬盘的过程,有手动触发自动触发

    2.1 手动触发

    手动触发有savebgsave两命令

     save命令:阻塞当前Redis,直到RDB持久化过程完成为止,若内存实例比较大会造成长时间阻塞,线上环境不建议用它

     bgsave命令redis进程执行fork操作创建子进程,由子线程完成持久化,阻塞时间很短(微秒级),是save的优化,在执行redis-cli shutdown关闭redis服务时,如果没有开启AOF持久化,自动执行bgsave;

    bgsave流程如下:

    2.2 RDB持久化命令

    命令:config set dir /usr/local  //设置rdb文件保存路径

    备份:bgsave  //dump.rdb保存到usr/local

    恢复:将dump.rdb放到redis安装目录与redis.conf同级目录,重启redis即可

    2.3 恢复和异常流程演示

    1,查看启动目录,没有dump文件

    2、set值

    3、执行shutdown命令关掉服务,查看目录,已经生成对应的dump文件。

    4、重启redis服务,发现数据还存在

    5、执行shutdown命令关掉服务,并把dump文件删除

    6、启动redis在进行查看,发现存储的数据已经不存在了。

    2.4 RDB持久化的优缺点

    优点:

    • 压缩后的二进制文,适用于备份、全量复制,用于灾难恢复
    • 加载RDB恢复数据远快于AOF方式

    缺点:

    • 无法做到实时持久化,每次都要创建子进程,频繁操作成本过高

    三、AOF持久化

    针对RDB不适合实时持久化,redis提供了AOF持久化方式来解决

    开启方式就是在redis.conf设置:appendonly yes  (默认不开启,为no)

    默认文件名:appendfilename "appendonly.aof" 

    3.1 AOF持久化原理

    1. 所有的写入命令(set hset)会append追加到aof_buf缓冲区中
    2. AOF缓冲区向硬盘做sync同步
    3. 随着AOF文件越来越大,需定期对AOF文件rewrite重写,达到压缩
    4. 当redis服务重启,可load加载AOF文件进行恢复

    3.2 AOF持久化配置

    配置信息 含义
    appendonly yes 启用aof持久化方式
    appendfsync always 每收到写命令就立即强制写入磁盘,最慢的,但是保证完全的持久化,不推荐使用
    appendfsync everysec 每秒强制写入磁盘一次,性能和持久化方面做了折中,推荐
    no-appendfsync-on-rewrite  yes 正在导出rdb快照的过程中,要不要停止同步aof
    auto-aof-rewrite-percentage 100 aof文件大小比起上次重写时的大小,增长率100%时,重写
    auto-aof-rewrite-min-size 64mb aof文件,至少超过64M时,重写

    3.3 AOF持久化恢复

    1. 设置appendonly yes;

    2. 将appendonly.aof放到dir参数指定的目录;

    3. 启动Redis,Redis会自动加载appendonly.aof文件。

    四、Redis持久化加载机制顺序

    如果同时都开启了AOF和RDB 两种持久化方式,那么加载顺序及流程如下

    1. 当 AOF 和 RDB 文件同时存在时,优先加载 AOF
    2. 若关闭了 AOF,加载 RDB 文件
    3. 加载 AOF/RDB 成功,redis 重启成功
    4. AOF/RDB 存在错误,redis 启动失败并打印错误信息


     

    展开全文
  • Redis持久化

    万次阅读 2019-05-13 21:41:39
    Redis持久化 Redis持久化有两个参数要记住,分别是RDB和AOF RDB(redis databas)在指定的时间间隔将内存中的数据集快照写入磁盘,也就我们说的快照,它恢复时是将快照文件读到内存中。 --redis会单独创建(fork...
  • 消息的可靠性是RabbitMQ的一大特色,那么RabbitMQ是如何保证消息可靠性的呢——消息持久化。  为了保证RabbitMQ在退出或者crash等异常情况下数据没有丢失,需要将queue,exchange和Message都持久化。 queue的...
  • RabbitMQ消息持久化

    万次阅读 2020-06-03 19:56:02
    当RabbitMQ服务器挂了,它可能就丢失所有队列中的消息和任务。如果你想让RabbitMQ记住当前的状态和内容,就需要通过2...单单设置消息持久化而不设置队列的持久化显得毫无意义。 注意:已经定义的队列,再次定义是...
  • rabbitmq持久化

    千次阅读 2019-05-19 12:02:25
    rabbitmq持久化分为三个部分: 交换器的持久化、队列的持久化和消息的持久化 交换器的持久化 交换器的持久化是通过声明队列时,将durable参数设置为true实现的。如果交换器不设置持久化,那么rabbitmq服务重启之后,...
  • ActiveMQ 持久化

    千次阅读 2019-09-27 21:49:16
    ActiveMQ中,持久化是指对消息数据的持久化。在ActiveMQ中,默认的消息是保存在内存中的。当内存容量不足的时候,或ActiveMQ正常关闭的时候,会将内存中的未处理的消息持久化到磁盘中。具体的持久化策略由配置文件中...
  • 008:Redis-快照持久化和AOF持久化

    千次阅读 2019-02-15 17:06:03
    持久化功能: redis为了内部数据的安全考虑,会把本身的数据以文件形式保存到磁盘中一份,在服务器重启之后会自动把硬盘的数据恢复到内存(redis)里面。 数据保存到硬盘的过程就成为“持久化”效果。 Snap shotting...
  • AOF持久化

    万次阅读 多人点赞 2018-08-30 01:47:31
    RDB持久化是将进程数据写入文件,而AOF持久化(即Append Only File持久化),则是将Redis执行的每次写命令记录到单独的日志文件中(有点像MySQL的binlog);当Redis重启时再次执行AOF文件中的命令来恢复数据。 与RDB...
  • Redis持久化方案

    千次阅读 2020-12-03 21:46:21
    Redis默认的方式,redis通过快照来将数据持久化到磁盘中。 设置持久化快照的条件 在redis.conf中修改持久化快照的条件,如下: 900秒内发生1次key变化则快照一次 300秒内发生10次key变化则快照一次 60秒内发生10000...
  • 全面分析redis持久化机制

    千次阅读 多人点赞 2020-08-21 16:37:10
    为什么要持久化/ RDB VS AOF 精讲+实操
  • 数据持久化

    千次阅读 2019-06-22 22:46:19
    数据持久化介绍 1、持久化(persistence):把数据保存到可掉电式存储设备中以供之后使用。大多数情况下,特别是企业级应用,数据持久化意味着将内存中的数据保存到硬盘上加以”固化“,而持久化的实现过程大多通过...
  • Spark RDD 持久化

    千次阅读 2019-04-29 20:00:48
    二:持久化的作用方式 三:实操 四:复习Java序列化的作用 五:类比硬盘,内存和CPU的工作关系 一:应用情景 迭代式算法 快速交互式应用 二:持久化的作用方式 1.再次对同一个RDD进行计算时,会复用已经...
  • Redis持久化配置

    万次阅读 2015-07-10 17:40:26
    因此对缓存中的数据定时进行持久化的必要性就相当突出了,Redis持久化分别有RDB和AOF两种方式, 以下是这两种方式的相关配置: 1 第一种: RDB持久化方式 1.1 概述 默认redis是会以快照的形式将数据持久化到磁盘...
  • 什么是数据持久化?为什么要持久化? 一直听人说数据库持久化,也想学这方面的技术,但是什么是数据库持久化呢? 持久数据其实就是将数据保存到数据库。 数据持久化就是将内存中的数据模型转换为存储模型,以及将...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 121,783
精华内容 48,713
关键字:

持久化