/** * 全局扫描hset * * @param match field匹配模式 */ public List<Map.Entry<String, String>> scanHSet(String domain, String match) { try (ShardedJedis shardedJedis = shardedJedisPool.getResource()) { int cursor = 0; ScanParams scanParams = new ScanParams(); scanParams.match(match); Jedis jedis = shardedJedis.getShard(domain); ScanResult<Map.Entry<String, String>> scanResult; List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(); do { scanResult = jedis.hscan(domain, String.valueOf(cursor), scanParams); list.addAll(scanResult.getResult()); cursor = Integer.parseInt(scanResult.getStringCursor()); } while (cursor > 0); return list; } }
@Override public List<Map.Entry<String, String>> hscan(final String bizkey, final String nameSpace, final String match) { final String key = CacheUtils.getKeyByNamespace(bizkey,nameSpace); return this.performFunction(key, new CallBack<List<Map.Entry<String, String>>>() { public List<Map.Entry<String, String>> invoke(Jedis jedis) { try{ int cursor = 0; ScanParams scanParams = new ScanParams(); scanParams.match(match); ScanResult<Map.Entry<String,String>> scanResult; List<Map.Entry<String, String>> res = new ArrayList<Map.Entry<String, String>>(); do { scanResult = jedis.hscan(key, String.valueOf(cursor), scanParams); res.addAll(scanResult.getResult()); cursor = Integer.parseInt(scanResult.getStringCursor()); } while (cursor > 0); return res; } catch (Exception ex) { logger.error("hscan key:"+key+",match:"+match+",error:", ex); } return null; } }); }
@Override public Set<String> sscan(final String bizkey,final String nameSpace, final String match) { final String key = CacheUtils.getKeyByNamespace(bizkey,nameSpace); return this.performFunction(key, new CallBack<Set<String>>() { public Set<String> invoke(Jedis jedis) { try{ int cursor = 0; ScanParams scanParams = new ScanParams(); scanParams.match(match); ScanResult<String> scanResult; Set<String> res = new HashSet<String>(); do { scanResult = jedis.sscan(key, String.valueOf(cursor), scanParams); res.addAll(scanResult.getResult()); cursor = Integer.parseInt(scanResult.getStringCursor()); } while (cursor > 0); return res; } catch (Exception ex) { logger.error("sscan key:"+key+",match:"+match+",error:", ex); } return null; } }); }
private void listKeys0() { if (StringUtils.isBlank(this.txtKeyPattern.getText())) { this.txtKeyPattern.setText("*"); } String pattern = this.txtKeyPattern.getText(); int limit = Integer.parseInt(String.valueOf(cmbLimit.getValue())); ObservableList<KeyItem> items = this.tblKeys.getItems(); items.clear(); if (pattern.trim().length() > 0) { try (Jedis jedis = JedisManager.getJedis()) { ScanParams scanParams = new ScanParams().match(pattern).count(limit); ScanResult<String> result = jedis.scan(ScanParams.SCAN_POINTER_START, scanParams); result.getResult().forEach(key -> { String type = jedis.type(key); items.add(new KeyItem(key, type)); }); } } }
@Override public Completable removeAll() { return Completable.fromAction(() -> { Set<String> matchingKeys = new HashSet<>(); ScanParams params = new ScanParams(); params.match(prefixAndDelim + "*"); try(Jedis jedis = pool.getResource()) { String nextCursor = "0"; do { ScanResult<String> scanResult = jedis.scan(nextCursor, params); List<String> keys = scanResult.getResult(); nextCursor = scanResult.getStringCursor(); matchingKeys.addAll(keys); } while(!nextCursor.equals("0")); jedis.del(matchingKeys.toArray(new String[matchingKeys.size()])); } }); }
@Override public List<Map.Entry<String, String>> hscan(final String bizkey, final String nameSpace, final String match) { final String key = CacheUtils.getKeyByNamespace(bizkey, nameSpace); return this.performFunction(key, new CallBack<List<Map.Entry<String, String>>>() { public List<Map.Entry<String, String>> invoke(Jedis jedis) { try { int cursor = 0; ScanParams scanParams = new ScanParams(); scanParams.match(match); ScanResult<Map.Entry<String, String>> scanResult; List<Map.Entry<String, String>> res = new ArrayList<Map.Entry<String, String>>(); do { scanResult = jedis.hscan(key, String.valueOf(cursor), scanParams); res.addAll(scanResult.getResult()); cursor = Integer.parseInt(scanResult.getStringCursor()); } while (cursor > 0); return res; } catch (Exception ex) { logger.error("hscan key:" + key + ",match:" + match + ",error:", ex); } return null; } }); }
@Override public Set<String> sscan(final String bizkey, final String nameSpace, final String match) { final String key = CacheUtils.getKeyByNamespace(bizkey, nameSpace); return this.performFunction(key, new CallBack<Set<String>>() { public Set<String> invoke(Jedis jedis) { try { int cursor = 0; ScanParams scanParams = new ScanParams(); scanParams.match(match); ScanResult<String> scanResult; Set<String> res = new HashSet<String>(); do { scanResult = jedis.sscan(key, String.valueOf(cursor), scanParams); res.addAll(scanResult.getResult()); cursor = Integer.parseInt(scanResult.getStringCursor()); } while (cursor > 0); return res; } catch (Exception ex) { logger.error("sscan key:" + key + ",match:" + match + ",error:", ex); } return null; } }); }
public Set<String> smembers(String key) { logger.trace("smembers {}", key); JedisCommands client = dynoClient; Set<String> r = new HashSet<>(); int cursor = 0; ScanParams sp = new ScanParams(); sp.count(50); do { ScanResult<String> sr = client.sscan(key, "" + cursor, sp); cursor = Integer.parseInt(sr.getStringCursor()); r.addAll(sr.getResult()); } while (cursor > 0); return r; }
/** * 返回指定数量的匹配值 * * @param cursor * @param count * @param patterns * @return */ public ScanResult<String> scan(final String cursor, final Integer count, final String... patterns) { ScanParams params = new ScanParams(); for (String pattern : patterns) { params.match(pattern); } if (null != count) { params.count(count); } if (RedisConstants.isInUse()) { return getTemplate().execute(new JedisCallBackHandler<ScanResult<String>>() { public ScanResult<String> invoke(Jedis jedis) { return jedis.scan(cursor, params); } }); } else { return null; } }
/** * 命令用于迭代哈希键中的键值对 * * @param key * @param cursor * @param count * @param patterns * @return */ public ScanResult<Entry<String, String>> hscan(final String key, final String cursor, final Integer count, final String... patterns) { ScanParams params = new ScanParams(); for (String pattern : patterns) { params.match(pattern); } if (null != count) { params.count(count); } if (RedisConstants.isInUse()) { return getTemplate().execute(new JedisCallBackHandler<ScanResult<Entry<String, String>>>() { public ScanResult<Entry<String, String>> invoke(Jedis jedis) { return jedis.hscan(key, cursor, params); } }); } else { return null; } }
/** * 返回指定数量的匹配值 * * @param cursor * @param count * @param patterns * @return */ public ScanResult<String> scan(final String cursor, final Integer count, final String... patterns) { ScanParams params = new ScanParams(); for (String pattern : patterns) { params.match(pattern); } if (null != count) { params.count(count); } if (RedisConstants.isInUse()) { return getTemplate().executeRead(new JedisCallBackHandler<ScanResult<String>>() { public ScanResult<String> invoke(Jedis jedis) { return jedis.scan(cursor, params); } }); } else { return null; } }
/** * 命令用于迭代哈希键中的键值对 * * @param key * @param cursor * @param count * @param patterns * @return */ public ScanResult<Entry<String, String>> hscan(final String key, final String cursor, final Integer count, final String... patterns) { ScanParams params = new ScanParams(); for (String pattern : patterns) { params.match(pattern); } if (null != count) { params.count(count); } if (RedisConstants.isInUse()) { return getTemplate().executeRead(new JedisCallBackHandler<ScanResult<Entry<String, String>>>() { public ScanResult<Entry<String, String>> invoke(Jedis jedis) { return jedis.hscan(key, cursor, params); } }); } else { return null; } }
@Override public Collection<SecurityInfo> getAll() { try (Jedis j = pool.getResource()) { ScanParams params = new ScanParams().match(SEC_EP + "*").count(100); Collection<SecurityInfo> list = new LinkedList<>(); String cursor = "0"; do { ScanResult<byte[]> res = j.scan(cursor.getBytes(), params); for (byte[] key : res.getResult()) { byte[] element = j.get(key); list.add(deserialize(element)); } cursor = res.getStringCursor(); } while (!"0".equals(cursor)); return list; } }
@Override public void run() { try (Jedis j = pool.getResource()) { ScanParams params = new ScanParams().match(REG_EP + "*").count(100); String cursor = "0"; do { ScanResult<byte[]> res = j.scan(cursor.getBytes(), params); for (byte[] key : res.getResult()) { Registration r = deserializeReg(j.get(key)); if (!r.isAlive(gracePeriod)) { Deregistration dereg = removeRegistration(j, r.getId(), true); if (dereg != null) expirationListener.registrationExpired(dereg.getRegistration(), dereg.getObservations()); } } cursor = res.getStringCursor(); } while (!"0".equals(cursor)); } catch (Exception e) { LOG.warn("Unexpected Exception while registration cleaning", e); } }
@Override public void setup(OperatorContext context) { super.setup(context); sleepTimeMillis = context.getValue(context.SPIN_MILLIS); getWindowDataManager().setup(context); this.context = context; scanOffset = 0; scanComplete = false; scanParameters = new ScanParams(); scanParameters.count(scanCount); // For the 1st window after checkpoint, windowID - 1 would not have recovery // offset stored in windowDataManager // But recoveryOffset is non-transient, so will be recovered with // checkPointing // Offset recovery from idempotency storage can be skipped in this case scanOffset = recoveryState.scanOffsetAtBeginWindow; skipOffsetRecovery = true; }
/** * Construct the iterator to start at the cursor with no match results. * * @param redisClient The client to use; may not be {@code null}. * @param cursor The cursor to start at; may not be {@code null}. * @param params The parameters; {@code null} means no parameters. */ public ScanSpliterator(Redis redisClient, String cursor, ScanParams params) throws Exception { Objects.requireNonNull(redisClient, "Client for Redis"); Objects.requireNonNull(cursor, "The cursor to start from (you probably meanto use STARTING_CURSOR)"); ScanResult<String> scanResult = redisClient.withRedis(jedis -> { if (params == null) { return jedis.scan(cursor); } else { return jedis.scan(cursor, params); } }); results = scanResult.getResult().toArray(new String[scanResult.getResult().size()]); if (scanResult.getStringCursor().equals("0")) { this.next = null; } else { this.next = ForkJoinPool.commonPool().submit(() -> { return new ScanSpliterator(redisClient, scanResult.getStringCursor(), params); }); } }
@Override public ScanResult<String> scan(final long cursor, final ScanParams params) { ShardedJedis shardedJedis = null; try { shardedJedis = POOL.getJedis(config.getRedisType()); final Collection<Jedis> allJedis = shardedJedis.getAllShards(); if (allJedis.size() == 1) { final Jedis jedis = allJedis.iterator().next(); if (params == null) { return jedis.scan(String.valueOf(cursor), DEFAULT_SCAN_PARAMS); } else { return jedis.scan(String.valueOf(cursor), params); } } else { throw new RedisClientException("不支持对多节点Sharded模式进行Scan操作"); } } catch (final Throwable e) { if (e instanceof RedisClientException) { throw e; } throw new RedisClientException(e.getMessage(), e); } finally { POOL.close(shardedJedis); } }
@Override public ScanResult<Entry<String, Double>> zscan(final String key, final long cursor, final ScanParams params) { Assert.hasText(key); Assert.notNull(params); ShardedJedis jedis = null; try { jedis = POOL.getJedis(config.getRedisType()); final ScanResult<Tuple> res = jedis.zscan(key, String.valueOf(cursor), params); final List<Tuple> tuples = res.getResult(); if (CollectionUtils.isEmpty(tuples)) { return new ScanResult<>(res.getStringCursor(), Collections.emptyList()); } final List<Entry<String, Double>> newTuples = Lists.newArrayList(); tuples.forEach(tuple -> newTuples.add(new AbstractMap.SimpleEntry<>(tuple.getElement(), tuple.getScore()))); return new ScanResult<>(res.getStringCursor(), newTuples); } catch (final Throwable e) { throw new RedisClientException(e.getMessage(), e); } finally { POOL.close(jedis); } }
@Override public ScanResult<Entry<String, Double>> zscan(final String key, final long cursor, final ScanParams params) { Assert.hasText(key); Assert.notNull(params); try { final ScanResult<Tuple> res = cluster.zscan(key, String.valueOf(cursor), params); final List<Tuple> tuples = res.getResult(); if (CollectionUtils.isEmpty(tuples)) { return new ScanResult<>(res.getStringCursor(), Collections.emptyList()); } final List<Entry<String, Double>> newTuples = Lists.newArrayList(); tuples.forEach(tuple -> newTuples.add(new AbstractMap.SimpleEntry<>(tuple.getElement(), tuple.getScore()))); return new ScanResult<>(res.getStringCursor(), newTuples); } catch (final Throwable e) { throw new RedisClientException(e.getMessage(), e); } }
@Test public void sscanTest() { final String key = "sscan.test"; final String prefix = "sscan.test-"; try { final List<String> values = Lists.newArrayList(); for (int idx = 0; idx < 1000; idx++) { values.add(prefix + idx); } redisClient.sadd(key, values.toArray(new String[values.size()])); final AtomicLong cursor = new AtomicLong(-1); final ScanParams params = new ScanParams().count(10); while (cursor.get() == -1 || cursor.get() > 0) { if (cursor.get() == -1) { cursor.set(0); } final ScanResult<String> res = redisClient.sscan(key, cursor.get(), params); cursor.set(Long.valueOf(res.getStringCursor())); } } finally { redisClient.del(key); } }
@Test public void zscanTest() { final String key = "zscan.test"; final String prefix = "zscan.test-"; try { final Map<Object, Double> map = Maps.newHashMap(); for (int idx = 0; idx < 1000; idx++) { map.put(prefix + idx, Double.valueOf(idx)); } redisClient.zadd(key, map); final AtomicLong cursor = new AtomicLong(-1); final ScanParams params = new ScanParams().count(10); while (cursor.get() == -1 || cursor.get() > 0) { if (cursor.get() == -1) { cursor.set(0); } final ScanResult<Entry<String, Double>> res = redisClient.zscan(key, cursor.get(), params); cursor.set(Long.valueOf(res.getStringCursor())); } } finally { redisClient.del(key); } }
@Test public void scanTest() { final String prefix = "scan.test-"; final Map<String, Object> map = Maps.newHashMap(); for (int idx = 0; idx < 100; idx++) { map.put(prefix + idx, idx); } redisClient.set(map); final ScanParams params = new ScanParams().match(prefix + '*'); long cursor = -1; while (cursor == -1 || cursor > 0) { final ScanResult<String> res = redisClient.scan(cursor == -1 ? 0 : cursor, params); final String nextCursor = res.getStringCursor(); cursor = Long.parseLong(nextCursor); final List<String> keys = res.getResult(); LOGGER.debug("{}", keys); if (cursor > 0) { Assert.assertTrue(keys.size() > 0); } } redisClient.del(map.keySet().toArray(new String[map.size()])); }
@Override public ScanResult<String> scan(String cursor, ScanParams params) { Span span = helper.buildSpan("scan"); span.setTag("cursor", cursor); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.scan(cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<Entry<String, String>> hscan(String key, String cursor, ScanParams params) { Span span = helper.buildSpan("hscan", key); span.setTag("cursor", cursor); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.hscan(key, cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<String> sscan(String key, String cursor, ScanParams params) { Span span = helper.buildSpan("sscan", key); span.setTag("cursor", cursor); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.sscan(key, cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<Tuple> zscan(String key, String cursor, ScanParams params) { Span span = helper.buildSpan("zscan", key); span.setTag("cursor", cursor); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.zscan(key, cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<byte[]> scan(byte[] cursor, ScanParams params) { Span span = helper.buildSpan("scan"); span.setTag("cursor", Arrays.toString(cursor)); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.scan(cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<Entry<byte[], byte[]>> hscan(byte[] key, byte[] cursor, ScanParams params) { Span span = helper.buildSpan("hscan", key); span.setTag("cursor", Arrays.toString(cursor)); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.hscan(key, cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<byte[]> sscan(byte[] key, byte[] cursor, ScanParams params) { Span span = helper.buildSpan("sscan", key); span.setTag("cursor", Arrays.toString(cursor)); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.sscan(key, cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<Tuple> zscan(byte[] key, byte[] cursor, ScanParams params) { Span span = helper.buildSpan("zscan", key); span.setTag("cursor", Arrays.toString(cursor)); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.zscan(key, cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<String> scan(int cursor, ScanParams params) { Span span = helper.buildSpan("scan"); span.setTag("cursor", cursor); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.scan(cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<Entry<String, String>> hscan(String key, int cursor, ScanParams params) { Span span = helper.buildSpan("hscan", key); span.setTag("cursor", cursor); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.hscan(key, cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }
@Override public ScanResult<String> sscan(String key, int cursor, ScanParams params) { Span span = helper.buildSpan("sscan", key); span.setTag("cursor", cursor); span.setTag("params", TracingHelper.toString(params.getParams())); try { return super.sscan(key, cursor, params); } catch (Exception e) { onError(e, span); throw e; } finally { span.finish(); } }