How to use

KeyValueOperations

in

org.springframework.data.keyvalue.core

  @Override
  @SuppressWarnings("unchecked")
  public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {

    RedisPersistentEntity<T> entity = (RedisPersistentEntity<T>) operations.getMappingContext()
        .getRequiredPersistentEntity(domainClass);

    return new MappingRedisEntityInformation<>(entity);
  }
}

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

/**
 * @param parameters
 * @param query
 */
@Nullable
@SuppressWarnings({ "unchecked", "rawtypes" })
protected Object doExecute(Object[] parameters, KeyValueQuery<?> query) {
  if (queryMethod.isPageQuery() || queryMethod.isSliceQuery()) {
    Pageable page = (Pageable) parameters[queryMethod.getParameters().getPageableIndex()];
    query.setOffset(page.getOffset());
    query.setRows(page.getPageSize());
    Iterable<?> result = this.keyValueOperations.find(query, queryMethod.getEntityInformation().getJavaType());
    long count = queryMethod.isSliceQuery() ? 0
        : keyValueOperations.count(query, queryMethod.getEntityInformation().getJavaType());
    return new PageImpl(IterableConverter.toList(result), page, count);
  } else if (queryMethod.isCollectionQuery()) {
    return this.keyValueOperations.find(query, queryMethod.getEntityInformation().getJavaType());
  } else if (queryMethod.isQueryForEntity()) {
    Iterable<?> result = this.keyValueOperations.find(query, queryMethod.getEntityInformation().getJavaType());
    return result.iterator().hasNext() ? result.iterator().next() : null;
  }
  throw new UnsupportedOperationException("Query method not supported.");
}

@Override
public Page<T> findAll(Pageable pageable) {
  Assert.notNull(pageable, "Pageable must not be null!");
  if (pageable.isUnpaged()) {
    List<T> result = findAll();
    return new PageImpl<>(result, Pageable.unpaged(), result.size());
  }
  Iterable<T> content = operations.findInRange(pageable.getOffset(), pageable.getPageSize(), pageable.getSort(),
      entityInformation.getJavaType());
  return new PageImpl<>(IterableConverter.toList(content), pageable,
      this.operations.count(entityInformation.getJavaType()));
}

/**
 * Execute a "delete" query, not really a query more of an operation.
 * <p>
 *
 * @param query       The query to run
 * @param queryMethod Used here to find the type of object to match the query
 * @return Collection of deleted objects or the number of deleted objects
 */
private Object executeDeleteQuery(final KeyValueQuery<?> query, final QueryMethod queryMethod) {
  Iterable<?> resultSet = this.keyValueOperations.find(query, queryMethod.getEntityInformation().getJavaType());
  Iterator<?> iterator = resultSet.iterator();
  List<Object> result = new ArrayList<>();
  while (iterator.hasNext()) {
    result.add(this.keyValueOperations.delete(iterator.next()));
  }
  if (queryMethod.isCollectionQuery()) {
    return result;
  } else if (long.class.equals(queryMethod.getReturnedObjectType()) || Long.class
      .equals(queryMethod.getReturnedObjectType())) {
    return result.size();
  } else {
    throw new UnsupportedOperationException(String.format(
        "Illegal returned type: %s. The operation 'deleteBy' accepts only 'long' and 'Collection' as the returned "
            + "object type", queryMethod.getReturnedObjectType()));
  }
}

  @Override
  public void deleteAll() {
    operations.delete(entityInformation.getJavaType());
  }
}

@Override
public <S extends T> S save(S entity) {
  Assert.notNull(entity, "Entity must not be null!");
  if (entityInformation.isNew(entity)) {
    return operations.insert(entity);
  }
  return operations.update(entityInformation.getRequiredId(entity), entity);
}

@Override
public long count() {
  return operations.count(entityInformation.getJavaType());
}

@Override
public Iterable<T> findAll(Sort sort) {
  return operations.findAll(sort, entityInformation.getJavaType());
}

/**
 * <p>
 * Execute a retrieval query. The query engine will return this in an iterator, which may need conversion to a single
 * domain entity or a stream.
 * </P>
 *
 * @param query       The query to run
 * @param queryMethod Holds metadata about the query, is paging etc
 * @return Query result
 */
