How to use

RedisKeyValueAdapter

in

org.springframework.data.redis.core

@Override
public RedisKeyValueAdapter create(CreationalContext<RedisKeyValueAdapter> creationalContext) {
  Type beanType = getBeanType();
  return new RedisKeyValueAdapter(getDependencyInstance(this.redisOperations, beanType));
}

@Override
public <T> T delete(Object id, String keyspace, Class<T> type) {
  byte[] binId = toBytes(id);
  byte[] binKeyspace = toBytes(keyspace);
  T o = get(id, keyspace, type);
  if (o != null) {
    byte[] keyToDelete = createKey(asString(keyspace), asString(id));
    redisOps.execute((RedisCallback<Void>) connection -> {
      connection.del(keyToDelete);
      connection.sRem(binKeyspace, binId);
      new IndexWriter(connection, converter).removeKeyFromIndexes(asString(keyspace), binId);
      return null;
    });
  }
  return o;
}

@Override
public long count(RedisOperationChain criteria, String keyspace) {
  if (criteria == null || criteria.isEmpty()) {
    return this.getAdapter().count(keyspace);
  }
  return this.getAdapter().execute(connection -> {
    long result = 0;
    if (!criteria.getOrSismember().isEmpty()) {
      result += connection.sUnion(keys(keyspace + ":", criteria.getOrSismember())).size();
    }
    if (!criteria.getSismember().isEmpty()) {
      result += connection.sInter(keys(keyspace + ":", criteria.getSismember())).size();
    }
    return result;
  });
}

public List<?> getAllOf(String keyspace, long offset, int rows) {
  byte[] binKeyspace = toBytes(keyspace);
  Set<byte[]> ids = redisOps.execute((RedisCallback<Set<byte[]>>) connection -> connection.sMembers(binKeyspace));
  List<Object> result = new ArrayList<>();
  List<byte[]> keys = new ArrayList<>(ids);
  if (keys.isEmpty() || keys.size() < offset) {
    return Collections.emptyList();
  }
  offset = Math.max(0, offset);
  if (rows > 0) {
    keys = keys.subList((int) offset, Math.min((int) offset + rows, keys.size()));
  }
  for (byte[] key : keys) {
    result.add(get(key, keyspace));
  }
  return result;
}

@Nullable
@Override
public <T> T get(Object id, String keyspace, Class<T> type) {
  String stringId = asString(id);
  String stringKeyspace = asString(keyspace);
  byte[] binId = createKey(stringKeyspace, stringId);
  Map<byte[], byte[]> raw = redisOps
      .execute((RedisCallback<Map<byte[], byte[]>>) connection -> connection.hGetAll(binId));
  RedisData data = new RedisData(raw);
  data.setId(stringId);
  data.setKeyspace(stringKeyspace);
  return readBackTimeToLiveIfSet(binId, converter.read(type, data));
}

  initKeyExpirationListener();
byte[] key = toBytes(rdo.getId());
byte[] objectKey = createKey(rdo.getKeyspace(), rdo.getId());
connection.sAdd(toBytes(rdo.getKeyspace()), key);

    || (CollectionUtils.isEmpty(criteria.getOrSismember()) && CollectionUtils.isEmpty(criteria.getSismember()))
        && criteria.getNear() == null) {
  return (Collection<T>) getAdapter().getAllOf(keyspace, offset, rows);
  byte[] keyspaceBin = getAdapter().getConverter().getConversionService().convert(keyspace + ":", byte[].class);
};
Map<byte[], Map<byte[], byte[]>> raw = this.getAdapter().execute(callback);
  data.setId(getAdapter().getConverter().getConversionService().convert(entry.getKey(), String.class));
  data.setKeyspace(keyspace);
  T converted = this.getAdapter().getConverter().read(type, data);

Object id = update.getId();
byte[] redisKey = createKey(keyspace, converter.getConversionService().convert(id, String.class));
            && !converter.getConversionService().canConvert(pUpdate.getValue().getClass(), byte[].class))) {
      redisUpdateObject = fetchDeletePathsFromHashAndUpdateIndex(redisUpdateObject, propertyPath, connection);
      connection.zRem(index.key, toBytes(redisUpdateObject.targetId));
    } else {
      connection.sRem(index.key, toBytes(redisUpdateObject.targetId));
  new IndexWriter(connection, converter).updateIndexes(toBytes(id), rdo.getIndexedData());
  return null;
});

@Override
public void deleteAllOf(String keyspace) {
  redisOps.execute((RedisCallback<Void>) connection -> {
    connection.del(toBytes(keyspace));
    new IndexWriter(connection, converter).removeAllIndexes(asString(keyspace));
    return null;
  });
}

  @Override
  public List<T> doInRedis(RedisKeyValueAdapter adapter) {
    Object callbackResult = adapter.execute(callback);
    if (callbackResult == null) {
      return Collections.emptyList();
    }
    Iterable<?> ids = ClassUtils.isAssignable(Iterable.class, callbackResult.getClass())
        ? (Iterable<?>) callbackResult : Collections.singleton(callbackResult);
    List<T> result = new ArrayList<>();
    for (Object id : ids) {
      String idToUse = adapter.getConverter().getConversionService().canConvert(id.getClass(), String.class)
          ? adapter.getConverter().getConversionService().convert(id, String.class) : id.toString();
      findById(idToUse, type).ifPresent(result::add);
    }
    return result;
  }
});

