redis.clients.jedis.params.SetParams Java Examples

/**
 * 缓存value
 *
 * @param nxxx NX|XX, NX -- Only set the key if it does not already exist. XX
 *             -- Only set the key
 */
public boolean setValue(String key, String value, String nxxx, int seconds) {
    try {
        SetParams setParams = new SetParams();
        setParams.ex(seconds);
        String str = jedisCluster.set(key, value, setParams);
        if ("OK".equals(str)) {
            return true;
        }
    } catch (Exception e) {
        log.error("redis操作失败, key:{},value:{}", key, value, new CacheException(e));
    } finally {
        //jedisCluster.close();
    }

    return false;
}
 

@Override
protected CacheResult do_PUT_IF_ABSENT(K key, V value, long expireAfterWrite, TimeUnit timeUnit) {
    try (Jedis jedis = config.getJedisPool().getResource()) {
        CacheValueHolder<V> holder = new CacheValueHolder(value, timeUnit.toMillis(expireAfterWrite));
        byte[] newKey = buildKey(key);
        SetParams params = new SetParams();
        params.nx()
                .px(timeUnit.toMillis(expireAfterWrite));
        String rt = jedis.set(newKey, valueEncoder.apply(holder), params);
        if ("OK".equals(rt)) {
            return CacheResult.SUCCESS_WITHOUT_MSG;
        } else if (rt == null) {
            return CacheResult.EXISTS_WITHOUT_MSG;
        } else {
            return new CacheResult(CacheResultCode.FAIL, rt);
        }
    } catch (Exception ex) {
        logError("PUT_IF_ABSENT", key, ex);
        return new CacheResult(ex);
    }
}
 

public OperationResult<String> d_set(final String key, final String value, final String nxxx, final String expx,
                                     final long time) {
    SetParams setParams = SetParams.setParams();
    if (nxxx.equalsIgnoreCase("NX")) {
        setParams.nx();
    } else if (nxxx.equalsIgnoreCase("XX")) {
        setParams.xx();
    }
    if (expx.equalsIgnoreCase("EX")) {
        setParams.ex((int) time);
    } else if (expx.equalsIgnoreCase("PX")) {
        setParams.px(time);
    }

    return d_set(key, value, setParams);
}
 

public ExtendHost(Host host, ConnectionPool pool, LockResource lockResource, CountDownLatch latch, String randomKey) {
    super(host, pool);
    this.lockResource = lockResource;
    this.value = lockResource.getResource();
    this.params = SetParams.setParams().px(lockResource.getTtlMs());
    this.randomKey = randomKey;
    this.latch = latch;
}
 

private boolean acquireMessageLock(String messageKey, String identifier, int ackDeadlineSeconds) {
  String response =
      redisClientDelegate.withCommandsClient(
          c -> {
            return c.set(
                messageKey, identifier, SetParams.setParams().nx().ex(ackDeadlineSeconds));
          });
  return SUCCESS.equals(response);
}
 

/**
 * Attempt to acquire a lock
 * @return true if lock was successfully acquired; false otherwise
 */
public boolean lock(T jedis){
    UUID lockId = UUID.randomUUID();
    final String setResponse = jedis.set(redisSchema.lockKey(), lockId.toString(), SetParams.setParams().nx().px(lockTimeout));
    boolean lockAcquired = !isNullOrEmpty(setResponse) && setResponse.equals("OK");
    if(lockAcquired){
        // save the random value used to lock so that we can successfully unlock later
        lockValue = lockId;
    }
    return lockAcquired;
}
 

@Override
protected boolean setnx(String key, String val, int expire) {
    ShardedJedis shardedJedis = null;
    try {
        shardedJedis = shardedJedisPool.getResource();
        Jedis jedis = shardedJedis.getShard(key);
        return OK.equalsIgnoreCase(jedis.set(key, val, SetParams.setParams().nx().ex(expire)));
    } finally {
        returnResource(shardedJedis);
    }
}
 

/**
 * 带有过期时间的保存数据到redis，到期自动删除
 *
 * @param key
 * @param value
 * @param expireTime 单位 秒
 */
public void setString(String key, String value, int expireTime) {
  JedisPool instance = this.instance();
  if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value) || instance == null) return;
  Jedis jedis = instance.getResource();
  SetParams params = new SetParams();
  params.px(expireTime * 1000);
  jedis.set(key, value, params);
  jedis.close();
}
 

/**
 * 带有过期时间的保存数据到redis，到期自动删除
 *
 * @param key
 * @param value
 * @param expireTime 单位 秒
 */
public void setString(String key, String value, int expireTime) {
    JedisPool instance = this.instance();
    if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value) || instance == null) return;
    Jedis jedis = instance.getResource();
    SetParams params = new SetParams();
    params.px(expireTime * 1000);
    jedis.set(key, value, params);
    jedis.close();
}
 

