A Repository implementation backed by an in memory Map. Intended to be subclassed for an Entity.

MemoryRepository.java

import org.springframework.data.repository.CrudRepository;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * Created with IntelliJ IDEA<br>
 * User: Xaver Kapeller<br>
 * Date: 29/11/2016
 */
public class MemoryRepository<T, ID extends Serializable> implements CrudRepository<T, ID> {

    private final Map<ID, T> mMap = new HashMap<>();

    private final Supplier<ID> mIdGenerator;
    private final BiConsumer<T, ID> mIdSetter;
    private final Function<T, ID> mIdGetter;

    public MemoryRepository(Supplier<ID> idGenerator, BiConsumer<T, ID> idSetter, Function<T, ID> idGetter) {
        mIdGenerator = idGenerator;
        mIdSetter = idSetter;
        mIdGetter = idGetter;
    }

    @Override
    public <S extends T> S save(S entity) {
        if (mIdGetter.apply(entity) == null) {
            final ID id = mIdGenerator.get();
            mIdSetter.accept(entity, id);
        }

        final ID id = mIdGetter.apply(entity);
        mMap.put(id, entity);
        return entity;
    }

    @Override
    public <S extends T> Iterable<S> save(Iterable<S> entities) {
        entities.forEach(this::save);
        return entities;
    }

    @Override
    public T findOne(ID id) {
        return mMap.get(id);
    }

    @Override
    public boolean exists(ID id) {
        return mMap.containsKey(id);
    }

    @Override
    public Iterable<T> findAll() {
        return mMap.values();
    }

    @Override
    public Iterable<T> findAll(Iterable<ID> ids) {
        final List<ID> idList = new ArrayList<>();
        ids.forEach(idList::add);
        return mMap.values().stream()
                .filter(item -> idList.contains(mIdGetter.apply(item)))
                .collect(Collectors.toList());
    }

    @Override
    public long count() {
        return mMap.size();
    }

    @Override
    public void delete(ID id) {
        mMap.remove(id);
    }

    @Override
    public void delete(T entity) {
        final ID id = mIdGetter.apply(entity);
        delete(id);
    }

    @Override
    public void delete(Iterable<? extends T> entities) {
        entities.forEach(this::delete);
    }

    @Override
    public void deleteAll() {
        mMap.clear();
    }
}