@Override
public void destroy(RedisKeyValueAdapter instance, CreationalContext<RedisKeyValueAdapter> creationalContext) {
  if (instance instanceof DisposableBean) {
    try {
      instance.destroy();
    } catch (Exception e) {
      throw new IllegalStateException(e);
    }
  }
  super.destroy(instance, creationalContext);
}

@Nullable
@Override
public Object get(Object id, String keyspace) {
  return get(id, keyspace, Object.class);
}

@Override
public Object delete(Object id, String keyspace) {
  return delete(id, keyspace, Object.class);
}

@Override
public List<?> getAllOf(String keyspace) {
  return getAllOf(keyspace, -1, -1);
}

@Nullable
@Override
public <T> T get(Object id, String keyspace, Class<T> type) {
  String stringId = asString(id);
  String stringKeyspace = asString(keyspace);
  byte[] binId = createKey(stringKeyspace, stringId);
  Map<byte[], byte[]> raw = redisOps
      .execute((RedisCallback<Map<byte[], byte[]>>) connection -> connection.hGetAll(binId));
  RedisData data = new RedisData(raw);
  data.setId(stringId);
  data.setKeyspace(stringKeyspace);
  return readBackTimeToLiveIfSet(binId, converter.read(type, data));
}

  initKeyExpirationListener();
byte[] key = toBytes(rdo.getId());
byte[] objectKey = createKey(rdo.getKeyspace(), rdo.getId());
connection.sAdd(toBytes(rdo.getKeyspace()), key);

    || (CollectionUtils.isEmpty(criteria.getOrSismember()) && CollectionUtils.isEmpty(criteria.getSismember()))
        && criteria.getNear() == null) {
  return (Collection<T>) getAdapter().getAllOf(keyspace, offset, rows);
  byte[] keyspaceBin = getAdapter().getConverter().getConversionService().convert(keyspace + ":", byte[].class);
};
Map<byte[], Map<byte[], byte[]>> raw = this.getAdapter().execute(callback);
  data.setId(getAdapter().getConverter().getConversionService().convert(entry.getKey(), String.class));
  data.setKeyspace(keyspace);
  T converted = this.getAdapter().getConverter().read(type, data);

Object id = update.getId();
byte[] redisKey = createKey(keyspace, converter.getConversionService().convert(id, String.class));
            && !converter.getConversionService().canConvert(pUpdate.getValue().getClass(), byte[].class))) {
      redisUpdateObject = fetchDeletePathsFromHashAndUpdateIndex(redisUpdateObject, propertyPath, connection);
      connection.zRem(index.key, toBytes(redisUpdateObject.targetId));
    } else {
      connection.sRem(index.key, toBytes(redisUpdateObject.targetId));
  new IndexWriter(connection, converter).updateIndexes(toBytes(id), rdo.getIndexedData());
  return null;
});

private RedisUpdateObject fetchDeletePathsFromHashAndUpdateIndex(RedisUpdateObject redisUpdateObject, String path,
    RedisConnection connection) {
  redisUpdateObject.addFieldToRemove(toBytes(path));
  byte[] value = connection.hGet(redisUpdateObject.targetKey, toBytes(path));
    byte[] existingValueIndexKey = ByteUtils.concatAll(toBytes(redisUpdateObject.keyspace), toBytes(":" + path),
        toBytes(":"), value);
    if (asString(field).startsWith(path + ".")) {
      value = connection.hGet(redisUpdateObject.targetKey, toBytes(field));
        byte[] existingValueIndexKey = ByteUtils.concatAll(toBytes(redisUpdateObject.keyspace), toBytes(":"), field,
            toBytes(":"), value);
  byte[] existingGeoIndexKey = ByteUtils.concatAll(toBytes(redisUpdateObject.keyspace), toBytes(":"),
      toBytes(pathToUse));
  if (connection.zRank(existingGeoIndexKey, toBytes(redisUpdateObject.targetId)) != null) {
    redisUpdateObject.addIndexToUpdate(new RedisUpdateObject.Index(existingGeoIndexKey, DataType.ZSET));

public List<?> getAllOf(String keyspace, long offset, int rows) {
  byte[] binKeyspace = toBytes(keyspace);
  Set<byte[]> ids = redisOps.execute((RedisCallback<Set<byte[]>>) connection -> connection.sMembers(binKeyspace));
  List<Object> result = new ArrayList<>();
  List<byte[]> keys = new ArrayList<>(ids);
  if (keys.isEmpty() || keys.size() < offset) {
    return Collections.emptyList();
  }
  offset = Math.max(0, offset);
  if (rows > 0) {
    keys = keys.subList((int) offset, Math.min((int) offset + rows, keys.size()));
  }
  for (byte[] key : keys) {
    result.add(get(key, keyspace));
  }
  return result;
}