Java IgniteCache类代码示例

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
@PostConstruct
    public void start() {
        log.info("Application is started for Node:" + ignite.cluster().nodes());
        CollectionConfiguration cfg = new CollectionConfiguration();
        IgniteQueue<Object> queue = ignite.queue("main", 0, cfg);
        IgniteCache<UUID, Operation> operationCache = ignite.cache("operationCache");
        log.info("Application is started for KeySizes:" + operationCache.size(CachePeekMode.PRIMARY));
        ArrayList<Event> events = new ArrayList<>();
        events.add(new Event(UUID.randomUUID(), IEventType.EXECUTE, EventState.CREATED, new String[]{"firstpar1","firstpar2"}));
        operationCache.put(UUID.randomUUID(), new Operation("TEST_CREATE", events, TransactionState.RUNNING));
        log.info("Application is started for KeySizes:" + operationCache.size(CachePeekMode.PRIMARY));
/*        Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                kafkaTemplate.send("operation-events",UUID.randomUUID(),
                        new Operation("blaaggre",Arrays.asList(new Event()),TransactionState.RUNNING));

            }
        }, 3,3, TimeUnit.SECONDS);*/

//        log.info(transactionCache.get(UUID.fromString("4447a089-e5f7-477c-9807-79210fafa296")).toString());
    }
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
/**
 * method assumes ChromosomeCriteria is set.
 * 
 * @param k
 *            - gene index in Chromosome.
 * @return
 */
