Javers~查询存储库的当前状态

Question

public class JaversMemoryRepositoryTest {
    private static final String AUTHOR_NAME = "Luther Lansfeld";
    private static Javers javersRepository;
    GameCharacter sylvia;
    GameCharacter bokay;
    GameCharacter cyrus;
    
    @BeforeEach
    public void setUpJaversRepository() {
        javersRepository = JaversBuilder.javers().build();
        sylvia = GameCharacters.sylvia();
        javersRepository.commit(AUTHOR_NAME, sylvia);
        sylvia.name = "Sylvia the Atomic";
        javersRepository.commit(AUTHOR_NAME, sylvia);
        bokay= GameCharacters.bokay();
        javersRepository.commit(AUTHOR_NAME, bokay);
        cyrus= GameCharacters.cyrus();
        javersRepository.commit(AUTHOR_NAME, cyrus);
    }

    @Test
    public void queryShouldFindLatestVersionOfEachCharacter() {
        JqlQuery entryQuery = QueryBuilder.byClass(GameCharacter.class).build();
        List<Shadow<GameCharacter>> gameCharacterShadowList
            = javersRepository.findShadows(entryQuery);
        assertEquals(3, gameCharacterShadowList.size());
    }
}

JqlQuery entryQuery = QueryBuilder.byClass(GameCharacter.class).withLatestVersion().build();

...除了这不存在。但这是关于我在这里想做什么。

或相反的：

JqlQuery entryQuery = QueryBuilder.byClass(GameCharacter.class).withVersion(1).build();

...它获取每个GameCharacter的最早版本。为此，我已经尝试了withversion(-1)，但显然Javers没有从最后开始计算版本。

import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.*;

import java.util.*;

import org.javers.core.*;
import org.javers.core.metamodel.annotation.Id;
import org.javers.repository.jql.*;
import org.javers.shadow.Shadow;
import org.junit.jupiter.api.*;

public class GetLatestVersionTest {
    private static final String FIRST_STRING = "This string should be in the end result";
    private static final String SECOND_STRING = "This string will get overwritten with a newer version";
    private static final String THIRD_STRING = "This string should also be in the end result";
    private static final String FOURTH_STRING = "This string should be in the end result as well";
    private static final String AUTHOR_NAME = "Test Author";

    @Test
    public void shouldRetrieveOnlyLatestVersionsOfAllObjects() {
        Javers javers = JaversBuilder.javers().build();
        StringContainer firstObject = new StringContainer(FIRST_STRING);
        javers.commit(AUTHOR_NAME, firstObject);
        StringContainer secondObject = new StringContainer(SECOND_STRING);
        javers.commit(AUTHOR_NAME, secondObject);
        StringContainer thirdObject = new StringContainer(THIRD_STRING);
        javers.commit(AUTHOR_NAME, thirdObject);
        secondObject.string = FOURTH_STRING;
        javers.commit(AUTHOR_NAME, secondObject);
        
        //At this point, some logic is needed that will only query the latest version
        JqlQuery entryQuery = QueryBuilder.byClass(StringContainer.class).withVersion(-1).build();
        List<Shadow<StringContainer>> mostRecentShadows = javers.findShadows(entryQuery);
        
        assertEquals(3, mostRecentShadows.size());
        List<String> mostRecentStrings = new ArrayList<>();
        for(Shadow<StringContainer> shadow : mostRecentShadows) {
            mostRecentStrings.add(shadow.get().string);
        }
        assertTrue(mostRecentStrings.contains(FIRST_STRING));
        assertFalse(mostRecentStrings.contains(SECOND_STRING));
        assertTrue(mostRecentStrings.contains(THIRD_STRING));
        assertTrue(mostRecentStrings.contains(FOURTH_STRING));
    }
}

class StringContainer {
    @Id
    public String string;
    
    public StringContainer(String string) {
        this.string = string;
    }
}

这方面的Gradle依赖关系是：

plugins {
    id 'java-library-distribution'
}

repositories {
    jcenter()
}

dependencies {
    // Use JUnit test framework
    testCompile("org.junit.jupiter:junit-jupiter:5.6.0")
    testCompile("org.junit.platform:junit-platform-runner:1.6.0")
    
    //Logging
    compile 'commons-logging:commons-logging:1.2'
    compile 'log4j:log4j:1.2.17'
    compile 'org.slf4j:slf4j-log4j12:1.7.25'
    compile 'commons-logging:commons-logging:1.2'
    
    //JaVers
    compile 'org.javers:javers-core:5.10.0'
    compile 'org.javers:javers-persistence-mongo:5.10.0'
}

Answer 1

我现在编写了一个实用程序类，它利用了阴影按最晚到最早排序的事实，以最小的麻烦解决了这个问题：

    public static List<Shadow<GameCharacter>> getLatestShadowsFrom(
        List<Shadow<GameCharacter>> gameCharacterShadowList
    ) {
        List<Shadow<GameCharacter>> latestGameCharacterShadows
            = new ArrayList<>();
        List<String> registeredGameCharacterShadowIds
            = new ArrayList<>(); 
        for(Shadow<GameCharacter> gameCharacterShadow : gameCharacterShadowList) {
            String gameCharacterId
                = gameCharacterShadow.get()._id;
            if(!registeredGameCharacterShadowIds.contains(gameCharacterId)) {
                registeredGameCharacterShadowIds.add(gameCharacterId);
                latestGameCharacterShadows.add(gameCharacterShadow);
            }
        }
        return latestGameCharacterShadows;
    }

像这样应用：

    @Test
    public void queryShouldFindLatestVersionOfEachCharacter() {
        JqlQuery entryQuery = QueryBuilder.byClass(GameCharacter.class).build();
        List<Shadow<GameCharacter>> allGameCharacterShadows
            = javersRepository.findShadows(entryQuery);
        List<Shadow<GameCharacter>> latestGameCharacterShadows
            = JaversUtilities.getLatestShadowsFrom(allGameCharacterShadows);
        assertEquals(3, latestGameCharacterShadows.size());
    }

但是，这种方法的主要缺点是，由于该函数依赖于GameCharacter的_ID字段，所以我必须为每个具有发散ID变量的对象创建该函数的副本（毕竟，所有具有_ID字段的对象都可以分组在一个抽象类中），因此我认为这并不是最佳的。