Java GridCache类代码示例

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
private static GridCache tryCache(String name) {
    GridCache cache = null;

    if (state.equals(ConnState.CONNECTED)) {
        logger.fine("[State " + state.name() + "] Trying to get cache " + name + " from the grid cause im connected to it");

        try {
            cache = grid.cache(name);
        } catch (RuntimeException e) {
            logger.log(Level.SEVERE, "Runtime exception when calling cache: " + e.getMessage());
            notifyFail();
        }
    } else {
        logger.fine("[State " + state.name() + "] Tried to get cache " + name + " from the grid, but im not connected");
    }

    return cache;
}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static void main(String[] args) throws FileNotFoundException, IOException, GridException, InterruptedException {
	try (AnnotationConfigApplicationContext appCtx = new AnnotationConfigApplicationContext(LumenConfig.class)) {
		Grid grid = appCtx.getBean(Grid.class);
		
		GridCache<String, YagoRule> ruleCache = YagoRule.cache(grid);
		GridCache<String, YagoLabel> labelCache = YagoLabel.cache(grid);
		GridCache<String, ListMultimap<String, String>> entityByLabelCache = YagoLabel.entityByLabelCache(grid);
		
		grid.compute().broadcast((GridRunnable) () -> {
			try {
				log.info("For yagoRule, I have {} primary out of {} entries + {} swap", 
						ruleCache.primarySize(), ruleCache.size(), ruleCache.swapKeys());
				log.info("For yagoLabel, I have {} primary out of {} entries + {} swap", 
						labelCache.primarySize(), labelCache.size(), labelCache.swapKeys());
				log.info("For entityByLabel, I have {} primary out of {} entries + {} swap", 
						entityByLabelCache.primarySize(), entityByLabelCache.size(), entityByLabelCache.swapKeys());
			} catch (Exception e) {
				log.error("swapKeys error", e);
			}
		});
	}
	
}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static void main(String[] args) throws GridException {
		try (Grid grid = GridGain.start(
				System.getProperty("user.home") + "/gridgain-platform-os-6.1.9-nix/examples/config/example-cache.xml")) {
			GridCache<Integer, String> cache = grid.cache("partitioned");
//			String oldVal = cache.put(1, "1");
//			boolean success = cache.putx(2, "2");
//			boolean success2 = cache.putxIfAbsent(3, "3");
//			log.info("Current 3 value = {}", cache.get(3));
//			cache.transform(3, (it) -> it + "-transformed");
			log.info("Transformed 3 value = {}", cache.get(3));
		}
	}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static void main(String[] args) throws GridException {
		try (Grid grid = GridGain.start(
				System.getProperty("user.home") + "/gridgain-platform-os-6.1.9-nix/examples/config/example-cache.xml")) {
			GridCache<Integer, Oya> cache = grid.cache("partitioned");
//			String oldVal = cache.put(1, "1");
//			boolean success = cache.putx(2, "2");
			boolean success2 = cache.putxIfAbsent(3, new Oya("3"));
			log.info("Current 3 value = {}", cache.get(3));
			cache.transform(3, (it) -> new Oya(it.name + "-transformed"));
			log.info("Transformed 3 value = {}", cache.get(3));
		}
	}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static void main(String[] args) throws FileNotFoundException, IOException, GridException, InterruptedException {
		try (AnnotationConfigApplicationContext appCtx = new AnnotationConfigApplicationContext(LumenConfig.class)) {
			Grid grid = appCtx.getBean(Grid.class);
			
			GridCache<String, YagoRule> ruleCache = YagoRule.cache(grid);
			if (ruleCache.isEmpty()) {
				log.info("Loading rules...");
				ruleCache.loadCache(null, 0);
			}
			log.info("For yagoRule, I have {} primary out of {} entries + {} swap", 
					ruleCache.primarySize(), ruleCache.size(), ruleCache.swapKeys());
			
			GridCache<String, YagoLabel> labelCache = YagoLabel.cache(grid);
//			if (labelCache.isEmpty()) {
//				log.info("Loading labels...");
//				labelCache.loadCache(null, 0);
//			}
			log.info("For yagoLabel, I have {} primary out of {} entries + {} swap", 
					labelCache.primarySize(), labelCache.size(), labelCache.swapKeys());
			
			GridCache<String, ListMultimap<String, String>> entityByLabelCache = YagoLabel.entityByLabelCache(grid);
//			if (labelCache.isEmpty()) {
//				log.info("Loading labels...");
//				labelCache.loadCache(null, 0);
//			}
			log.info("For entityByLabel, I have {} primary out of {} entries + {} swap", 
					entityByLabelCache.primarySize(), entityByLabelCache.size(), entityByLabelCache.swapKeys());
			
			Thread.currentThread().join();
		}
	}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static void main(String[] args) throws FileNotFoundException, IOException, GridException {
	String entityId = "Muhammad";
	
	try (AnnotationConfigApplicationContext appCtx = new AnnotationConfigApplicationContext(LumenConfig.class)) {
		Grid grid = appCtx.getBean(Grid.class);
		GridCache<String, YagoLabel> labelCache = YagoLabel.cache(grid);
		log.info("Label for {}: {}", entityId, labelCache.get(entityId));
	}
	
}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static void main(String[] args) throws FileNotFoundException, IOException, GridException {
		String upLabel = "Muhammad";
		
		try (Grid grid = GridGain.start(YagoLabelLookupCli2.class.getResource("yago.gridgain.xml"))) {
			GridCache<String, String> labelCache = grid.cache("yagoLabel");
//			labelCache.queries().createScanQuery(null).execute((GridClosure<Entry<String, String>, String>) (it) ->
//				it.getValue().equalsIgnoreCase(upLabel) ? it.getKey() : null);
			log.info("Finding resource for label '{}'...", upLabel);
			Collection<Set<String>> founds = labelCache.queries().createScanQuery(null).execute(new GridReducer<Entry<String, String>, Set<String>>() {
				Set<String> ids = new HashSet<>();
				
				@Override
				public boolean collect(Entry<String, String> e) {
					if (e.getValue().equalsIgnoreCase(upLabel)) {
						ids.add( e.getKey() );
					}
					return true;
				}
				
				@Override
				public Set<String> reduce() {
					return ids;
				}
			}).get();
			
			log.info("Found for {}: {}", upLabel, founds);
		}
		
	}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static void main(String[] args) throws FileNotFoundException, IOException, GridException {
		String upLabel = "Muhammad";
		
		try (AnnotationConfigApplicationContext appCtx = new AnnotationConfigApplicationContext(LumenConfig.class)) {
			Grid grid = appCtx.getBean(Grid.class);
			GridCache<String, ListMultimap<String, String>> entityByLabelCache = YagoLabel.entityByLabelCache(grid);
//			labelCache.queries().createScanQuery(null).execute((GridClosure<Entry<String, String>, String>) (it) ->
//				it.getValue().equalsIgnoreCase(upLabel) ? it.getKey() : null);
			log.info("Finding resource for label '{}'...", upLabel);
//			entityByLabelCache.removex(upLabel);
			ListMultimap<String, String> entities = entityByLabelCache.get(upLabel);
			log.info("Found for {}: {}", upLabel, entities);
		}
		
	}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static void main(String[] args) throws FileNotFoundException, IOException, GridException {
		String upLabel = "Muhammad";
		
		try (Grid grid = GridGain.start(YagoLabelLookupCli.class.getResource("yago.gridgain.xml"))) {
			GridCache<String, String> labelCache = grid.cache("yagoLabel");
//			labelCache.queries().createScanQuery(null).execute((GridClosure<Entry<String, String>, String>) (it) ->
//				it.getValue().equalsIgnoreCase(upLabel) ? it.getKey() : null);
			log.info("Finding resource for label '{}'...", upLabel);
			Collection<String> founds = labelCache.queries().createScanQuery(null).execute(new GridReducer<Entry<String, String>, String>() {
				String id;
				
				@Override
				public boolean collect(Entry<String, String> e) {
					if (e.getValue().equalsIgnoreCase(upLabel)) {
						id = e.getKey();
						return false;
					} else {
						return true;
					}
				}
				
				@Override
				public String reduce() {
					return id;
				}
			}).get();
			
			log.info("Found for {}: {}", upLabel, founds);
		}
		
	}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public ConnectedGridGainStateCache(GridCache<K, V> gridMap) {
    setMap(gridMap);
}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public void setMap(GridCache<K, V> gridMap) {
    _gridMap = gridMap;
}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
@Test
public void gridGainStateTest() throws GridException {
    List<String> topics = new ArrayList<String>();
    topics.add("location");

    GridConfiguration ggConf = new GridConfiguration();
    GridCacheConfiguration cacheLocation = new GridCacheConfiguration();
    cacheLocation.setName("location");
    cacheLocation.setCacheMode(GridCacheMode.PARTITIONED);
    ggConf.setCacheConfiguration(cacheLocation);
    Grid grid = GridGain.start(ggConf);

    GridCache<String, Map<String, Object>> map = grid.cache("location");

    GridGainStormState state = new GridGainStormState("location");

    List<List<Object>> keysList = new ArrayList<>();

    List<Object> keys = new ArrayList<>();
    keys.add("A");
    keysList.add(keys);

    keys = new ArrayList<>();
    keys.add("B");
    keysList.add(keys);

    keys = new ArrayList<>();
    keys.add("C");
    keysList.add(keys);

    List<Map<String, Map<String, Object>>> valuesList = new ArrayList<>();
    Map<String, Map<String, Object>> values = new HashMap<>();

    Map<String, Object> value = new HashMap<>();

    value.put("A1", 1);
    values.put("A", value);

    value = new HashMap<>();
    value.put("B1", 2);
    values.put("B", value);

    value = new HashMap<>();
    value.put("C1", 3);
    values.put("C", value);

    valuesList.add(values);


    state.multiPut(keysList, valuesList);


    List<Map<String, Map<String, Object>>> restoreList = state.multiGet(keysList);
    Map<String, Map<String, Object>> restore = restoreList.get(0);

    Assert.assertEquals(values.get("A"), restore.get("A"));
    Assert.assertEquals(values.get("A").get("A1"), restore.get("A").get("A1"));
    Assert.assertEquals(values.get("B"), restore.get("B"));
    Assert.assertEquals(values.get("B").get("B1"), restore.get("B").get("B1"));
    Assert.assertEquals(values.get("C"), restore.get("C"));
    Assert.assertEquals(values.get("C").get("C1"), restore.get("C").get("C1"));
    Assert.assertNotEquals(values.get("C").get("C1"), restore.get("B").get("B1"));

    grid.close();
}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static GridCache<String, YagoLabel> cache(Grid grid) {
	return grid.cache("yagoLabel");
}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static GridCache<String, ListMultimap<String, String>> entityByLabelCache(
		Grid grid) {
	return grid.cache("yagoEntityByLabel");
}
 

import org.gridgain.grid.cache.GridCache; //导入依赖的package包/类
public static GridCache<String, YagoRule> cache(Grid grid) {
	return grid.cache("yagoRule");
}