akka学习教程(十一) akka持久化

最新推荐文章于 2024-08-26 17:36:20 发布
最新推荐文章于 2024-08-26 17:36:20 发布
阅读量7.7k 收藏 11
点赞数
分类专栏： 分布式+高并发 akka学习教程 文章标签： akka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liubenlong007/article/details/54584303
版权

akka系列文章目录

本文内容来自于官网文档示例: AKKA Persistence

Akka持久化简介

Akka持久化可以使有状态的actor能够保持其内部状态，以便在启动、JVM崩溃后重新启动、或在集群中迁移时，恢复它们的内部状态。 Akka持久性关键点在于，只有对actor内部状态的更改才会被持久化，而不会直接保持其当前状态（可选快照除外）。 这些更改只会追加到存储，没有任何修改，这允许非常高的事务速率和高效的复制。 通过加载持久化的数据Stateful actors可以重建内部状态。 这可以是所有修改的完整历史记录，也可以从一个快照开始，这可以显着减少恢复时间。 Akka持久性还提供至少一次消息传递语义的点对点通信。【翻译与官方文档】

接下来将官方文档的示例运行一遍

依赖与配置

引入persistence依赖

<dependency>
    <groupId>com.typesafe.akka</groupId>
    <artifactId>akka-persistence_2.11</artifactId>
    <version>2.4.16</version>
</dependency>

Akka持久性扩展依赖一些内置持久性插件，包括基于内存堆的日志，基于本地文件系统的快照存储和基于LevelDB的日志。

基于LevelDB的插件将需要以下附加的依赖声明：

<dependency>
  <groupId>org.iq80.leveldb</groupId>
  <artifactId>leveldb</artifactId>
  <version>0.7</version>
</dependency>
<dependency>
  <groupId>org.fusesource.leveldbjni</groupId>
  <artifactId>leveldbjni-all</artifactId>
  <version>1.8</version>
</dependency>

不过本文没有使用leveldb。

添加配置文件

这里需要配置持久化使用到的配置信息journal

  • 默认情况下，持久化actor或视图将使用在reference.conf配置资源的以下部分中配置的“default”日志和快照存储插件。
  • 注意，在这种情况下，actor或视图只覆盖persistenceId方法。
  • 当持久化actor或视图覆盖journalPluginId和snapshotPluginId方法时，actor或视图将由这些特定的持久性插件提供服务，而不是默认值。

reference.conf：

akka {
  loglevel = "INFO"
}

akka.persistence.journal.plugin = "akka.persistence.journal.inmem"
# Absolute path to the default snapshot store plugin configuration entry.
akka.persistence.snapshot-store.plugin = "akka.persistence.snapshot-store.local"

上代码

package akka.serializable;

import akka.actor.UntypedActor;
import akka.event.Logging;
import akka.event.LoggingAdapter;
import akka.persistence.SnapshotOffer;
import akka.persistence.UntypedPersistentActor;
import com.alibaba.fastjson.JSON;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.UUID;

import static java.util.Arrays.asList;

class Cmd implements Serializable {
    private static final long serialVersionUID = 1L;
    private final String data;

    public Cmd(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }
}

class Evt implements Serializable {
    private static final long serialVersionUID = 1L;
    private final String data;
    private final String uuid;

    public Evt(String data, String uuid) {
        this.data = data;
        this.uuid = uuid;
    }

    public String getUuid() {
        return uuid;
    }

    public String getData() {
        return data;
    }
}

class ExampleState implements Serializable {
    private static final long serialVersionUID = 1L;
    private final ArrayList<String> events;

    public ExampleState() {
        this(new ArrayList<String>());
    }

    public ExampleState(ArrayList<String> events) {
        this.events = events;
    }

    public ExampleState copy() {
        return new ExampleState(new ArrayList<String>(events));
    }

    public void update(Evt evt) {
        events.add(evt.getData());
    }

    public int size() {
        return events.size();
    }

    @Override
    public String toString() {
        return events.toString();
    }
}

class ExamplePersistentActor extends UntypedPersistentActor {

    LoggingAdapter log = Logging.getLogger(getContext().system (), this );

    @Override
    public String persistenceId() { return "sample-id-1"; }

    private ExampleState state = new ExampleState();

    public int getNumEvents() {
        return state.size();
    }