private long selectGeneByChromsomeCriteria(int k) {
    List<Gene> genes = new ArrayList();

    StringBuffer sbSqlClause = new StringBuffer("_val like '");
    sbSqlClause.append("%");
    sbSqlClause.append(config.getChromosomeCritiera().getCriteria().get(k));
    sbSqlClause.append("%'");

    IgniteCache<Long, Gene> cache = ignite.cache(GAGridConstants.GENE_CACHE);

    SqlQuery sql = new SqlQuery(Gene.class, sbSqlClause.toString());

    try (QueryCursor<Entry<Long, Gene>> cursor = cache.query(sql)) {
        for (Entry<Long, Gene> e : cursor)
            genes.add(e.getValue());
    }

    int idx = selectRandomIndex(genes.size());

    Gene gene = genes.get(idx);
    return gene.id();
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
@Scheduled(initialDelayString = "${initialDelay}", fixedDelayString = "${fixedDelay}")
public void cleanExpiredRecords(){
    // query the matching records first
    logger.debug("Starting the clean up job to clear the expired records");
    long towMinutesRange = System.currentTimeMillis()-900000;
    final IgniteCache<String, List<AlertEntry>> alertsCache = getAlertsCache();
    final String sql = "select * from AlertEntry where timestamp <= ?";
    SqlQuery<String,AlertEntry> query = new SqlQuery(AlertEntry.class,sql);
    query.setArgs(towMinutesRange);
    final List<Cache.Entry<String, AlertEntry>> toDeleteAlerts = alertsCache.query(query).getAll();
    // then call remove all as this will remove the records from the cache and the persistent file system as sql delete will just delete it from the cache layer not the file system
    // or the persistent store
    if(toDeleteAlerts!=null && !toDeleteAlerts.isEmpty()){
        logger.debug("Finished cleaning out {} records",toDeleteAlerts.size());
        alertsCache.removeAll(new HashSet(toDeleteAlerts
                .stream()
                .map(Cache.Entry::getKey)
                .collect(Collectors.toList())));

    }

}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
@Override
public void onAfterPut(Cache.Entry<Long, JournalItem> entry) {
    IgniteCache<String, Long> sequenceNumberTrack = ignite.getOrCreateCache("sequenceNumberTrack");
    sequenceNumberTrack.invoke(entry.getValue().getPersistenceId(), (mutableEntry, objects) -> {
        if (mutableEntry.exists() && mutableEntry.getValue() != null) {
            // if it is less than the new sequence value , use it
            if (mutableEntry.getValue() < entry.getKey()) {
                mutableEntry.setValue(entry.getKey());
            }
        } else {
            // if does not exist , just use it
            mutableEntry.setValue(entry.getKey());
        }
        // by api design nothing needed here
        return null;
    });
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
/**
 * @param config      the akka configuration object
 * @param actorSystem the akk actor system
 * @return the created snapshot ignite cache
 */
@Override
public IgniteCache<Long, SnapshotItem> apply(Config config, ActorSystem actorSystem) {
    final IgniteExtension extension = IgniteExtensionProvider.EXTENSION.get(actorSystem);
    final String cachePrefix = config.getString(CACHE_PREFIX_PROPERTY);
    final int cacheBackups = config.getInt(CACHE_BACKUPS);
    final CacheConfiguration<Long, SnapshotItem> eventStore = new CacheConfiguration();
    eventStore.setCopyOnRead(false);
    if (cacheBackups > 0) {
        eventStore.setBackups(cacheBackups);
    } else {
        eventStore.setBackups(1);
    }
    eventStore.setAtomicityMode(CacheAtomicityMode.ATOMIC);
    eventStore.setName(cachePrefix + "_SNAPSHOT");
    eventStore.setCacheMode(CacheMode.PARTITIONED);
    eventStore.setReadFromBackup(true);
    eventStore.setIndexedTypes(Long.class, SnapshotItem.class);
    eventStore.setIndexedTypes(String.class, SnapshotItem.class);
    return extension.getIgnite().getOrCreateCache(eventStore);
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
/**
 * Distributed matrix get.
 *
 * @param a Row or column index.
 * @param b Row or column index.
 * @return Matrix value at (a, b) index.
 */
private double matrixGet(int a, int b) {
    // Remote get from the primary node (where given row or column is stored locally).
    return ignite().compute(getClusterGroupForGivenKey(CACHE_NAME, getBlockId(a, b))).call(() -> {
        IgniteCache<MatrixBlockKey, MatrixBlockEntry> cache = Ignition.localIgnite().getOrCreateCache(CACHE_NAME);

        MatrixBlockKey key = getCacheKey(getBlockId(a, b));

        // Local get.
        MatrixBlockEntry block = cache.localPeek(key, CachePeekMode.PRIMARY);

        if (block == null)
            block = cache.get(key);

        return block == null ? 0.0 : block.get(a % block.rowSize(), b % block.columnSize());
    });
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
/**
 * method assumes ChromosomeCriteria is set.
 * 
 * @param k - gene index in Chromosome.
 *            
 * @return long
 */
private long selectGeneByChromsomeCriteria(int k) {
    List<Gene> genes = new ArrayList();

    StringBuffer sbSqlClause = new StringBuffer("_val like '");
    sbSqlClause.append("%");
    sbSqlClause.append(config.getChromosomeCritiera().getCriteria().get(k));
    sbSqlClause.append("%'");

    IgniteCache<Long, Gene> cache = ignite.cache(GAGridConstants.GENE_CACHE);

    SqlQuery sql = new SqlQuery(Gene.class, sbSqlClause.toString());

    try (QueryCursor<Entry<Long, Gene>> cursor = cache.query(sql)) {
        for (Entry<Long, Gene> e : cursor)
            genes.add(e.getValue());
    }

    int idx = selectRandomIndex(genes.size());

    Gene gene = genes.get(idx);
    return gene.id();
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
private Chromosome getChromosome(Long key) {
    IgniteCache<Long, Chromosome> cache = ignite.cache(GAGridConstants.POPULATION_CACHE);
    StringBuffer sbSqlClause = new StringBuffer();
    sbSqlClause.append("_key IN (");
    sbSqlClause.append(key);
    sbSqlClause.append(")");

    Chromosome chromosome = null;

    SqlQuery sql = new SqlQuery(Chromosome.class, sbSqlClause.toString());

    try (QueryCursor<Entry<Long, Chromosome>> cursor = cache.query(sql)) {
        for (Entry<Long, Chromosome> e : cursor)
            chromosome = (e.getValue())

            ;
    }

    return chromosome;
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
@Test(dataProvider = DataProviders.KV_META_LIST_PROVIDER)
public void loadAllPersons(List<KeyValueAndMetadata> kvMetas, String dbMode) throws SQLException {
    JDBCUtil.setDBMode(dataSource, dbMode);
    JDBCUtil.applyInConnection(dataSource, connection -> {
        for (KeyValueAndMetadata kvMeta : kvMetas) {
            JDBCUtil.insertIntoDB(connection, kvMeta);
        }
    });
    Map<Integer, Object> expectedResults = kvMetas
            .stream()
            .collect(Collectors.toMap(KeyValueAndMetadata::getKey, KeyValueAndMetadata::getUnwrappedValue));
    String cacheName = kvMetas.get(0).getCacheName();
    IgniteCache<Integer, Object> cache = ignite().cache(cacheName);
    Map<Integer, Object> results = cache.getAll(expectedResults.keySet());

    assertEquals(results, expectedResults);
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
@Test
public void gapDetectionProcessFillsGaps() throws Exception {
    int firstKey = 1;
    PrimitivesHolder firstValue = new PrimitivesHolder();
    IgniteCache<Integer, PrimitivesHolder> cache = ignite().cache(PrimitivesHolder.CACHE);
    cache.put(firstKey, firstValue);

    long missedTx = createGap();
    int lastKey = 2;
    PrimitivesHolder lastValue = new PrimitivesHolder(true, (byte) 1, (short) 1, 1, 1, 1, 1);
    cache.put(lastKey, lastValue);

    awaitReconciliationOnTransaction(missedTx);
    awaitTransactions();
    Map<Integer, PrimitivesHolder> expected = new LinkedHashMap<>();
    expected.put(firstKey, firstValue);
    expected.put(lastKey, lastValue);
    assertObjectsInDB(expected, false);
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
public static <V> Reference<V> getReference(Ignite ignite, final String name, boolean create) {
    final IgniteCache<Object, Object> cache = create ? ignite.getOrCreateCache(NAME) : ignite.cache(NAME);
    return new Reference<V>() {
        @Override
        public V get() {
            return cache == null ? null : (V) cache.get(name);
        }

        @Override
        public void set(V value) {
            if (value == null) {
                cache.remove(name);
            } else {
                cache.put(name, value);
            }
        }
    };
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
/** */
private static double queryAccountBalance(Account account,
    IgniteCache<AccountTransactionKey, AccountTransaction> accountTxCache) {
    double result = 0;
    int accountId = account.getAccountKey().getAccountId();

    for (AccountTransactionKey txKey : account.getTransactionKeys().values()) {
        AccountTransaction transaction = accountTxCache.get(txKey);

        if (accountId == transaction.getFromAccountId()) {
            result -= transaction.getMoneyAmount();
        }
        else {
            result += transaction.getMoneyAmount();
        }
    }
    return result;
}
 

import org.apache.ignite.IgniteCache; //导入依赖的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.IgniteCache; //导入依赖的package包/类
/**
 * Creates cache with full configuration. Active store is used.
 *
 * @param cacheName name of cache.
 * @param atomicityMode atomicity.
 * @param cacheMode mode.
 * @param writeBehindEnabled should write behind be used for active store.
 * @param flushFreq flush frequency for write behind.
 * @param base configuration to copy settings from.
 * @param <K> type of key.
 * @param <V> type of value
 * @return cache instance.
 */
@SuppressWarnings("unchecked")
public <K, V> IgniteCache<K, V> createCache(String cacheName, CacheAtomicityMode atomicityMode, CacheMode cacheMode,
    boolean writeBehindEnabled, int flushFreq,
    CacheConfiguration<K, V> base) {
    CacheConfiguration<K, V> realConfiguration = base == null
        ? new CacheConfiguration<K, V>()
        : new CacheConfiguration<K, V>(base);
    realConfiguration.setName(cacheName);
    realConfiguration.setAtomicityMode(atomicityMode);
    realConfiguration.setCacheMode(cacheMode);
    realConfiguration.setBackups(2);
    realConfiguration.setWriteThrough(true);
    realConfiguration.setReadThrough(true);
    realConfiguration.setWriteBehindEnabled(writeBehindEnabled);
    realConfiguration.setWriteBehindFlushFrequency(flushFreq);
    realConfiguration.setCacheStoreFactory(activeStoreConfiguration.activeCacheStoreFactory());
    return ignite().createCache(realConfiguration);
}
 

import org.apache.ignite.IgniteCache; //导入依赖的package包/类
/** */
@Test
public void testRead() {
    initializeKV();

    Object[] result = resource.ignite().compute().call(new IgniteCallable<Object[]>() {
        @Override public Object[] call() throws Exception {
            IgniteCache<Object, Object> cache = Ignition.localIgnite().cache(firstCache);
            return new Object[] {
                cache.get("a"),
                cache.get("b"),
                cache.get("c"),
                cache.get("d"),
                cache.get("e")
            };
        }
    });

    Assert.assertEquals("1", result[0]);
    Assert.assertEquals("3", result[1]);
    Assert.assertEquals("4", result[2]);
    Assert.assertNull(result[3]);
    Assert.assertNull(result[4]);
}