Field Detail

• logger

  public static final org.slf4j.Logger logger

Constructor Detail

• JaversBuilder

  protected JaversBuilder()

  use static factory method javers()

Method Detail

• javers

  public static JaversBuilder javers()

• build

  public Javers build()

• assembleJaversInstance

  protected Javers assembleJaversInstance()

• registerJaversRepository

  public JaversBuilder registerJaversRepository​(JaversRepository repository)

  See Also:

  http://javers.org/documentation/repository-configuration

• registerEntity

  public JaversBuilder registerEntity​(java.lang.Class<?> entityClass)

  Registers an EntityType.
  Use @Id annotation to mark exactly one Id-property.
  
  Optionally, use @Transient or @DiffIgnore annotations to mark ignored properties.
  
  For example, Entities are: Person, Document

  See Also:

  http://javers.org/documentation/domain-configuration/#entity, registerEntity(EntityDefinition)

• registerValueObject

  public JaversBuilder registerValueObject​(java.lang.Class<?> valueObjectClass)

  Registers a ValueObjectType.
  Optionally, use @Transient or @DiffIgnore annotations to mark ignored properties.
  
  For example, ValueObjects are: Address, Point

  See Also:

  http://javers.org/documentation/domain-configuration/#value-object, registerValueObject(ValueObjectDefinition)

• registerEntity

  public JaversBuilder registerEntity​(EntityDefinition entityDefinition)

  Registers an EntityType.
  Use this method if you are not willing to use Entity annotation.
  
  Recommended way to create EntityDefinition is EntityDefinitionBuilder, for example:

   javersBuilder.registerEntity(
       EntityDefinitionBuilder.entityDefinition(Person.class)
       .withIdPropertyName("id")
       .withTypeName("Person")
       .withIgnoredProperties("notImportantProperty","transientProperty")
       .build());
   

  For simple cases, you can use EntityDefinition constructors, for example:

   javersBuilder.registerEntity( new EntityDefinition(Person.class, "login") );
   

  See Also:

  http://javers.org/documentation/domain-configuration/#entity, EntityDefinitionBuilder.entityDefinition(Class)

• registerType

  public JaversBuilder registerType​(ClientsClassDefinition clientsClassDefinition)

  Generic version of registerEntity(EntityDefinition) and registerValueObject(ValueObjectDefinition)