    /**
     * Called on restart. Loads from Snapshot first, and then replays Journal Events to update state.
     * @param msg
     */
    @Override
    public void onReceiveRecover(Object msg) {
        log.info("onReceiveRecover: " + JSON.toJSONString(msg));
        if (msg instanceof Evt) {
            log.info("onReceiveRecover -- msg instanceof Event");
            log.info("event --- " + ((Evt) msg).getData());
            state.update((Evt) msg);
        } else if (msg instanceof SnapshotOffer) {
            log.info("onReceiveRecover -- msg instanceof SnapshotOffer");
            state = (ExampleState)((SnapshotOffer)msg).snapshot();
        } else {
          unhandled(msg);
        }
    }

    /**
     * Called on Command dispatch
     * @param msg
     */
    @Override
    public void onReceiveCommand(Object msg) {
        log.info("onReceiveCommand: " + JSON.toJSONString(msg));
        if (msg instanceof Cmd) {
            final String data = ((Cmd)msg).getData();

            // generate an event we will persist after being enriched with a uuid
            final Evt evt1 = new Evt(data + "-" + getNumEvents(), UUID.randomUUID().toString());
            final Evt evt2 = new Evt(data + "-" + (getNumEvents() + 1), UUID.randomUUID().toString());

            // persist event and THEN update the state of the processor
            persistAll(asList(evt1, evt2), evt -> {
                state.update(evt);
                if (evt.equals(evt2)) {
                    // broadcast event on eventstream 发布该事件
                    getContext().system().eventStream().publish(evt);
                }
            });
        } else if (msg.equals("snap")) {
            // IMPORTANT: create a copy of snapshot
            // because ExampleState is mutable !!!
            saveSnapshot(state.copy());
        } else if (msg.equals("print")) {
            System.out.println("state:  " + state);
        } else {
          unhandled(msg);
        }
    }
}

class EventHandler extends UntypedActor {


    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

    @Override
    public void onReceive(Object msg ) throws Exception {
        log.info( "Handled Event: " + JSON.toJSONString(msg));
    }
}

main方法

package akka.serializable;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;


public class MainTest {

  public static final Logger log = LoggerFactory.getLogger(System.class);

  public static void main(String... args) throws Exception {

    final ActorSystem actorSystem = ActorSystem.create("actor-server");

    final ActorRef handler = actorSystem.actorOf(Props.create(EventHandler. class));
    // 订阅
    actorSystem.eventStream().subscribe(handler , Evt.class);

    Thread.sleep(5000);

    final ActorRef actorRef = actorSystem.actorOf(Props.create(ExamplePersistentActor. class), "eventsourcing-processor" );

    actorRef.tell( new Cmd("CMD 1" ), null);
    actorRef.tell( new Cmd("CMD 2" ), null);
    actorRef.tell( new Cmd("CMD 3" ), null);
    actorRef.tell( "snap", null );//发送保存快照命令
    actorRef.tell( new Cmd("CMD 4" ), null);
    actorRef.tell( new Cmd("CMD 5" ), null);
    actorRef.tell( "print", null );

    Thread.sleep(5000);

    log.info( "Actor System Shutdown Starting..." );

    actorSystem.shutdown();
  }
}

运行结果：

