Intro to JaVers

Intro aux JaVers

1. Vue d'ensemble

Dans cet article, nous examinerons la bibliothèqueJaVers.

Cette bibliothèque aide les programmeurs à examiner et à détecter les modifications d'état des objets Java simples. Lorsque nous utilisons des objets mutables dans notre code, chaque objet peut potentiellement être modifié à divers endroits de l'application; JaVers would help us discover and audit these changes.

2. Dépendance Maven

Pour commencer, ajoutons la dépendance Mavenjavers-core à nospom.xml:


    org.javers
    javers-core
    3.1.0

Nous pouvons trouver la dernière version surMaven Central.

3. Détection des changements d'état POJO

Commençons par une simple classePerson:

public class Person {
    private Integer id;
    private String name;

    // standard getters/constructors
}

Supposons que nous ayons créé un objetPerson dans une partie de notre application, et dans une autre partie de la base de code, le nom du champthe person with the same id a été changé. Nous voulons les comparer pour savoir quel type de changements est arrivé à l'objet personne.

Nous pouvons comparer ces deux objets en utilisant la méthodecompare() de la classeJaVers:

@Test
public void givenPersonObject_whenApplyModificationOnIt_thenShouldDetectChange() {
    // given
    Javers javers = JaversBuilder.javers().build();

    Person person = new Person(1, "Michael Program");
    Person personAfterModification = new Person(1, "Michael Java");

    // when
    Diff diff = javers.compare(person, personAfterModification);

    // then
    ValueChange change = diff.getChangesByType(ValueChange.class).get(0);

    assertThat(diff.getChanges()).hasSize(1);
    assertThat(change.getPropertyName()).isEqualTo("name");
    assertThat(change.getLeft()).isEqualTo("Michael Program");
    assertThat(change.getRight()).isEqualTo("Michael Java");
}

4. Détection du changement d'état de la liste d'objets

Si nous travaillons avec des collections d'objets, nous devons également examiner les changements d'état en examinant chaque élément de la collection. Parfois, nous souhaitons ajouter ou supprimer un objet particulier de la liste, en modifiant son état.

Let’s have a look at an example; disons que nous avons une liste d'objets, et nous supprimons un objet de cette liste.

Ce changement peut être indésirable pour une raison quelconque, et nous souhaitons vérifier les changements survenus dans cette liste. JaVers nous permet de le faire en utilisant une méthodecompareCollections():

@Test
public void givenListOfPersons_whenCompare_ThenShouldDetectChanges() {
    // given
    Javers javers = JaversBuilder.javers().build();
    Person personThatWillBeRemoved = new Person(2, "Thomas Link");
    List oldList =
      Lists.asList(new Person(1, "Michael Program"), personThatWillBeRemoved);
    List newList =
      Lists.asList(new Person(1, "Michael Not Program"));

    // when
    Diff diff = javers.compareCollections(oldList, newList, Person.class);

    // then
    assertThat(diff.getChanges()).hasSize(3);

    ValueChange valueChange =
      diff.getChangesByType(ValueChange.class).get(0);

    assertThat(valueChange.getPropertyName()).isEqualTo("name");
    assertThat(valueChange.getLeft()).isEqualTo("Michael Program");
    assertThat(valueChange.getRight()).isEqualTo("Michael Not Program");

    ObjectRemoved objectRemoved = diff.getChangesByType(ObjectRemoved.class).get(0);
    assertThat(
      objectRemoved.getAffectedObject().get().equals(personThatWillBeRemoved))
      .isTrue();

    ListChange listChange = diff.getChangesByType(ListChange.class).get(0);
    assertThat(listChange.getValueRemovedChanges().size()).isEqualTo(1);
}

5. Comparaison des graphiques d'objets

Dans les applications de mots réels, nous traitons souvent avec les graphes d'objets. Disons que nous avons une classePersonWithAddress qui a une liste des objetsAddress et que nous ajoutons une nouvelle adresse pour la personne donnée.

Nous pouvons facilement trouver le type de changement survenu:

@Test
public void givenListOfPerson_whenPersonHasNewAddress_thenDetectThatChange() {
    // given
    Javers javers = JaversBuilder.javers().build();

    PersonWithAddress person =
      new PersonWithAddress(1, "Tom", Arrays.asList(new Address("England")));

    PersonWithAddress personWithNewAddress =
      new PersonWithAddress(1, "Tom",
        Arrays.asList(new Address("England"), new Address("USA")));


    // when
    Diff diff = javers.compare(person, personWithNewAddress);
    List objectsByChangeType = diff.getObjectsByChangeType(NewObject.class);

    // then
    assertThat(objectsByChangeType).hasSize(1);
    assertThat(objectsByChangeType.get(0).equals(new Address("USA")));
}

De même, la suppression d'une adresse sera détectée:

@Test
public void givenListOfPerson_whenPersonRemovedAddress_thenDetectThatChange() {
    // given
    Javers javers = JaversBuilder.javers().build();

    PersonWithAddress person =
      new PersonWithAddress(1, "Tom", Arrays.asList(new Address("England")));

    PersonWithAddress personWithNewAddress =
      new PersonWithAddress(1, "Tom", Collections.emptyList());


    // when
    Diff diff = javers.compare(person, personWithNewAddress);
    List objectsByChangeType = diff.getObjectsByChangeType(ObjectRemoved.class);

    // then
    assertThat(objectsByChangeType).hasSize(1);
    assertThat(objectsByChangeType.get(0).equals(new Address("England")));
}

6. Conclusion

Dans cet article rapide, nous avons utilisé la bibliothèque JaVers, une bibliothèque utile qui nous fournit des API pour détecter les changements d'état dans nos objets. Non seulement il peut détecter le changement dans un objet POJO simple, mais il peut aussi détecter des changements plus complexes dans les collections d'objets, voire dans les graphiques d'objets.

Comme toujours, le code est disponibleover on GitHub.

TOC