Java PersistentRepr類代碼示例

import akka.persistence.PersistentRepr; //導入依賴的package包/類
@Override
public Future<Iterable<Optional<Exception>>> doAsyncWriteMessages(final Iterable<AtomicWrite> messages) {
    return Futures.future(() -> {
        for (AtomicWrite write : messages) {
            // Copy to array - workaround for eclipse "ambiguous method" errors for toIterator, toIterable etc
            PersistentRepr[] array = new PersistentRepr[write.payload().size()];
            write.payload().copyToArray(array);
            for (PersistentRepr repr: array) {
                LOG.trace("doAsyncWriteMessages: id: {}: seqNr: {}, payload: {}", repr.persistenceId(),
                    repr.sequenceNr(), repr.payload());

                addEntry(repr.persistenceId(), repr.sequenceNr(), repr.payload());

                WriteMessagesComplete complete = WRITE_MESSAGES_COMPLETE.get(repr.persistenceId());
                if (complete != null) {
                    if (complete.ofType == null || complete.ofType.equals(repr.payload().getClass())) {
                        complete.latch.countDown();
                    }
                }
            }
        }

        return Collections.emptyList();
    }, context().dispatcher());
}
 

import akka.persistence.PersistentRepr; //導入依賴的package包/類
/**
 * @param config akka configuration
 * @throws NotSerializableException
 */
public IgniteWriteJournal(Config config) throws NotSerializableException {
    ActorSystem actorSystem = context().system();
    serializer = SerializationExtension.get(actorSystem).serializerFor(PersistentRepr.class);
    storage = new Store<>(actorSystem);
    JournalCaches journalCaches = journalCacheProvider.apply(config, actorSystem);
    sequenceNumberTrack = journalCaches.getSequenceCache();
    cache = journalCaches.getJournalCache();
}
 

import akka.persistence.PersistentRepr; //導入依賴的package包/類
@Override
public Future<Void> doAsyncReplayMessages(String persistenceId, long fromSequenceNr, long toSequenceNr, long max, Consumer<PersistentRepr> replayCallback) {

    return storage.execute(persistenceId, cache, (entityIdParam, cacheParam) -> {
        if (log.isDebugEnabled()) {
            log.debug("doAsyncReplayMessages with params persistenceId: '{}' :fromSequenceNr {} :toSequenceNr {} :max {}"
                    , persistenceId, fromSequenceNr, toSequenceNr, max);
        }

        try (QueryCursor<Cache.Entry<Long, JournalItem>> query = cache
                .query(new SqlQuery<Long, JournalItem>(JournalItem.class, "sequenceNr >= ? AND sequenceNr <= ? AND persistenceId=?")
                        .setArgs(fromSequenceNr, toSequenceNr, persistenceId))) {
            final List<Cache.Entry<Long, JournalItem>> all = query.getAll();
            if (log.isDebugEnabled()) {
                log.debug("replyMessage results {} {} {}", query.toString(), all.toString(), all.size());
            }

            if (null != all && !all.isEmpty()) {

                if (all.size() < max) {
                    for (Cache.Entry<Long, JournalItem> entry : all) {
                        if (log.isDebugEnabled()) {
                            log.debug("replay message persistenceId '{}' getKey {}", persistenceId, entry.getKey());
                        }
                        replayCallback.accept(convert(entry.getValue()));
                    }
                } else {
                    all.subList(0, (int) max).forEach(longJournalItemEntry -> {
                        if (log.isDebugEnabled()) {
                            log.debug("replay message persistenceId'{}' getKey {}", persistenceId, longJournalItemEntry.getKey());
                        }
                        replayCallback.accept(convert(longJournalItemEntry.getValue()));

                    });
                }
            }
        }
        return null;
    });
}
 

import akka.persistence.PersistentRepr; //導入依賴的package包/類
@Override
public Future<Void> doAsyncReplayMessages(final String persistenceId, final long fromSequenceNr,
        final long toSequenceNr, final long max, final Consumer<PersistentRepr> replayCallback) {
    LOG.trace("doAsyncReplayMessages for {}: fromSequenceNr: {}, toSequenceNr: {}", persistenceId,
            fromSequenceNr,toSequenceNr);
    return Futures.future(() -> {
        CountDownLatch blockLatch = BLOCK_READ_MESSAGES_LATCHES.remove(persistenceId);
        if (blockLatch != null) {
            Uninterruptibles.awaitUninterruptibly(blockLatch);
        }

        Map<Long, Object> journal = JOURNALS.get(persistenceId);
        if (journal == null) {
            return null;
        }

        synchronized (journal) {
            int count = 0;
            for (Map.Entry<Long,Object> entry : journal.entrySet()) {
                if (++count <= max && entry.getKey() >= fromSequenceNr && entry.getKey() <= toSequenceNr) {
                    PersistentRepr persistentMessage =
                            new PersistentImpl(deserialize(entry.getValue()), entry.getKey(), persistenceId,
                                    null, false, null, null);
                    replayCallback.accept(persistentMessage);
                }
            }
        }

        return null;
    }, context().dispatcher());
}
 

import akka.persistence.PersistentRepr; //導入依賴的package包/類
private JournalItem convert(PersistentRepr p) {
    return new JournalItem(p.sequenceNr(), p.persistenceId(), serializer.toBinary(p));
}