[INFO] [01/17/2017 16:16:02.526] [actor-server-akka.actor.default-dispatcher-5] [akka://actor-server/user/eventsourcing-processor] onReceiveRecover: {}
[INFO] [01/17/2017 16:16:02.526] [actor-server-akka.actor.default-dispatcher-5] [akka://actor-server/user/eventsourcing-processor] onReceiveRecover -- msg instanceof SnapshotOffer
[INFO] [01/17/2017 16:16:02.560] [actor-server-akka.actor.default-dispatcher-5] [akka://actor-server/user/eventsourcing-processor] onReceiveRecover: {"instance":{"$ref":"@"}}
[INFO] [01/17/2017 16:16:02.565] [actor-server-akka.actor.default-dispatcher-5] [akka://actor-server/user/eventsourcing-processor] onReceiveCommand: {"data":"CMD 1"}
[INFO] [01/17/2017 16:16:02.591] [actor-server-akka.actor.default-dispatcher-5] [akka://actor-server/user/eventsourcing-processor] onReceiveCommand: {"data":"CMD 2"}
[INFO] [01/17/2017 16:16:02.592] [actor-server-akka.actor.default-dispatcher-6] [akka://actor-server/user/eventsourcing-processor] onReceiveCommand: {"data":"CMD 3"}
[INFO] [01/17/2017 16:16:02.593] [actor-server-akka.actor.default-dispatcher-8] [akka://actor-server/user/$a] Handled Event: {"data":"CMD 1-37","uuid":"fe0fca08-a415-425d-b618-c730b117ca7d"}
[INFO] [01/17/2017 16:16:02.594] [actor-server-akka.actor.default-dispatcher-6] [akka://actor-server/user/eventsourcing-processor] onReceiveCommand: "snap"
[INFO] [01/17/2017 16:16:02.595] [actor-server-akka.actor.default-dispatcher-8] [akka://actor-server/user/$a] Handled Event: {"data":"CMD 2-39","uuid":"76fbf9e8-befd-40f4-a4fe-49b5698c7c7d"}
[INFO] [01/17/2017 16:16:02.595] [actor-server-akka.actor.default-dispatcher-8] [akka://actor-server/user/$a] Handled Event: {"data":"CMD 3-41","uuid":"3b9f70c2-83c5-47d3-9f0a-4710905c3cfe"}
[INFO] [01/17/2017 16:16:02.595] [actor-server-akka.actor.default-dispatcher-6] [akka://actor-server/user/eventsourcing-processor] onReceiveCommand: {"data":"CMD 4"}
[INFO] [01/17/2017 16:16:02.596] [actor-server-akka.actor.default-dispatcher-5] [akka://actor-server/user/$a] Handled Event: {"data":"CMD 4-43","uuid":"f8bb1e7e-716e-4f3c-9d81-e4570e0501c0"}
[INFO] [01/17/2017 16:16:02.596] [actor-server-akka.actor.default-dispatcher-8] [akka://actor-server/user/eventsourcing-processor] onReceiveCommand: {"data":"CMD 5"}
[INFO] [01/17/2017 16:16:02.597] [actor-server-akka.actor.default-dispatcher-5] [akka://actor-server/user/$a] Handled Event: {"data":"CMD 5-45","uuid":"574f9cdf-59f3-421c-8337-df8a50c95ee6"}
state:  [CMD 1-0, CMD 1-1, CMD 2-2, CMD 2-3, CMD 3-4, CMD 3-5, CMD 1-6, CMD 1-7, CMD 2-8, CMD 2-9, CMD 3-10, CMD 3-11, CMD 1-12, CMD 1-13, CMD 2-14, CMD 2-15, CMD 3-16, CMD 3-17, CMD 1-18, CMD 1-19, CMD 2-20, CMD 2-21, CMD 3-22, CMD 3-23, CMD 1-24, CMD 1-25, CMD 2-26, CMD 2-27, CMD 3-28, CMD 3-29, CMD 1-30, CMD 1-31, CMD 2-32, CMD 2-33, CMD 3-34, CMD 3-35, CMD 1-36, CMD 1-37, CMD 2-38, CMD 2-39, CMD 3-40, CMD 3-41, CMD 4-42, CMD 4-43, CMD 5-44, CMD 5-45]
[INFO] [01/17/2017 16:16:02.598] [actor-server-akka.actor.default-dispatcher-8] [akka://actor-server/user/eventsourcing-processor] onReceiveCommand: "print"
[INFO] [01/17/2017 16:16:02.613] [actor-server-akka.actor.default-dispatcher-15] [akka://actor-server/user/eventsourcing-processor] onReceiveCommand: {}
2017-01-17 16:16:06.835 [main            ] INFO  System                  - Actor System Shutdown Starting...

Process finished with exit code 0

这里注意：如果再次执行该程序，系统会首先恢复上次处理器的状态。本程序中会首先恢复快照中的状态然后是其他的状态。
快照使得处理器的状态持久化更加高效。

假如现在运行结果是酱紫的：
state:  [
CMD 1-0, CMD 1-1, 
CMD 2-2, CMD 2-3, 
CMD 3-4, CMD 3-5, 

CMD 1-6, CMD 1-7, 
CMD 2-8, CMD 2-9, 
CMD 3-10, CMD 3-11, 
CMD 4-12, CMD 4-13, 
CMD 5-14, CMD 5-15]

在运行一次，结果就是酱紫的：

state:  [
CMD 1-0, CMD 1-1, 
CMD 2-2, CMD 2-3, 
CMD 3-4, CMD 3-5, 

CMD 1-6, CMD 1-7, 
CMD 2-8, CMD 2-9, 
CMD 3-10, CMD 3-11, 

CMD 1-12, CMD 1-13, 
CMD 2-14, CMD 2-15, 
CMD 3-16, CMD 3-17, 
CMD 4-18, CMD 4-19, 
CMD 5-20, CMD 5-21]

由于我们采用的是默认的持久化策略，会持久化到本地磁盘，进入项目统计目录下，会看到文件夹snapshots:
这里写图片描述

参考资料

快乐崇拜234
关注
专栏目录
使用Akka持久化——消息发送与接收
beliefer的博客
02-06 9748
在《使用Akka持久化——持久化与快照》一文中介绍了如何使用Akka持久化消息及生成快照。对于集群应用来说，发送者发出消息，只有当收到了接受者的成功回复才应当认为是一次完整的请求和应答（一些RPC框架只提供了远程调用、序列化/反序列化的机制，但是具体调用的成功与否实际是抛给了开发者本人），利用Akka的应答机制很容易实现这些功能。
使用Akka持久化——持久化与快照
beliefer的博客
01-19 6954
前言 对于java web而言，一个用户的HTTP请求最终会转换为一条java线程处理。HTTP本身是无状态的，具体的请求逻辑一般也是无状态的。如果进程奔溃或者系统宕机，用户会发觉当前网页不可用之类的错误。虽然会影响一些用户体验，但是只要服务重启了，用户依然可以完成他的请求并满足其需要。但是有些情况下则势必会造成混乱甚至恐慌，例如跨行转账。用户从自己A银行的账户转账1万元至自己在B银行的账户，如果
Akka（14）： 持久化模式：PersistentActor
weixin_30662849的博客
07-21 206
Akka程序的特点之一就是高弹性或者强韧性（resilient）的，因为Actor具有自我修复的能力。当Actor模式的程序出现中断情况如：系统崩溃、人为终结等，系统在重启后有关Actor可以恢复之前的状态。这项功能是通过PersistentActor实现的。PersistentActor是一种特殊的带有内部状态的Actor，它是以事件来源模式（event-sourcing）来进...
Akka-概述/与环境搭建
最新发布
文天大人
08-26 244
热爱湘鄂的妹子，喜欢江浙的妹子
Akka系列（八）：Akka persistence设计理念之CQRS
weixin_33795743的博客
08-02 114
这一篇文章主要是讲解Akka persistence的核心设计理念，也是CQRS（Command Query Responsibility Segregation）架构设计的典型应用，就让我们来看看为什么Akka persistence会采用CQRS架构设计。 CQRS 很多时候我们在处理高并发的业务需求的时候，往往能把应用层的代码优化的...
Akka 指南 之「持久化」
CG国斌的博客
02-14 1594
温馨提示：Akka 中文指南的 GitHub 地址为「akka-guide」，欢迎大家Star、Fork，纠错。 文章目录持久化依赖示例项目简介体系结构事件源 持久化 依赖 为了使用 Akka 持久化（Persistence）功能，你必须在项目中添加如下依赖： &amp;amp;amp;amp;lt;!-- Maven --&amp;amp;amp;amp;gt; &amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp
Akka系列（七）：Actor持久化之Akka persistence
weixin_34122548的博客
07-23 272
这次把这部分内容提到现在写，是因为这段时间开发的项目刚好在这一块遇到了一些难点，所以准备把经验分享给大家，我们在使用Akka时，会经常遇到一些存储Actor内部状态的场景，在系统正常运行的情况下，我们不需要担心什么，但是当系统出错，比如Actor错误需要重启，或者内存溢出，亦或者整个系统崩溃，如果我们不采取一定的方案的话，在系统重启时Ac...
akka型持久化：Akka Typed的事件源
02-05
Akka类型的持久性 Akka Typed的活动来源 该库通过事件源实现演员持久性。 它提供： 演员定义API， 与Akka Typed集成在一起， 静态类型安全， 并支持参与者的持久性（带有事件源和快照）； 和此API的实现基于...
java6.0源码-akka-persistence-learning:akka-持久性学习
06-04
如何将事件持久化到日志， 如何为您的数据模型创建、配置和使用 Google Protocol Buffers， 如何创建、配置和 EventAdapter，标记事件，并将域模型转换为数据模型 (protobuf)， 如何创建、配置和使用自定义序列化...
akka-persistence-rocksdb:Akka 持久化 RocksDB 插件
07-10
**Akka 持久化与 RocksDB 插件详解** Akka 是一个用 Scala 编写的、基于 Actor 模型的并发框架，它提供了一种高效、容错且易于管理的方式来进行分布式系统的设计和实现。在 Akka 中，持久化是确保 Actor 状态在系统...
akka-learning:用Akka要点书学习Akka
05-26
4. **持久化**：Akka提供了一种可插拔的持久化机制，使得Actor的状态能够持久化到数据库或其他存储介质中，即使在系统重启后也能恢复状态，这对于实现容错和高可用性至关重要。 5. **集群**：Akka集群允许分布在...
akka-persistence-sql-async, 一个用于akka持久性的日志和快照存储.zip
09-18
akka-persistence-sql-async, 一个用于akka持久性的日志和快照存储 akka-persistence-sql-async 的日志和快照存储插件( akka持久化插件。 Akka-persistence-sql-async执行由 scalikejdbc异步查询，它提供非阻塞api来与数据库。Akka
akka-persistence-jdbc-play:使用 akka-persistence-jdbc 的示例播放项目
06-17
#akka-persistence-jdbc-play 一个小例子，如何使用和 (Typesafe Play)[ ]。 请安装以下内容： （酿造）[ ] 在控制台上键入以下内容： ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" brew update （酿造桶）[ ] 在控制台上键入以下内容： brew install caskroom/cask/brew-cask brew tap caskroom/versions brew cask install java brew cask install java6 brew cask install java7 brew cask install boot2docker brew cask in
AKKA框架持久化入门样例
康雨城
05-11 537
背景 我们在开发的过程中可能会在内存中操作数据，但是可能会遇到突然服务器断电、网线被挖等情况。这就需要将内存中的数据持久化，在程序重启的时候依然能够恢复。 AKKA介绍 Akka is a toolkit for building highly concurrent, distributed, and resilient message-driven applications for Jav...
akka PersistentActor（event sourcing）通过mysql持久化数据
weikwer
05-22 596
akka PersistentActor（event sourcing）通过mysql持久化数据 一：新建mysql数据库表 create database if not exists akka_persistence_sql_async; CREATE TABLE IF NOT EXISTS persistence_metadata ( persistence_key BIGINT NOT...
akka入门-对处理器状态进行持久化
长青树呀
05-17 1753
该话题涉及几个概念： 处理器、信道、事件源、日志、状态。 消息可以持久化，通常当前的状态保存在内存中（内存镜像），而事件源机制可以通过重播接收到的消息（在应用程序正常启动或崩溃后）恢复当前（或历史）的状态。 Eventsourced 实现了预写日志(write-ahead log ,WAL)用于跟踪一个Actor 所接收消息，并通过回放记录的消息来恢复其状态。 处理
使用Akka Persistence使反应性队列持久
03-30 275
前段时间，我写了如何使用Akka Streams实现反应消息队列 。 队列支持带有反向压力的流发送和接收操作，但有一个缺点：所有消息都存储在内存中，因此在重新启动的情况下会丢失。 但这可以通过实验性的akka-persistence模块轻松解决​​，该模块在Akka 2.3.4中进行了更新 。 队列参与者刷新 为了使队列持久，我们只需要更改队列参与者即可； 反应/流部件保持完整。 提...
akka mysql_Akka系列（七）：Actor持久化之Akka persistence
weixin_31043555的博客
01-26 306
这次把这部分内容提到现在写，是因为这段时间开发的项目刚好在这一块遇到了一些难点，所以准备把经验分享给大家，我们在使用Akka时，会经常遇到一些存储Actor内部状态的场景，在系统正常运行的情况下，我们不需要担心什么，但是当系统出错，比如Actor错误需要重启，或者内存溢出，亦或者整个系统崩溃，如果我们不采取一定的方案的话，在系统重启时Actor的状态就会丢失，这会导致我们丢失一些关键的数据，造成系...
akka java_使用Akka, Spring Boot, DDD建立Java分布式系统
weixin_26731219的博客
02-21 516
当需要处理的数据增长超过单个JVM中时，这时候AKKA集群提供了构建此类实现的可扩展的解决方案。这是一篇涉及分布式计算许多方面的文章。请准备在文章上阅读上花费大量的时间，参考所提到的各种外部链接，才能充分了解每个子主题，并可下载并运行文章提供的AKKA initializer/ util代码库才能更深入地了解本文主题。这里所提供的initializer程序库具有良好的文档注释，贯穿整个代码都提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

快乐崇拜234

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值