Java Transaction类代码示例

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void sessionEnd(boolean commit) throws CacheWriterException {
    Transaction transaction = session.transaction();
    if (transaction == null) {
        return;
    }
    Map<Object, Object> properties = session.properties();
    if (!commit) {
        Map bigBuffer = (Map) properties.get(BUFFER_PROPERTY_NAME);
        if (bigBuffer != null) {
            bigBuffer.remove(cacheName);
        }
    }
    Set<String> caches = (Set<String>) properties.get(CACHES_PROPERTY_NAME);
    if (caches != null && caches.remove(cacheName) && caches.isEmpty()) {
        Map<String, Collection<Cache.Entry<?, ?>>> buffer =
                (Map<String, Collection<Cache.Entry<?, ?>>>) properties.get(BUFFER_PROPERTY_NAME);
        notifyListeners(nextTransactionId(), buffer);
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void sessionEnd(boolean commit) throws CacheWriterException {
    Transaction transaction = session.transaction();
    if (transaction == null) {
        return;
    }
    Map<Object, Object> properties = session.properties();
    if (!commit) {
        Map bigBuffer = (Map)properties.get(BUFFER_PROPERTY_NAME);
        if (bigBuffer != null) {
            bigBuffer.remove(cacheName);
        }
    }
    Set<String> caches = (Set<String>)properties.get(CACHES_PROPERTY_NAME);
    if (caches != null && caches.remove(cacheName) && caches.isEmpty()) {
        Map<String, Collection<Cache.Entry<?, ?>>> buffer =
            (Map<String, Collection<Cache.Entry<?, ?>>>)properties.get(BUFFER_PROPERTY_NAME);
        notifyListeners(nextTransactionId(), buffer);
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
@Override public void commit(List<Long> txIds,
    IgniteClosure<Long, Map.Entry<List<IgniteBiTuple<String, ?>>, List<Object>>> txSupplier,
    IgniteInClosure<Long> onSingleCommit) {
    for (final Long txId : txIds) {
        Map.Entry<List<IgniteBiTuple<String, ?>>, List<Object>> currentTx = txSupplier.apply(txId);
        List<IgniteBiTuple<String, ?>> keys = currentTx.getKey();
        List<Object> values = currentTx.getValue();
        try (Transaction tx = ignite.transactions().txStart()) {
            for (int i = 0; i < keys.size(); i++) {
                IgniteBiTuple<String, ?> compositeKey = keys.get(i);
                ignite.cache(compositeKey.getKey()).put(compositeKey.getValue(), values.get(i));
                tx.commit();
            }
        }
        onSingleCommit.apply(txId);
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void process(final Map<?, ?> entries) {
    long processingStartTime = System.currentTimeMillis();
    ignite.compute().run(new IgniteRunnable() {
        @IgniteInstanceResource
        private Ignite localIgnite;

        @Override public void run() {
            IgniteCache cache = localIgnite.cache(cacheName);

            if (transactional) {
                try (Transaction tx = localIgnite.transactions().txStart()) {
                    process(cache, entries);
                }
            }
            else {
                process(cache, entries);
            }
        }
    });
    Statistics.recordOperation(System.currentTimeMillis() - processingStartTime);
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/**
 * Performs preparation for or actual write to persistence storage.
 *
 * @param entries changed in cache.
 */
private void putAll(Collection<Cache.Entry<?, ?>> entries) {
    if (isOnDRCluster()) {
        return;
    }
    Transaction transaction = session.transaction();
    if (transaction == null) {
        notifyListeners(nextTransactionId(), Collections.singletonMap(cacheName, entries));
    }
    else {
        Collection<Cache.Entry<?, ?>> cacheBuffer = getBuffer();
        for (Cache.Entry<?, ?> entry : entries) {
            cacheBuffer.add(entry);
        }
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void sessionEnd(boolean commit) throws CacheWriterException {
    Transaction transaction = session.transaction();
    if (transaction == null) {
        return;
    }
    Map<Object, Object> properties = session.properties();
    if (!commit) {
        Map bigBuffer = (Map)properties.get(BUFFER_PROPERTY_NAME);
        if (bigBuffer != null) {
            bigBuffer.remove(cacheName);
        }
    }
    Set<String> caches = (Set<String>)properties.get(CACHES_PROPERTY_NAME);
    if (caches != null && caches.remove(cacheName) && caches.isEmpty() && !isOnDRCluster()) {
        Map<String, Collection<Cache.Entry<?, ?>>> buffer =
            (Map<String, Collection<Cache.Entry<?, ?>>>)properties.get(BUFFER_PROPERTY_NAME);
        notifyListeners(nextTransactionId(), buffer);
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
protected void singleCommit(TransactionSupplier txSupplier, IgniteInClosure<Long> onSingleCommit, long txId) {
    TransactionDataIterator it = txSupplier.dataIterator(txId);

    try (Transaction tx = ignite.transactions().txStart()) {
        while (it.hasNextCache()) {
            IgniteCache<Object, Object> cache = ignite.cache(it.nextCache());

            while (it.hasNextEntry()) {
                it.advance();
                Object value = it.getValue();
                if (ActiveCacheStore.TOMBSTONE.equals(value)) {
                    cache.remove(it.getKey());
                } else {
                    cache.put(it.getKey(), value);
                }
            }
        }
        tx.commit();
    }
    onSingleCommit.apply(txId);
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/**
 * Make deposit into specified account number.
 *
 * @param accountNumber Bank account number.
 * @param amount Amount to deposit.+
 * @throws IgniteException If failed.
 */
private static void deposit(IgniteCache<Integer, BankAccount> cache, int accountNumber,
    double amount) throws IgniteException {
    try (Transaction tx = Ignition.ignite().transactions().txStart(PESSIMISTIC, REPEATABLE_READ)) {
        BankAccount bankAccount = cache.get(accountNumber);

        // Deposit into account.
        bankAccount.deposit(amount);

        // Store updated account in cache.
        cache.put(accountNumber, bankAccount);

        tx.commit();
    }

    logger.info("");
    logger.info("|--Deposit amount: $" + amount + "--|");
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/**
 * Make withdraw from specified account number.
 *
 * @param accountNumber Bank Account number.
 * @param amount Amount to withdraw.-
 * @throws IgniteException If failed.
 */
private static void withdraw(IgniteCache<Integer, BankAccount> cache, int accountNumber,
    double amount) throws IgniteException {
    try (Transaction tx = Ignition.ignite().transactions().txStart(PESSIMISTIC, REPEATABLE_READ)) {
        BankAccount bankAccount = cache.get(accountNumber);

        // Deposit into account.
        bankAccount.withdraw(amount);

        // Store updated account in cache.
        cache.put(accountNumber, bankAccount);

        tx.commit();
    }

    logger.info("");
    logger.info("|--Withdraw amount: $" + amount + "--|");
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/**
 * @param key Key.
 * @param txMode Non null tx mode if explicit transaction should be started.
 * @throws Exception If failed.
 */
private void checkVersion(String key, @Nullable TransactionConcurrency txMode) throws Exception {
    IgniteCache<String, Integer> cache = jcache(0);

    Transaction tx = null;

    if (txMode != null)
        tx = cache.unwrap(Ignite.class).transactions().txStart(txMode, REPEATABLE_READ);

    try {
        cache.put(key, 1);

        if (tx != null)
            tx.commit();
    }
    finally {
        if (tx != null)
            tx.close();
    }

    checkEntryVersion(key);
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/**
 * @param cache Cache.
 * @param concurrency Transaction concurrency.
 * @param isolation Transaction isolcation.
 * @param c Closure to run in transaction.
 * @throws Exception If failed.
 */
private void txAsync(final IgniteCache<Integer, Integer> cache,
    final TransactionConcurrency concurrency,
    final TransactionIsolation isolation,
    final IgniteClosure<IgniteCache<Integer, Integer>, Void> c) throws Exception {
    IgniteInternalFuture<?> fut = GridTestUtils.runAsync(new Callable<Void>() {
        @Override public Void call() throws Exception {
            IgniteTransactions txs = cache.unwrap(Ignite.class).transactions();

            try (Transaction tx = txs.txStart(concurrency, isolation)) {
                c.apply(cache);

                tx.commit();
            }

            return null;
        }
    }, "async-thread");

    fut.get();
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/**
 * @param concurrency Transaction concurrency level.
 * @param isolation Transaction isolation level.
 */
private void testTransactionalRemove(TransactionConcurrency concurrency, TransactionIsolation isolation) {
    IgniteCache cache = grid(0).getOrCreateCache(DEFAULT_CACHE_NAME);

    Random r = new Random();

    try (Transaction tx = grid(0).transactions().txStart(concurrency, isolation)) {
        for (int i = 0; i < CNT; ++i) {
            int key = r.nextInt();

            cache.put(key, "test-value");

            cache.remove(key, "test-value");
        }

        tx.commit();
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/**
 * @param cache Cache.
 * @throws Exception If failed.
 */
private void putAndCheckEntrySet(IgniteCache<Object, Object> cache) throws Exception {
    try (Transaction tx = cache.unwrap(Ignite.class).transactions().txStart(PESSIMISTIC, REPEATABLE_READ)) {
        Integer total = (Integer) cache.get(TX_KEY);

        if (total == null)
            total = 0;

        int cntr = 0;

        for (Cache.Entry e : cache) {
            if (e.getKey() instanceof Integer)
                cntr++;
        }

        assertEquals(total, (Integer)cntr);

        cache.put(cntr + 1, cntr + 1);

        cache.put(TX_KEY, cntr + 1);

        tx.commit();
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/** */
public void testTxPutUpdate() throws Exception {
    executeWithAllTxCaches(new TestClosure() {
        @Override public void run() throws Exception {
            GridTestUtils.assertThrows(log, new Callable<Object>() {
                @Override public Object call() throws Exception {
                    try (Transaction tx = ignite.transactions().txStart(concurrency, isolation)) {
                        cache.put(key1, okValue);
                        cache.put(key2, okValue);
                        cache.put(key2, badValue);

                        tx.commit();
                    }

                    assertEquals(0, cache.size());

                    return null;
                }
            }, CacheException.class, ERR_MSG);
        }
    });
}
 

import org.apache.ignite.transactions.Transaction; //导入依赖的package包/类
/** */
public void testTxPutIfAbsent() throws Exception {
    executeWithAllTxCaches(new TestClosure() {
        @Override public void run() throws Exception {
            GridTestUtils.assertThrows(log, new Callable<Object>() {
                @Override public Object call() throws Exception {
                    try (Transaction tx = ignite.transactions().txStart(concurrency, isolation)) {
                        cache.putIfAbsent(key1, badValue);

                        tx.commit();
                    }

                    assertEquals(0, cache.size());

                    return null;
                }
            }, CacheException.class, ERR_MSG);
        }
    });
}