• registerValueObject

  public JaversBuilder registerValueObject​(ValueObjectDefinition valueObjectDefinition)

  Registers a ValueObjectType.
  Use this method if you are not willing to use ValueObject annotations.
  
  Recommended way to create ValueObjectDefinition is ValueObjectDefinitionBuilder. For example:

   javersBuilder.registerValueObject(ValueObjectDefinitionBuilder.valueObjectDefinition(Address.class)
       .withIgnoredProperties(ignoredProperties)
       .withTypeName(typeName)
       .build();
   

  For simple cases, you can use ValueObjectDefinition constructors, for example:

   javersBuilder.registerValueObject( new ValueObjectDefinition(Address.class, "ignored") );
   

  See Also:

  http://javers.org/documentation/domain-configuration/#value-object, ValueObjectDefinitionBuilder.valueObjectDefinition(Class)

• withPackagesToScan

  public JaversBuilder withPackagesToScan​(java.lang.String packagesToScan)

  Comma separated list of packages.
  Allows you to registerType all your classes with @TypeName annotation in order to use them in all kinds of JQL queries
  (without getting TYPE_NAME_NOT_FOUND exception).

  Parameters:

  packagesToScan - e.g. "my.company.domain.person, my.company.domain.finance"

  Since:

  2.3

• scanTypeName

  public JaversBuilder scanTypeName​(java.lang.Class userType)

  Register your class with @TypeName annotation in order to use it in all kinds of JQL queries.
  
  You can also use withPackagesToScan(String) to scan all your classes.
  
  Technically, this method is the convenient alias for Javers.getTypeMapping(Type)

  Since:

  1.4

• registerValue

  public JaversBuilder registerValue​(java.lang.Class<?> valueClass)

  Registers a simple value type (see ValueType).
  
  For example, values are: BigDecimal, LocalDateTime.
  
  Use this method if you are not willing to use Value annotation.
  
  Values are compared using default Object.equals(Object). If you don't want to use it, registerType a custom value comparator with registerValue(Class, CustomValueComparator).

  See Also:

  http://javers.org/documentation/domain-configuration/#ValueType

• registerValue

  public <T> JaversBuilder registerValue​(java.lang.Class<T> valueClass,
                                         CustomValueComparator<T> customValueComparator)

  Registers a ValueType with a custom comparator to be used instead of default Object.equals(Object).
  
  Given comparator is used when given Value type is:

  • simple property
  • List item
  • Array item
  • Map value

  Since this comparator is not aligned with Object.hashCode(), it is not used when given Value type is:

  • Map key
  • Set item

  For example, BigDecimals are (by default) ValueTypes compared using BigDecimal.equals(Object). If you want to compare them in the smarter way, ignoring trailing zeros:

   javersBuilder.registerValue(BigDecimal.class, (a,b) -> a.compareTo(b) == 0);
   

  Since:

  3.3

  See Also:

  http://javers.org/documentation/domain-configuration/#ValueType

• registerValueWithCustomToString

  public <T> JaversBuilder registerValueWithCustomToString​(java.lang.Class<T> valueClass,
                                                           java.util.function.Function<T,java.lang.String> toString)

  For complex ValueType classes that are used as Entity Id.
  
  Registers a custom toString function that will be used for creating GlobalId for Entities, instead of default ReflectionUtil.reflectiveToString(Object).
  
  For example:

   class Entity {
       @Id Point id
       String data
   }
  
   class Point {
       double x
       double y
  
       String myToString() {
           "("+ (int)x +"," +(int)y + ")"
       }
   }
  
   def "should use custom toString function for complex Id"(){
     given:
       Entity entity = new Entity(
       id: new Point(x: 1/3, y: 4/3))
  
     when: "default reflectiveToString function"
       def javers = JaversBuilder.javers().build()
       GlobalId id = javers.getTypeMapping(Entity).createIdFromInstance(entity)
  
     then:
       id.value() == "com.mypackage.Entity/0.3333333333,1.3333333333"
  
     when: "custom toString function"
       javers = JaversBuilder.javers()
               .registerValueWithCustomToString(Point, {it.myToString()}).build()
       id = javers.getTypeMapping(Entity).createIdFromInstance(entity)
  
     then:
       id.value() == "com.mypackage.Entity/(0,1)"
   }
   

  For ValueType you can register both custom toString function and CustomValueComparator.

  Parameters:

  toString - should return String value of a given object

  Since:

  3.7.6

  See Also:

  ValueType, registerValue(Class, CustomValueComparator)

• registerIgnoredClass

  public JaversBuilder registerIgnoredClass​(java.lang.Class<?> ignoredClass)

  Marks given class as ignored by JaVers.
  
  Use this method if you are not willing to use DiffIgnore annotation.

  See Also:

  DiffIgnore

• registerValueTypeAdapter

  public JaversBuilder registerValueTypeAdapter​(JsonTypeAdapter typeAdapter)

  Registers a ValueType and its custom JSON adapter.
  
  Useful for not trivial ValueTypes when Gson's default representation isn't appropriate

  See Also:

  http://javers.org/documentation/repository-configuration/#json-type-adapters, JsonTypeAdapter

• registerJsonAdvancedTypeAdapter

  public JaversBuilder registerJsonAdvancedTypeAdapter​(JsonAdvancedTypeAdapter adapter)

  INCUBATING
  For complex structures like Multimap

  Since:

  3.1

• registerValueGsonTypeAdapter

  public JaversBuilder registerValueGsonTypeAdapter​(java.lang.Class valueType,
                                                    com.google.gson.TypeAdapter nativeAdapter)

  Registers ValueType and its custom native Gson adapter.
  
  Useful when you already have Gson TypeAdapters implemented.

  See Also:

  TypeAdapter

• withTypeSafeValues

  public JaversBuilder withTypeSafeValues​(boolean typeSafeValues)

  Switch on when you need a type safe serialization for heterogeneous collections like List, List<Object>.
  
  Heterogeneous collections are collections which contains items of different types (or types unknown at compile time).
  
  This approach is generally discouraged, prefer statically typed collections with exactly one type of items like List<String>.

  Parameters:

  typeSafeValues - default false

  See Also:

  JsonConverterBuilder.typeSafeValues(boolean)

• withPrettyPrint

  public JaversBuilder withPrettyPrint​(boolean prettyPrint)

  choose between JSON pretty or concise printing style, i.e. :

  • pretty:

     {
         "value": 5
     }
     

  • concise:

     {"value":5}
     

  Parameters:

  prettyPrint - default true

• registerEntities

  public JaversBuilder registerEntities​(java.lang.Class<?>... entityClasses)

• registerValueObjects

  public JaversBuilder registerValueObjects​(java.lang.Class<?>... valueObjectClasses)

• withMappingStyle

  public JaversBuilder withMappingStyle​(MappingStyle mappingStyle)

  Default style is MappingStyle.FIELD.

  See Also:

  http://javers.org/documentation/domain-configuration/#property-mapping-style

• withCommitIdGenerator

  public JaversBuilder withCommitIdGenerator​(CommitIdGenerator commitIdGenerator)

  • CommitIdGenerator.SYNCHRONIZED_SEQUENCE — for non-distributed applications
  • CommitIdGenerator.RANDOM — for distributed applications

  SYNCHRONIZED_SEQUENCE is used by default.

• withNewObjectsSnapshot

  public JaversBuilder withNewObjectsSnapshot​(boolean newObjectsSnapshot)

  When enabled, Javers.compare(Object oldVersion, Object currentVersion) generates additional 'Snapshots' of new objects (objects added in currentVersion graph).
  For each new object, state of its properties is captured and returned as a Set of PropertyChanges. These Changes have null at the left side and a current property value at the right side.
  
  Disabled by default.

• withObjectAccessHook

  public JaversBuilder withObjectAccessHook​(ObjectAccessHook objectAccessHook)

• registerCustomComparator

  public <T> JaversBuilder registerCustomComparator​(CustomPropertyComparator<T,?> comparator,
                                                    java.lang.Class<T> customType)

  Registers a custom property comparator for a given Custom Type.
  
  Custom comparators are used by diff algorithm to calculate property-to-property diff and also collection-to-collection diff.
  
  Internally, given type is mapped as CustomType.

  Type Parameters:

  T - Custom Type

  See Also:

  CustomType, CustomPropertyComparator

• withListCompareAlgorithm

  public JaversBuilder withListCompareAlgorithm​(ListCompareAlgorithm algorithm)

  Choose between two algorithms for comparing list: ListCompareAlgorithm.SIMPLE or ListCompareAlgorithm.LEVENSHTEIN_DISTANCE.
  
  Generally, we recommend using LEVENSHTEIN_DISTANCE, because it's smarter. However, it can be slow for long lists, so SIMPLE is enabled by default.
  
  Refer to http://javers.org/documentation/diff-configuration/#list-algorithms for description of both algorithms

  Parameters:

  algorithm - ListCompareAlgorithm.SIMPLE is used by default

• withDateTimeProvider

  public JaversBuilder withDateTimeProvider​(DateProvider dateProvider)

  DateProvider providers current util for Commit.getCommitDate().
  By default, now() is used.
  Overriding default dateProvider probably makes sense only in test environment.

• withPrettyPrintDateFormats

  public JaversBuilder withPrettyPrintDateFormats​(JaversCoreProperties.PrettyPrintDateFormats prettyPrintDateFormats)

• withProperties

  public JaversBuilder withProperties​(JaversCoreProperties javersProperties)