public OperationResult<String> d_set(final byte[] key, final byte[] value, final SetParams setParams) {
    return connPool.executeWithFailover(new BaseKeyOperation<String>(key, OpName.SET) {
        @Override
        public String execute(Jedis client, ConnectionContext state) throws DynoException {
            return client.set(key, value, setParams);
        }
    });
}
 

public LockHost(Host host, ConnectionPool pool, LockResource lockResource, CountDownLatch latch, String randomKey) {
    super(host, pool);
    this.lockResource = lockResource;
    this.value = lockResource.getResource();
    this.params = SetParams.setParams().nx().px(lockResource.getTtlMs());
    this.randomKey = randomKey;
    this.latch = latch;
}
 

/**
 * 加锁，使用你自己创建的jedis对象
 *
 * @param key          键
 * @param value        值
 * @param shardedJedis 自己创建的jedis对象
 * @return
 */
public boolean lock(String key, String value, ShardedJedis shardedJedis) {
    try {
        if (shardedJedis == null) {
            return false;
        }
        int count = 0;

        SetParams params = SetParams.setParams().nx().px(5000);
        String result = shardedJedis.set(key, value, params);

        while (result == null || !result.toUpperCase().equals("OK")) {
            /* 如果设置失败，代表这个key已经存在了,也就说明锁被占用了，则进入等待 */
            Thread.sleep(500);
            if (count >= 19) {
                /* 10秒后还没有获取锁，则停止等待 */
                return false;
            }
            result = shardedJedis.set(key, value, params);

            count++;
        }
        return true;
    } catch (Exception e) {
        logger.error("获取redis锁发生异常", e);
        return false;
    } finally {
        marsRedisTemplate.recycleJedis(shardedJedis);
    }
}
 

@Override
public String set(byte[] key, byte[] value, SetParams params) {
  Span span = helper.buildSpan("set", key);
  span.setTag("value", Arrays.toString(value));
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> super.set(key, value, params));
}
 

@Override
public String set(String key, String value, SetParams params) {
  Span span = helper.buildSpan("set", key);
  span.setTag("value", value);
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> super.set(key, value, params));
}
 

@Override
public String set(byte[] key, byte[] value, SetParams params) {
  Span span = helper.buildSpan("set", key);
  span.setTag("value", Arrays.toString(value));
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> wrapped.set(key, value, params));
}
 

@Override
public String set(String key, String value, SetParams params) {
  Span span = helper.buildSpan("set", key);
  span.setTag("value", value);
  span.setTag("params", nullable(TracingHelper.toString(params.getByteParams())));
  return helper.decorate(span, () -> wrapped.set(key, value, params));
}
 

@Override
public String set(final byte[] key, final byte[] value, final SetParams params) {
  String command = "set";
  return instrumented(command, payloadSize(value), () -> delegated.set(key, value, params));
}
 

@Override
public Response<String> set(String key, String value, SetParams params) {
  String command = "set";
  return instrumented(command, payloadSize(value), () -> delegated.set(key, value, params));
}
 

@Override
public Response<String> set(byte[] key, byte[] value, SetParams params) {
  String command = "set";
  return instrumented(command, payloadSize(value), () -> delegated.set(key, value, params));
}
 

@Override
public String set(String key, String value, SetParams params) {
  String command = "set";
  return instrumented(command, payloadSize(value), () -> delegated.set(key, value, params));
}
 

@Override
public String set(final byte[] key, final byte[] value, final SetParams setParams) {
    return d_set(key, value, setParams).getResult();
}
 

public String set(final String key, final String value, final SetParams setParams) {
    return d_set(key, value, setParams).getResult();
}
 

@Override
public Response<String> set(byte[] key, byte[] value, SetParams params) {
    throw new UnsupportedOperationException("not yet implemented");
}
 

@Override
public Response<String> set(String key, String value, SetParams params) {
    return null;
}
 

@Override
public String set(String s, String s1, SetParams setParams) {
    return cluster.set(s, s1, setParams);
}
 

@Override
protected boolean setnx(String key, String val, int expire) {
    return OK.equalsIgnoreCase(jedisCluster.set(key, val, SetParams.setParams().nx().ex(expire)));
}
 

@Override
public String set(String key, String value, SetParams setParams) {
    return jedisCluster.set(key, value, setParams);
}
 

@Override
public String set(String key, String value, SetParams setParams) {
    try (Jedis jedis = jedisPool.getResource()) {
        return jedis.set(key, value, setParams);
    }
}
 

@Test
public void testSet() {
    jedisSentinel.set("key", "value");
    jedisSentinel.set("key", "value", SetParams.setParams());
}
 

@Test
public void testSet() {
    jedisCluster.set("key", "value");
    jedisCluster.set("key", "value", SetParams.setParams());
}