JaversBuilder (javers-core 5.1.3 API)

java.lang.Object
- org.javers.core.AbstractContainerBuilder
- - org.javers.core.JaversBuilder

```
public class JaversBuilder
extends AbstractContainerBuilder
```
Creates a JaVers instance based on your domain model metadata and custom configuration.

For example, to build a JaVers instance configured with reasonable defaults:
```
 Javers javers = JaversBuilder.javers().build();
 
```
To build a JaVers instance with Entity type registered:
```
 Javers javers = JaversBuilder.javers()
                              .registerEntity(MyEntity.class)
                              .build();
 
```
See Also:

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

Field Summary

Fields
Modifier and Type Field Description

static org.slf4j.Logger logger

Fields
Modifier and Type	Field	Description
`static org.slf4j.Logger`	`logger`

Constructor Summary

Constructors
Modifier Constructor Description

protected JaversBuilder()
use static factory method javers()

Constructors
Modifier	Constructor	Description
`protected`	`JaversBuilder()`	use static factory method `javers()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected Javers`	`assembleJaversInstance()`
`Javers`	`build()`
`static JaversBuilder`	`javers()`
`<T> JaversBuilder`	`registerCustomComparator(CustomPropertyComparator<T,?> comparator, java.lang.Class<T> customType)`	Registers a custom property comparator for a given Custom Type.
`JaversBuilder`	`registerEntities(java.lang.Class<?>... entityClasses)`
`JaversBuilder`	`registerEntity(java.lang.Class<?> entityClass)`	Registers an `EntityType`.
`JaversBuilder`	`registerEntity(EntityDefinition entityDefinition)`	Registers an `EntityType`.
`JaversBuilder`	`registerIgnoredClass(java.lang.Class<?> ignoredClass)`	Marks given class as ignored by JaVers.
`JaversBuilder`	`registerJaversRepository(JaversRepository repository)`
`JaversBuilder`	`registerJsonAdvancedTypeAdapter(JsonAdvancedTypeAdapter adapter)`	INCUBATING For complex structures like Multimap
`JaversBuilder`	`registerType(ClientsClassDefinition clientsClassDefinition)`	Generic version of `registerEntity(EntityDefinition)` and `registerValueObject(ValueObjectDefinition)`
`JaversBuilder`	`registerValue(java.lang.Class<?> valueClass)`	Registers a simple value type (see `ValueType`).
`<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)`.
`JaversBuilder`	`registerValueGsonTypeAdapter(java.lang.Class valueType, com.google.gson.TypeAdapter nativeAdapter)`	Registers `ValueType` and its custom native Gson adapter.
`JaversBuilder`	`registerValueObject(java.lang.Class<?> valueObjectClass)`	Registers a `ValueObjectType`.
`JaversBuilder`	`registerValueObject(ValueObjectDefinition valueObjectDefinition)`	Registers a `ValueObjectType`.
`JaversBuilder`	`registerValueObjects(java.lang.Class<?>... valueObjectClasses)`
`JaversBuilder`	`registerValueTypeAdapter(JsonTypeAdapter typeAdapter)`	Registers a `ValueType` and its custom JSON adapter.
`<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.
`JaversBuilder`	`scanTypeName(java.lang.Class userType)`	Register your class with @`TypeName` annotation in order to use it in all kinds of JQL queries.
`JaversBuilder`	`withCommitIdGenerator(CommitIdGenerator commitIdGenerator)`	`CommitIdGenerator.SYNCHRONIZED_SEQUENCE` — for non-distributed applications `CommitIdGenerator.RANDOM` — for distributed applications SYNCHRONIZED_SEQUENCE is used by default.
`JaversBuilder`	`withDateTimeProvider(DateProvider dateProvider)`	DateProvider providers current util for `Commit.getCommitDate()`.
`JaversBuilder`	`withListCompareAlgorithm(ListCompareAlgorithm algorithm)`	Choose between two algorithms for comparing list: ListCompareAlgorithm.SIMPLE or ListCompareAlgorithm.LEVENSHTEIN_DISTANCE.
`JaversBuilder`	`withMappingStyle(MappingStyle mappingStyle)`	Default style is `MappingStyle.FIELD`.
`JaversBuilder`	`withNewObjectsSnapshot(boolean newObjectsSnapshot)`	When enabled, `Javers.compare(Object oldVersion, Object currentVersion)` generates additional 'Snapshots' of new objects (objects added in currentVersion graph).
`JaversBuilder`	`withObjectAccessHook(ObjectAccessHook objectAccessHook)`
`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).
`JaversBuilder`	`withPrettyPrint(boolean prettyPrint)`	choose between JSON pretty or concise printing style, i.e.
`JaversBuilder`	`withPrettyPrintDateFormats(JaversCoreProperties.PrettyPrintDateFormats prettyPrintDateFormats)`
`JaversBuilder`	`withProperties(JaversCoreProperties javersProperties)`
`JaversBuilder`	`withTypeSafeValues(boolean typeSafeValues)`	Switch on when you need a type safe serialization for heterogeneous collections like List, List<Object>.

Methods inherited from class org.javers.core.AbstractContainerBuilder
addComponent, addModule, addModule, bindComponent, bootContainer, getComponents, getContainer, getContainerComponent, removeComponent

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 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)
```

Class JaversBuilder

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.javers.core.AbstractContainerBuilder

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

JaversBuilder

Method Detail

javers

build

assembleJaversInstance

registerJaversRepository

registerEntity

registerValueObject

registerEntity

registerType

registerValueObject

withPackagesToScan

scanTypeName

registerValue

registerValue

registerValueWithCustomToString

registerIgnoredClass

registerValueTypeAdapter

registerJsonAdvancedTypeAdapter

registerValueGsonTypeAdapter

withTypeSafeValues

withPrettyPrint

registerEntities

registerValueObjects

withMappingStyle

withCommitIdGenerator

withNewObjectsSnapshot

withObjectAccessHook

registerCustomComparator

withListCompareAlgorithm

withDateTimeProvider

withPrettyPrintDateFormats

withProperties