private Object executeFindQuery(final KeyValueQuery<?> query, final QueryMethod queryMethod) {
  Iterable<?> resultSet = this.keyValueOperations.find(query, queryMethod.getEntityInformation().getJavaType());
  if (!queryMethod.isCollectionQuery() && !queryMethod.isPageQuery() && !queryMethod.isSliceQuery() && !queryMethod
      .isStreamQuery()) {
    // Singleton result
    return resultSet.iterator().hasNext() ? resultSet.iterator().next() : null;
  }
  if (queryMethod.isStreamQuery()) {
    return StreamUtils.createStreamFromIterator(resultSet.iterator());
  }
  return resultSet;
}

@Override
public Optional<T> findById(ID id) {
  return operations.findById(id, entityInformation.getJavaType());
}

/**
 * @param parameters
 * @param query
 */
@Nullable
@SuppressWarnings({ "unchecked", "rawtypes" })
protected Object doExecute(Object[] parameters, KeyValueQuery<?> query) {
  if (queryMethod.isPageQuery() || queryMethod.isSliceQuery()) {
    Pageable page = (Pageable) parameters[queryMethod.getParameters().getPageableIndex()];
    query.setOffset(page.getOffset());
    query.setRows(page.getPageSize());
    Iterable<?> result = this.keyValueOperations.find(query, queryMethod.getEntityInformation().getJavaType());
    long count = queryMethod.isSliceQuery() ? 0
        : keyValueOperations.count(query, queryMethod.getEntityInformation().getJavaType());
    return new PageImpl(IterableConverter.toList(result), page, count);
  } else if (queryMethod.isCollectionQuery()) {
    return this.keyValueOperations.find(query, queryMethod.getEntityInformation().getJavaType());
  } else if (queryMethod.isQueryForEntity()) {
    Iterable<?> result = this.keyValueOperations.find(query, queryMethod.getEntityInformation().getJavaType());
    return result.iterator().hasNext() ? result.iterator().next() : null;
  }
  throw new UnsupportedOperationException("Query method not supported.");
}

@Override
public Page<T> findAll(Pageable pageable) {
  Assert.notNull(pageable, "Pageable must not be null!");
  if (pageable.isUnpaged()) {
    List<T> result = findAll();
    return new PageImpl<>(result, Pageable.unpaged(), result.size());
  }
  Iterable<T> content = operations.findInRange(pageable.getOffset(), pageable.getPageSize(), pageable.getSort(),
      entityInformation.getJavaType());
  return new PageImpl<>(IterableConverter.toList(content), pageable,
      this.operations.count(entityInformation.getJavaType()));
}

  @Override
  public void deleteAll() {
    operations.delete(entityInformation.getJavaType());
  }
}

@Override
public <S extends T> S save(S entity) {
  Assert.notNull(entity, "Entity must not be null!");
  if (entityInformation.isNew(entity)) {
    return operations.insert(entity);
  }
  return operations.update(entityInformation.getRequiredId(entity), entity);
}

@Override
public long count() {
  return operations.count(entityInformation.getJavaType());
}

@Override
public Iterable<T> findAll(Sort sort) {
  return operations.findAll(sort, entityInformation.getJavaType());
}

@Override
public Optional<T> findById(ID id) {
  return operations.findById(id, entityInformation.getJavaType());
}

@Override
protected RepositoryFragments getRepositoryFragments(RepositoryMetadata metadata) {
  RepositoryFragments fragments = RepositoryFragments.empty();
  if (QueryByExampleExecutor.class.isAssignableFrom(metadata.getRepositoryInterface())) {
    RedisMappingContext mappingContext = (RedisMappingContext) this.operations.getMappingContext();
    RedisPersistentEntity<?> persistentEntity = mappingContext.getRequiredPersistentEntity(metadata.getDomainType());
    MappingRedisEntityInformation<?, ?> entityInformation = new MappingRedisEntityInformation<>(persistentEntity);
    fragments = fragments.append(RepositoryFragment.implemented(QueryByExampleExecutor.class,
        getTargetRepositoryViaReflection(QueryByExampleRedisExecutor.class, entityInformation, operations)));
  }
  return fragments;
}

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