How to use

DefaultValueOperations

in

org.springframework.data.redis.core

@Override
public ValueOperations<K, V> opsForValue() {
  if (valueOps == null) {
    valueOps = new DefaultValueOperations<>(this);
  }
  return valueOps;
}

@Override
public String get(K key, long start, long end) {
  byte[] rawKey = rawKey(key);
  byte[] rawReturn = execute(connection -> connection.getRange(rawKey, start, end), true);
  return deserializeString(rawReturn);
}

@Override
public List<V> multiGet(Collection<K> keys) {
  if (keys.isEmpty()) {
    return Collections.emptyList();
  }
  byte[][] rawKeys = new byte[keys.size()][];
  int counter = 0;
  for (K hashKey : keys) {
    rawKeys[counter++] = rawKey(hashKey);
  }
  List<byte[]> rawValues = execute(connection -> connection.mGet(rawKeys), true);
  return deserializeValues(rawValues);
}

@Override
public void set(K key, V value) {
  byte[] rawValue = rawValue(value);
  execute(new ValueDeserializingRedisCallback(key) {
    @Override
    protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
      connection.set(rawKey, rawValue);
      return null;
    }
  }, true);
}

@Override
public void set(K key, V value, long offset) {
  byte[] rawKey = rawKey(key);
  byte[] rawValue = rawValue(value);
  execute(connection -> {
    connection.setRange(rawKey, rawValue, offset);
    return null;
  }, true);
}

@Override
public Boolean setIfAbsent(K key, V value, long timeout, TimeUnit unit) {
  byte[] rawKey = rawKey(key);
  byte[] rawValue = rawValue(value);
  Expiration expiration = Expiration.from(timeout, unit);
  return execute(connection -> connection.set(rawKey, rawValue, expiration, SetOption.ifAbsent()), true);
}

@Override
public Boolean setIfAbsent(K key, V value) {
  byte[] rawKey = rawKey(key);
  byte[] rawValue = rawValue(value);
  return execute(connection -> connection.setNX(rawKey, rawValue), true);
}

@Override
public Long increment(K key) {
  byte[] rawKey = rawKey(key);
  return execute(connection -> connection.incr(rawKey), true);
}

@Override
public Long increment(K key, long delta) {
  byte[] rawKey = rawKey(key);
  return execute(connection -> connection.incrBy(rawKey, delta), true);
}

@Override
public Integer append(K key, String value) {
  byte[] rawKey = rawKey(key);
  byte[] rawString = rawString(value);
  return execute(connection -> {
    Long result = connection.append(rawKey, rawString);
    return (result != null) ? result.intValue() : null;
  }, true);
}

@Override
public Long decrement(K key) {
  byte[] rawKey = rawKey(key);
  return execute(connection -> connection.decr(rawKey), true);
}

@Override
public Boolean multiSetIfAbsent(Map<? extends K, ? extends V> m) {
  if (m.isEmpty()) {
    return true;
  }
  Map<byte[], byte[]> rawKeys = new LinkedHashMap<>(m.size());
  for (Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
    rawKeys.put(rawKey(entry.getKey()), rawValue(entry.getValue()));
  }
  return execute(connection -> connection.mSetNX(rawKeys), true);
}

@Override
public void multiSet(Map<? extends K, ? extends V> m) {
  if (m.isEmpty()) {
    return;
  }
  Map<byte[], byte[]> rawKeys = new LinkedHashMap<>(m.size());
  for (Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
    rawKeys.put(rawKey(entry.getKey()), rawValue(entry.getValue()));
  }
  execute(connection -> {
    connection.mSet(rawKeys);
    return null;
  }, true);
}

@Override
public Long decrement(K key, long delta) {
  byte[] rawKey = rawKey(key);
  return execute(connection -> connection.decrBy(rawKey, delta), true);
}

@Override
public Boolean setBit(K key, long offset, boolean value) {
  byte[] rawKey = rawKey(key);
  return execute(connection -> connection.setBit(rawKey, offset, value), true);
}

@Override
public Boolean getBit(K key, long offset) {
  byte[] rawKey = rawKey(key);
  return execute(connection -> connection.getBit(rawKey, offset), true);
}

@Override
public Long size(K key) {
  byte[] rawKey = rawKey(key);
  return execute(connection -> connection.strLen(rawKey), true);
}

  @Override
  public List<Long> bitField(K key, final BitFieldSubCommands subCommands) {

    byte[] rawKey = rawKey(key);
    return execute(connection -> connection.bitField(rawKey, subCommands), true);
  }
}

@Override
public void set(K key, V value, long timeout, TimeUnit unit) {
  byte[] rawKey = rawKey(key);
  byte[] rawValue = rawValue(value);
  execute(new RedisCallback<Object>() {
    @Override
    public Object doInRedis(RedisConnection connection) throws DataAccessException {
      potentiallyUsePsetEx(connection);
      return null;
    }
    public void potentiallyUsePsetEx(RedisConnection connection) {
      if (!TimeUnit.MILLISECONDS.equals(unit) || !failsafeInvokePsetEx(connection)) {
        connection.setEx(rawKey, TimeoutUtils.toSeconds(timeout, unit), rawValue);
      }
    }
    private boolean failsafeInvokePsetEx(RedisConnection connection) {
      boolean failed = false;
      try {
        connection.pSetEx(rawKey, timeout, rawValue);
      } catch (UnsupportedOperationException e) {
        // in case the connection does not support pSetEx return false to allow fallback to other operation.
        failed = true;
      }
      return !failed;
    }
  }, true);
}

@Override
public V get(Object key) {
  return execute(new ValueDeserializingRedisCallback(key) {
    @Override
    protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
      return connection.get(rawKey);
    }
  }, true);
}