Dozer

https://dozermapper.github.io
Admin
Dozer is a Java Bean to Java Bean mapper that recursively copies data from one object to another.
Tokens:33,846
Snippets:463
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Java Assembler Class Example with Dozer

Source: https://dozermapper.github.io/gitbook/documentation/faq.html

Demonstrates an Assembler implementation using Dozer for data mapping between source and destination objects. Encapsulates mapping logic for reusability and testability.

```java
public class SomeAssemblerImpl implements SomeAssembler {

  private Mapper dozerMapper;

  public DestObject assembleDestObject(SrcObject src) {
    return dozerMapper.map(src, DestObject.class);
  }

}
```

--------------------------------

### Deep Indexed Mapping with Hints

Source: https://dozermapper.github.io/gitbook/documentation/deepmapping.html

Provides an example of using deep index hints for mapping when the collection type is not an Array or when not using Java 1.5 Generics. This helps Dozer determine the types of destination objects to create.

```xml
<field>
    <a>someField</a>
    <b>someList[1].someOtherList[0].someOtherField</b>
    <b-deep-index-hint>
        com.github.dozermapper.core.vo.TestObject, com.github.dozermapper.core.vo.AnotherTestObject
    </b-deep-index-hint>
</field>
```

--------------------------------

### Mapping to Custom Map with Custom Get/Set Methods

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Sets up a mapping to a custom map object (CustomMap), defining 'putValue' as the set method and 'getValue' as the get method. Includes custom field key and exclusion.

```xml
<mapping map-id="myCustomTestMapping">
    <class-a>com.github.dozermapper.core.vo.map.PropertyToMap</class-a>
    <class-b map-set-method="putValue" map-get-method="getValue">
      com.github.dozermapper.core.vo.map.CustomMap
  </class-b>
    <field>
        <a set-method="addStringProperty2">stringProperty2</a>
        <b key="myStringProperty">this</b>
    </field>
    <field-exclude>
        <a>excludeMe</a>
        <b>this</b>
    </field-exclude>
</mapping>
```

--------------------------------

### Complete Dozer Mapping XML Configuration

Source: https://dozermapper.github.io/gitbook/documentation/gettingstarted.html

This is a complete example of a Dozer mapping XML file, including configuration options like date format and wildcard usage, along with a custom field mapping.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns="http://dozermapper.github.io/schema/bean-mapping"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://dozermapper.github.io/schema/bean-mapping http://dozermapper.github.io/schema/bean-mapping.xsd">
    <configuration>
        <stop-on-errors>true</stop-on-errors>
        <date-format>MM/dd/yyyy HH:mm</date-format>
        <wildcard>true</wildcard>
    </configuration>
    <mapping>
        <class-a>yourpackage.yourSourceClassName</class-a>
        <class-b>yourpackage.yourDestinationClassName</class-b>
        <field>
            <A>yourSourceFieldName</A>
            <B>yourDestinationFieldName</B>
        </field>
    </mapping>
</mappings>
```

--------------------------------

### Deep Indexed Mapping Example

Source: https://dozermapper.github.io/gitbook/documentation/deepmapping.html

Illustrates how to map properties within nested collections using index notation. This is useful for accessing specific elements in arrays or lists.

```xml
<field>
    <a>offSpringName</a>
    <b>pets[1].offSpring[2].petName</b>
</field>
```

--------------------------------

### Java Configuration for Dozer Bean Mapper

Source: https://dozermapper.github.io/gitbook/documentation/springintegration.html

Define the Dozer mapper bean using Java configuration. This example shows how to set mapping files using Spring's ResourcePatternResolver.

```java
@Configuration
public class DozerConfig {
    @Bean
    public DozerBeanMapperFactoryBean dozerMapper(
        ResourcePatternResolver resourcePatternResolver) throws IOException {
        DozerBeanMapperFactoryBean factoryBean = new DozerBeanMapperFactoryBean();
        factoryBean.setMappingFiles(
            resourcePatternResolver.getResources("classpath*:/*mapping.xml"));
        // ...
        return factoryBean;
    }
}
```

--------------------------------

### New DozerConverter API Example

Source: https://dozermapper.github.io/gitbook/documentation/customconverter.html

Utilize the new DozerConverter API for a cleaner and more intuitive way to define custom converters. This version supports Java 5 Generics, eliminating the need for manual casting.

```java
import com.github.dozermapper.core.DozerConverter;

public class NewDozerConverter extends DozerConverter<String, Boolean> {

    public NewDozerConverter() {
        super(String.class, Boolean.class);
    }

    @Override
    public Boolean convertTo(String source, Boolean destination) {
        if ("yes".equals(source)) {
            return Boolean.TRUE;
        } else if ("no".equals(source)) {
            return Boolean.FALSE;
        }
        throw new IllegalStateException("Unknown value!");
    }

    @Override
    public String convertFrom(Boolean source, String destination) {
        if (Boolean.TRUE.equals(source)) {
            return "yes";
        } else if (Boolean.FALSE.equals(source)) {
            return "no";
        }
        throw new IllegalStateException("Unknown value!");
    }
}
```

--------------------------------

### Redundant Field Mapping in Subclasses

Source: https://dozermapper.github.io/gitbook/documentation/baseattributes.html

Avoid repeating base class field mappings in each subclass. This example shows the verbose approach.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.SubClass</class-a>
    <class-b>com.github.dozermapper.core.vo.SubClassPrime</class-b>
    <field>
        <!-- this is the same for all sub classes -->
        <a>superAttribute</a>
        <b>superAttr</b>
    </field>
    <field>
        <a>attribute2</a>
        <b>attributePrime2</b>
    </field>
</mapping>
<mapping>
    <class-a>com.github.dozermapper.core.vo.SubClass2</class-a>
    <class-b>com.github.dozermapper.core.vo.SubClassPrime2</class-b>
    <field>
        <!-- this is the same for all sub classes -->
        <a>superAttribute</a>
        <b>superAttr</b>
    </field>
    <field>
        <a>attribute2</a>
        <b>attributePrime2</b>
    </field>
</mapping>
```

--------------------------------

### Get MappingMetadata Instance

Source: https://dozermapper.github.io/gitbook/documentation/metadata.html

Retrieves an instance of `MappingMetadata` from a `Mapper` object. This instance is the entry point for querying mapping definitions.

```java
MappingMetadata mapMetadata = mapper.getMappingMetadata();
```

--------------------------------

### Custom Set() and Get() Methods (Bi-directional)

Source: https://dozermapper.github.io/gitbook/documentation/custommethods.html

Specify custom setter and getter methods using `set-method` and `get-method` attributes for bi-directional mapping when beans have unorthodox methods.

```xml
<field>
    <a set-method="placeValue" get-method="buildValue">value</a>
    <b>value</b>
</field>
```

--------------------------------

### Global Default Date Format in Mappings

Source: https://dozermapper.github.io/gitbook/documentation/stringtodatemapping.html

Define a global default date format within the top-level mappings configuration. This format applies to all mappings unless overridden at a lower level. The example sets a default format for all date conversions within the entire mapping configuration.

```xml
<mappings>
    <configuration>
        <date-format>MM/dd/yyyy HH:mm</date-format>
    </configuration>
    <mapping wildcard="true">
        <class-a>com.github.dozermapper.core.vo.TestObject</class-a>
        <class-b>com.github.dozermapper.core.vo.TestObjectPrime</class-b>
        <field>
            <a>dateString</a>
            <b>dateObject</b>
        </field>
    </mapping>
    <mapping>
        <class-a>com.github.dozermapper.core.vo.SomeObject</class-a>
        <class-b>com.github.dozermapper.core.vo.SomeOtherObject</class-b>
        <field>
            <a>srcField</a>
            <b>destField</b>
        </field>
    </mapping>
</mappings>
```

--------------------------------

### Mapping Object to java.util.Map using Map-ID

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Example of mapping a PropertyToMap object to a HashMap using the 'myTestMapping' map-id. The destination type is specified as HashMap.class.

```java
// Example 1
PropertyToMap ptm = new PropertyToMap();
ptm.setStringProperty("stringPropertyValue");
ptm.addStringProperty2("stringProperty2Value");
Map map = Mapper.map(ptm, HashMap.class, "myTestMapping");
```

--------------------------------

### Sample CustomConverter Implementation in Java

Source: https://dozermapper.github.io/gitbook/documentation/customconverter.html

Provides a basic implementation of the `CustomConverter` interface. It demonstrates handling null source values and performing type conversion between `Double` and `CustomDoubleObject`.

```java
import com.github.dozermapper.core.CustomConverter;
import com.github.dozermapper.core.MappingException;

public class TestCustomConverter implements CustomConverter {

    @Override
    public Object convert(Object existingDestinationFieldValue, Object sourceFieldValue, Class<?> destinationClass, Class<?> sourceClass) {
        if (sourceFieldValue == null) {
            return null;
        }

        CustomDoubleObject dest;
        if (source instanceof Double) {
            // check to see if the object already exists
            if (destination == null) {
                dest = new CustomDoubleObject();
            } else {
                dest = (CustomDoubleObject)destination;
            }

            dest.setTheDouble(((Double)source).doubleValue());

            return dest;
        }
        // Handle other types or throw an exception if conversion is not supported
        throw new MappingException("Conversion not supported for source type: " + source.getClass().getName());
    }
}
```

--------------------------------

### View Dozer Initialization Information

Source: https://dozermapper.github.io/gitbook/documentation/faq.html

Enable debug mode using the -Ddozer.debug system property to view one-time initialization details of the Dozer mapper.

```bash
dozer: Trying to find Dozer configuration file: dozer.properties
dozer: Using URL [file:/local/subversion_projects/dozer/trunk/target/test-classes/dozer.properties] for Dozerglobal property configuration
dozer: Reading Dozer properties from URL[file:/local/subversion_projects/dozer/trunk/target/test-classes/dozer.properties]
dozer: Finished configuring Dozer global properties
dozer: Initializing Dozer. Version: ${project.version}, Thread Name:main
dozer: Initializing a new instance of the dozer bean mapper.
dozer: Using the following xml files to load custom mappings for the bean mapper instance:[fieldAttributeMapping.xml]
dozer: Trying to find xml mapping file: fieldAttributeMapping.xml
dozer: Using URL [file:/local/subversion_projects/dozer/trunk/target/test-classes/fieldAttributeMapping.xml]to load custom xml mappings
dozer: Successfully loaded custom xml mappings from URL:[file:/local/subversion_projects/dozer/trunk/target/test-classes/fieldAttributeMapping.xml]
```

--------------------------------

### Using Map-Backed Mappings in Dozer Configuration

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Demonstrates how to reference map-ids ('myTestMapping', 'myCustomTestMapping') within a Dozer mapping configuration to apply specific map-backed property mappings.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.map.MapTestObject</class-a>
    <class-b>com.github.dozermapper.core.vo.map.MapTestObjectPrime</class-b>
    <field map-id="myTestMapping">
        <a>propertyToMap</a>
        <b>propertyToMapMap</b>
    </field>
    <field map-id="myTestMapping">
        <a>propertyToMapToNullMap</a>
        <b>nullPropertyToMapMap</b>
        <b-hint>java.util.HashMap</b-hint>
    </field>
    <field map-id="myCustomTestMapping">
        <a>propertyToCustomMap</a>
        <b>propertyToCustomMapMap</b>
    </field>
</mapping>
```

--------------------------------

### Build Mapper with Mapping Files

Source: https://dozermapper.github.io/gitbook/documentation/metadata.html

Builds a Dozer Mapper instance and loads mapping definitions from specified XML files. Ensure the mapping files are correctly formatted and accessible.

```java
Mapper mapper = DozerBeanMapperBuilder.create()
        .withMappingFiles(listOfFiles)
        .build();
```

--------------------------------

### Populating Custom Map with Specific Method

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Shows how to manually populate a CustomMap using its custom 'putValue' method before mapping it to another object.

```java
// Example 3
CustomMap custom = new CustomMap();
custom.putValue("myKey", "myValue");
Mapper.map(ptm, custom, "myCustomTestMapping");
```

--------------------------------

### Browse Dozer Source Repository

Source: https://dozermapper.github.io/community/source-repository.html

Access the browsable version of the Dozer source repository via a web browser.

```text
https://github.com/DozerMapper/Dozer/dozer-plugins-parent/dozer-site
```

--------------------------------

### Configure Dozer Mapping Files (application.properties)

Source: https://dozermapper.github.io/gitbook/documentation/springBootIntegration.html

Specify custom Dozer mapping files using the `dozer.mapping-files` property in your application.properties file. The `classpath*:/*mapping.xml` pattern loads all XML mapping files from the classpath.

```properties
dozer.mapping-files=classpath*:/*mapping.xml
```

--------------------------------

### Enable Copy By Reference Globally for a Class

Source: https://dozermapper.github.io/gitbook/documentation/copybyreference.html

Configure Dozer to copy all instances of a specific class by reference. This is done within the <configuration> block by listing the fully qualified class name.

```xml
<configuration>
    <copy-by-references>
        <copy-by-reference>
       com.github.dozermapper.core.vo.NoExtendBaseObjectGlobalCopyByReference
     </copy-by-reference>
    </copy-by-references>
</configuration>
```

--------------------------------

### Class Mapping Level Default Date Format

Source: https://dozermapper.github.io/gitbook/documentation/stringtodatemapping.html

Set a default date format for all fields within a specific class mapping. This format can be overridden at the field level. The example shows a default format for mapping between TestObject and TestObjectPrime.

```xml
<mapping date-format="MM-dd-yyyy HH:mm:ss">
    <class-a>com.github.dozermapper.core.vo.TestObject</class-a>
    <class-b>com.github.dozermapper.core.vo.TestObjectPrime</class-b>
    <field>
        <a>dateString</a>
        <b>dateObject</b>
    </field>
</mapping>
```

--------------------------------

### Class Level Custom Create Method

Source: https://dozermapper.github.io/gitbook/documentation/customCreateMethod.html

Configure a custom static create method for all fields within a class.

```xml
<mapping>
    <class-a create-method="someCreateMethod">
    com.github.dozermapper.core.vo.InsideTestObject
  </class-a>
    <class-b>com.github.dozermapper.core.vo.InsideTestObjectPrime</class-b>
    <field>
        <a>label</a>
        <b>labelPrime</b>
    </field>
</mapping>
```

--------------------------------

### New XML Mapping Package

Source: https://dozermapper.github.io/gitbook/migration/v62-to-v63.html

Use 'com.github.dozermapper.core.builder.xml' for XML mapping in favor of the deprecated package.

```java
com.github.dozermapper.core.builder.xml
```

--------------------------------

### Add EL Dependencies

Source: https://dozermapper.github.io/gitbook/documentation/expressionlanguage.html

Include these Maven dependencies to enable EL support in your project. Ensure you have both the API and an implementation like Glassfish's.

```xml
<dependency>
    <groupId>javax.el</groupId>
    <artifactId>javax.el-api</artifactId>
    <version>3.0.0</version>
</dependency>
<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>javax.el</artifactId>
    <version>3.0.0</version>
</dependency>
```

--------------------------------

### Collection Mapping with Subclass Hints

Source: https://dozermapper.github.io/gitbook/documentation/baseattributes.html

Provides hints for collection mappings with different subtypes of the same parent type. Use 'a-hint' and 'b-hint' to specify potential subclasses.

```xml
<field>
    <a>aList</a>
    <b>bList</b>
    <a-hint>B1,B2</a-hint>
    <b-hint>BPrime1,BPrime2</b-hint>
</field>
```

--------------------------------

### Enable Copy By Reference with Wildcards

Source: https://dozermapper.github.io/gitbook/documentation/copybyreference.html

Use wildcard expressions within the <copy-by-reference> configuration to apply the setting to multiple classes matching a pattern. Supports single and multiple asterisks.

```xml
<configuration>
    <copy-by-references>
        <copy-by-reference>
       com.github.dozermapper.core.vo.*
     </copy-by-reference>
        <copy-by-reference>
       com.github.dozermapper.core.*.vo.*DTO
     </copy-by-reference>
    </copy-by-references>
</configuration>
```

--------------------------------

### Configure Dozer Mapping Files (application.yml)

Source: https://dozermapper.github.io/gitbook/documentation/springBootIntegration.html

Configure custom Dozer mapping files using the `dozer.mapping-files` property in your application.yml file. The `classpath*:/*mapping.xml` pattern loads all XML mapping files from the classpath.

```yaml
dozer:
  mapping-files: classpath*:/*mapping.xml
```

--------------------------------

### Build Dozer Mapper with Mapping Builders

Source: https://dozermapper.github.io/gitbook/documentation/apimappings.html

Construct a Dozer mapper instance by chaining mapping builders using `DozerBeanMapperBuilder.create().withMappingBuilder(builder).build()`. Multiple builders can be added to the configuration.

```java
Mapper mapper = DozerBeanMapperBuilder.create()
        .withMappingBuilder(builder)
        .build();
```

--------------------------------

### Map java.util.Map to java.util.Map with Hints

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Configure Dozer to map a java.util.Map to another java.util.Map. Supports deep recursion for complex types using hints.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.map.MapToMap</class-a>
    <class-b>com.github.dozermapper.core.vo.map.MapToMapPrime</class-b>
    <field>
        <a>standardMapWithHint</a>
        <b>standardMapWithHint</b>
        <a-hint>com.github.dozermapper.core.vo.TestObject</a-hint>
        <b-hint>com.github.dozermapper.core.vo.TestObjectPrime</b-hint>
    </field>
</mapping>
```

--------------------------------

### Iterate Method Mapping on Both Fields

Source: https://dozermapper.github.io/gitbook/documentation/custommethods.html

Configure iterate method mapping on both source and destination fields. Both fields require `type="iterate"` and a corresponding hint for the object type.

```xml
<field>
    <a set-method="addCar" get-method="myIterateCars" type="iterate">iterateCars</a>
    <b set-method="addIterateCar" type="iterate">iterateCars</b>
    <a-hint>com.github.dozermapper.core.vo.Car</a-hint>
    <b-hint>com.github.dozermapper.core.vo.Car</b-hint>
</field>
```

--------------------------------

### Map Source to Class

Source: https://dozermapper.github.io/gitbook/documentation/advancedproperty.html

Use this when mapping a single source object to a new instance of a target class.

```java
mapper.map(sourceA, ClassB.class);
```

--------------------------------

### Custom Create Method with Fully Qualified Name

Source: https://dozermapper.github.io/gitbook/documentation/customCreateMethod.html

Reference a static factory method from a different class using its fully qualified name.

```xml
<b create-method="com.github.dozermapper.core.factory.Factory.create">field</b>
```

--------------------------------

### ConfigurableCustomConverter Implementation

Source: https://dozermapper.github.io/gitbook/documentation/customconverter.html

Implement the ConfigurableCustomConverter interface to create custom converters that accept configuration parameters at runtime. The 'setParameter' method receives the parameter value.

```java
import com.github.dozermapper.core.ConfigurableCustomConverter;
import com.github.dozermapper.core.MappingException;

public class MathOperationConverter implements ConfigurableCustomConverter {

    private String parameter;

    @Override
    public void setParameter(String parameter) {
        this.parameter = parameter;
    }

    @Override
    public Object convert(Object existingDestinationFieldValue, Object sourceFieldValue, Class<?> destinationClass, Class<?> sourceClass) {
        Integer source = (Integer)sourceFieldValue;
        Integer destination = (Integer)existingDestinationFieldValue;

        if ("+".equals(parameter)) {
            return destination.intValue + source.intValue();
        }

        if ("-".equals(parameter)) {
            return destination.intValue - source.intValue();
        }

        throw new MappingException("Converter MathOperationConverter "
                                   + "used incorrectly. Arguments passed in were:"
                                   + destination
                                   + ", "
                                   + source
                                   + " and "
                                   + parameter);
    }
}
```

--------------------------------

### Basic Object Mapping with Dozer

Source: https://dozermapper.github.io/gitbook/documentation/usage.html

Demonstrates the fundamental usage of the Dozer Bean Mapper to map properties from a source object to a destination object. The mapper can either create a new destination object or map into an existing one.

```java
Mapper mapper = DozerBeanMapperBuilder.buildDefault();
DestinationObject destObject = mapper.map(sourceObject, DestinationObject.class);
```

```java
DestinationObject destObject = new DestinationObject();
mapper.map(sourceObject, destObject);
```

--------------------------------

### Global Configuration Settings

Source: https://dozermapper.github.io/gitbook/documentation/xmlConfiguration.html

Define global default settings and custom converters. This block is optional and can be defined in each mapping file, with mappings inheriting configuration from their respective files.

```xml
<configuration>
    <date-format>MM/dd/yyyy HH:mm</date-format>
    <stop-on-errors>true</stop-on-errors>
    <wildcard>true</wildcard>
    <custom-converters>
        <!-- these are always bi-directional -->
        <converter type="com.github.dozermapper.core.converters.TestCustomConverter">
            <class-a>com.github.dozermapper.core.vo.TestCustomConverterObject</class-a>
            <class-b>another.type.to.Associate</class-b>
        </converter>
    </custom-converters>
</configuration>
```

--------------------------------

### Add dozer-spring-boot-starter for Spring Boot support

Source: https://dozermapper.github.io/gitbook/migration/v61-to-v62.html

For Spring Boot auto-configuration, add the 'dozer-spring-boot-starter' dependency to your Maven project.

```xml
<dependency>
    <groupId>com.github.dozermapper</groupId>
    <artifactId>dozer-spring-boot-starter</artifactId>
    <version>6.2.0</version>
</dependency>
```

--------------------------------

### Add Dozer Spring Boot Starter Dependency

Source: https://dozermapper.github.io/gitbook/documentation/springBootIntegration.html

Include this Maven dependency to enable Dozer Spring Boot integration. Replace {dozer-version} with the desired Dozer version.

```xml
<dependency>
    <groupId>com.github.dozermapper</groupId>
    <artifactId>dozer-spring-boot-starter</artifactId>
    <version>{dozer-version}</version>
</dependency>
```

--------------------------------

### XML Configuration with Dozer Namespace

Source: https://dozermapper.github.io/gitbook/documentation/springintegration.html

An alternative XML configuration using the Dozer namespace for defining the mapper bean.

```xml
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dozer="http://dozermapper.github.io/schema/dozer-spring"
       xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://dozermapper.github.io/schema/dozer-spring
         https://dozermapper.github.io/schema/dozer-spring.xsd">

    <dozer:mapper id="dozerMapper"/>

</beans>
```

--------------------------------

### Assemble Objects into Existing Instance

Source: https://dozermapper.github.io/gitbook/documentation/advancedproperty.html

Call the mapper multiple times to populate an existing destination object with data from various sources, effectively assembling a coarse-grained object.

```java
ClassD d = new ClassD();
mapper.map(sourceA, d);
mapper.map(sourceB, d);
mapper.map(sourceC, d);
```

--------------------------------

### Mapping Object to Custom Map using Map-ID

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Demonstrates mapping a PropertyToMap object to a CustomMap instance using the 'myCustomTestMapping' map-id.

```java
// Example 2
CustomMap customMap = mapper.map(ptm, CustomMap.class, "myCustomTestMapping");
```

--------------------------------

### Iterate Method Mapping (Bi-directional)

Source: https://dozermapper.github.io/gitbook/documentation/custommethods.html

Use `type="iterate"` to map collections by calling a specified method on each object. A hint is required to specify the object type within the collection.

```xml
<field>
    <a>appleComputers</a>
    <b set-method="addComputer" type="iterate">computers</b>
    <b-hint>com.github.dozermapper.core.vo.AppleComputer</b-hint>
</field>
```

--------------------------------

### Deep Property Mapping Configuration

Source: https://dozermapper.github.io/gitbook/documentation/deepmapping.html

Configure deep property mappings between source and destination objects, including type hints for collections. Supports copy-by-reference and relationship types.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.deep.SrcDeepObj</class-a>
    <class-b>com.github.dozermapper.core.vo.deep.DestDeepObj</class-b>
    <field>
        <a>srcNestedObj.src1</a>
        <b>dest1</b>
    </field>
    <field>
        <a>srcNestedObj.src2</a>
        <b>dest2</b>
    </field>
    <field>
        <a>srcNestedObj.srcNestedObj2.src5</a>
        <b>dest5</b>
    </field>
    <field>
        <!-- java.util.List to java.util.List -->
        <a>srcNestedObj.hintList</a>
        <b>hintList</b>
        <a-hint>java.lang.String</a-hint>
        <b-hint>java.lang.Integer</b-hint>
    </field>
    <field>
        <a>srcNestedObj.hintList2</a>
        <b>hintList2</b>
        <a-hint>com.github.dozermapper.core.vo.TheFirstSubClass</a-hint>
        <b-hint>com.github.dozermapper.core.vo.TheFirstSubClassPrime</b-hint>
    </field>
    <field copy-by-reference="true">
        <a>srcNestedObj.hintList3</a>
        <b>hintList3</b>
    </field>
</mapping>
```

--------------------------------

### Injecting Custom Mapping Files Programmatically

Source: https://dozermapper.github.io/gitbook/documentation/usage.html

Shows how to configure the Dozer Bean Mapper with custom XML mapping files programmatically. This approach is not recommended for production due to initialization overhead; consider using a singleton pattern if necessary.

```java
Mapper mapper = DozerBeanMapperBuilder.create()
        .withMappingFiles("dozerBeanMapping.xml", "someOtherDozerBeanMappings.xml")
        .build();

DestinationObject destObject = mapper.map(sourceObject, DestinationObject.class);
```

--------------------------------

### Map Back: Mapping from Map to Object using Map-ID

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Illustrates mapping a HashMap back to a PropertyToMap object, utilizing the 'myTestMapping' map-id. Asserts the mapped property value.

```java
// Example 4 - Map Back
Map map = new HashMap();
map.put("stringProperty", "stringPropertyValue");
PropertyToMap property = mapper.map(map, PropertyToMap.class, "myTestMapping");
assertEquals("stringPropertyValue", property.getStringProperty());
```

--------------------------------

### Specify Collection Element Type with Hint

Source: https://dozermapper.github.io/gitbook/documentation/faq.html

Use a hint to specify the desired data object type for destination collections when not using JDK 1.5 Generics. If no hint is provided, the destination collection will be populated with objects of the same type as the source collection elements.

```xml
<field>
    <a>someList</a>
    <b>otherList</b>
    <b-hint>com.github.dozermapper.core.vo.TheFirstSubClassPrime</b-hint>
</field>
```

--------------------------------

### Individual Class Level Configuration

Source: https://dozermapper.github.io/gitbook/documentation/xmlConfiguration.html

Apply a setting to only one of the two classes by placing the attribute within the `class-a` or `class-b` tag.

```xml
<mapping>
    <class-a is-accessible="true">com.github.dozermapper.core.vo.SpringBean</class-a>
    <class-b>com.github.dozermapper.core.vo.SpringBeanPrime</class-b>
    <field>
        <a>anAttributeToMap</a>
        <b>anAttributeToMapPrime</b>
    </field>
</mapping>
```

--------------------------------

### Individual Field Level Configuration

Source: https://dozermapper.github.io/gitbook/documentation/xmlConfiguration.html

Apply settings to a single field by specifying attributes within the field's `<a>` or `<b>` tags, such as defining a custom getter method.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.SpringBean</class-a>
    <class-b>com.github.dozermapper.core.vo.SpringBeanPrime</class-b>
    <field>
        <a get-method="getTheAttribute">anAttributeToMap</a>
        <b>anAttributeToMapPrime</b>
    </field>
</mapping>
```

--------------------------------

### Perform First Dozer Mapping

Source: https://dozermapper.github.io/gitbook/documentation/gettingstarted.html

Use this code to map a source object to a destination object when field names are identical. Dozer handles type conversions automatically.

```java
Mapper mapper = DozerBeanMapperBuilder.buildDefault();
DestinationObject destObject = mapper.map(sourceObject, DestinationObject.class);
```

--------------------------------

### Invoke Mapper with Specific Context

Source: https://dozermapper.github.io/gitbook/documentation/contextmapping.html

Java code demonstrating how to invoke the Dozer mapper using a specific 'map-id' to apply a particular context-based mapping configuration.

```java
ContextMappingPrime cmpA = mapper.map(cm, ContextMappingPrime.class, "caseA");
```

--------------------------------

### Programmatic Mapping Configuration

Source: https://dozermapper.github.io/gitbook/documentation/apiConfiguration.html

Use MapperBuilder and BeanMappingBuilder to define mappings, class configurations, and field settings programmatically. This approach is useful for dynamic mapping definitions.

```java
Mapper mapper = DozerBeanMapperBuilder.create()
                .withMappingBuilder(new BeanMappingBuilder() {
                    @Override
                    protected void configure() {
                        mapping(type(A.class).mapEmptyString(true),
                                type(B.class),
                                TypeMappingOptions.wildcardCaseInsensitive(true)
                        ).fields(
                                field("fieldOfA").getMethod("getTheField"),
                                field("fieldOfB"),
                                FieldsMappingOptions.oneWay()
                        );
                    }
                })
                .build();
```

--------------------------------

### Spring Integration for Dozer Mapper Configuration

Source: https://dozermapper.github.io/gitbook/documentation/usage.html

Illustrates how to configure the Dozer Bean Mapper as a Spring bean, specifying custom mapping files through a Spring property list. This is the recommended approach for integrating Dozer within a Spring application.

```xml
<bean id="mapper" class="com.github.dozermapper.core.DozerBeanMapper">
    <property name="mappingFiles">
        <list>
            <value>dozer-global-configuration.xml</value>
            <value>dozer-bean-mappings.xml</value>
            <value>more-dozer-bean-mappings.xml</value>
        </list>
    </property>
</bean>
```

--------------------------------

### Simple Property Mapping

Source: https://dozermapper.github.io/gitbook/documentation/simpleproperty.html

Use this when mapping two properties with different names. This mapping is bi-directional.

```xml
<field>
    <a>one</a>
    <b>onePrime</b>
</field>
```

--------------------------------

### Clone Dozer Repository with Developer Access

Source: https://dozermapper.github.io/community/source-repository.html

Clone the Dozer Git tree using developer access credentials.

```bash
$ git clone git@github.com:DozerMapper/dozer.git
```

--------------------------------

### Implement Dozer EventListener Interface

Source: https://dozermapper.github.io/gitbook/documentation/events.html

Implement this interface to listen to Dozer mapping events. An `Event` object is passed to each callback, containing mapping details.

```java
public interface EventListener {

    public void onMappingStarted(Event event);

    public void onPreWritingDestinationValue(Event event);

    public void onPostWritingDestinationValue(Event event);

    public void onMappingFinished(Event event);
}
```

--------------------------------

### Map Field to HashMap with Custom Key and Setter

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Map a String field to a HashMap using a custom key name and a specific setter method for the source field.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.map.PropertyToMap</class-a>
    <class-b>com.github.dozermapper.core.vo.map.MapToProperty</class-b>
    <field>
        <a set-method="addStringProperty2">stringProperty2</a>
        <b key="myStringProperty">hashMap</b>
    </field>
</mapping>
```

--------------------------------

### Field Level Custom Create Method

Source: https://dozermapper.github.io/gitbook/documentation/customCreateMethod.html

Specify a custom static create method for a specific field.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.TestObject</class-a>
    <class-b>com.github.dozermapper.core.vo.TestObjectPrime</class-b>
    <field>
        <a>createMethodType</a>
        <b create-method="someCreateMethod">createMethodType</b>
    </field>
</mapping>
```

--------------------------------

### Map Field to Custom Map with Unique Get/Set Methods and Key

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Map a String field to a custom map implementation, specifying unique map getter/setter methods and a custom key. A destination hint can be provided for custom map types.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.map.PropertyToMap</class-a>
    <class-b>com.github.dozermapper.core.vo.map.MapToProperty</class-b>
    <field>
        <a>stringProperty3</a>
        <b map-get-method="getValue" map-set-method="putValue" key="myCustomProperty">customMap</b>
    </field>
    <field>
        <a>stringProperty4</a>
        <b map-get-method="getValue" map-set-method="putValue" key="myNullProperty">nullCustomMap</b>
        <b-hint>com.github.dozermapper.core.vo.map.CustomMap</b-hint>
    </field>
    <field>
        <a>stringProperty5</a>
        <b map-get-method="getValue" map-set-method="putValue">customMap</b>
    </field>
</mapping>
```

--------------------------------

### Global Dozer Configuration XML

Source: https://dozermapper.github.io/gitbook/documentation/faq.html

Define global configuration settings for the Dozer mapper in a separate XML file. This includes options like stop-on-errors, date format, and custom converters.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns="http://dozermapper.github.io/schema/bean-mapping"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://dozermapper.github.io/schema/bean-mapping http://dozermapper.github.io/schema/bean-mapping.xsd">
    <configuration>
        <stop-on-errors>true</stop-on-errors>
        <date-format>MM/dd/yyyy HH:mm</date-format>
        <wildcard>false</wildcard>
        <custom-converters>
            <converter type="com.github.dozermapper.core.converters.TestCustomConverter">
                <class-a>com.github.dozermapper.core.vo.CustomDoubleObject</class-a>
                <class-b>java.lang.Double</class-b>
            </converter>
        </custom-converters>
    </configuration>
</mappings>
```

--------------------------------

### Clone Dozer Repository Anonymously

Source: https://dozermapper.github.io/community/source-repository.html

Check out the Dozer source code anonymously using the Git clone command.

```bash
$ git clone https//github.com/DozerMapper/dozer/dozer-plugins-parent/dozer-site
```

--------------------------------

### Specifying Default Bean Factory in Configuration

Source: https://dozermapper.github.io/gitbook/documentation/custombeanfactories.html

Set a default bean factory for all mappings within a file by specifying it in the `<configuration>` section. This factory will be used unless overridden by a mapping-specific `bean-factory` attribute.

```xml
<configuration>
    <stop-on-errors>true</stop-on-errors>
    <wildcard>true</wildcard>
    <bean-factory>com.example.factories.SomeDefaultBeanFactory
  </bean-factory>
</configuration>
```

--------------------------------

### Configurable Custom Converter Mapping

Source: https://dozermapper.github.io/gitbook/documentation/customconverter.html

Map fields using a configurable custom converter, passing parameters via the 'custom-converter-param' attribute. This is useful for reusable, parametrized conversion logic.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.BeanA</class-a>
    <class-b>com.github.dozermapper.core.vo.BeanB</class-b>
    <field custom-converter="com.github.dozermapper.core.converters.MathOperationConverter" custom-converter-param="+">
        <a>amount</a>
        <b>amount</b>
    </field>
</mapping>
```

--------------------------------

### Map Field to HashMap

Source: https://dozermapper.github.io/gitbook/documentation/mapbackedproperty.html

Map a basic String field to a HashMap. The key will be the attribute name and the value will be the field's content.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.map.PropertyToMap</class-a>
    <class-b>com.github.dozermapper.core.vo.map.MapToProperty</class-b>
    <field>
        <a>stringProperty</a>
        <b>hashMap</b>
    </field>
</mapping>
```

--------------------------------

### Configure Custom Converters with IDs in Spring XML

Source: https://dozermapper.github.io/gitbook/documentation/customconverter.html

Define and inject custom converter instances with specific IDs using Spring XML configuration. This allows for programmatic configuration of converters and their reuse across mappings.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans default-lazy-init="false">
    <bean id="com.github.dozermapper.core.Mapper" class="com.github.dozermapper.core.DozerBeanMapper">
        <property name="mappingFiles">
            <list>
                <value>dozerBeanMapping.xml</value>
                <value>injectedCustomConverter.xml</value>
            </list>
        </property>
        <property name="customConvertersWithId">
            <map>
                <entry key="CustomConverterWithId" ref="configurableConverterBeanInstance1" />
                <entry key="CustomConverterWithId2" ref="configurableConverterBeanInstance2" />
            </map>
        </property>
    </bean>
</beans>
```

--------------------------------

### Object Array to List with Type Hint

Source: https://dozermapper.github.io/gitbook/documentation/collectionandarraymapping.html

Maps an Object array to a List, specifying a hint for data type conversion. This ensures the destination List contains String elements instead of the default Integer type.

```xml
<field>
    <a>arrayForLists</a>
    <b>listForArray</b>
    <b-hint>java.lang.String</b-hint>
</field>
```

--------------------------------

### Use DozerBeanMapperBuilder for Default Mapper

Source: https://dozermapper.github.io/gitbook/migration/v6-to-v61.html

The DozerBeanMapperSingletonWrapper is deprecated. Use DozerBeanMapperBuilder.buildDefault() to create a Mapper instance with default configuration, managed by your DI container.

```java
Mapper mapper = DozerBeanMapperBuilder.buildDefault();

```

--------------------------------

### Map Indexed Properties

Source: https://dozermapper.github.io/gitbook/documentation/indexmapping.html

Use this XML configuration to map indexed properties between two classes. It demonstrates mapping individual array elements and nested indexed properties.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.Individuals</class-a>
    <class-b>com.github.dozermapper.core.vo.FlatIndividual</class-b>
    <field>
        <a>usernames[0]</a>
        <b>username1</b>
    </field>
    <field>
        <a>usernames[1]</a>
        <b>username2</b>
    </field>
    <field>
        <a>individual.username</a>
        <b>username2</b>
    </field>
    <field>
        <a>secondNames[1]</a>
        <b>secondName1</b>
    </field>
    <field>
        <a>secondNames[2]</a>
        <b>secondName2</b>
    </field>
    <field>
        <a>aliases.otherAliases[0]</a>
        <b>primaryAlias</b>
    </field>
</mapping>
```

--------------------------------

### Configure Global Variables with EL

Source: https://dozermapper.github.io/gitbook/documentation/expressionlanguage.html

Define global variables for the Dozer mapper within the <variables> configuration block. These variables can then be used in mapping configurations.

```xml
<configuration>
   <wildcard>true</wildcard>
   <variables>
      <variable name="type_name">com.github.dozermapper.core.sample.MyType</variable>
   </variables>
</configuration>
<mapping>
   <class-a>${type_name}</class-a>
   <class-b>com.github.dozermapper.core.sample.OtherType</class-b>
</mapping>
```

--------------------------------

### Specify Destination Collection Element Type with Hint

Source: https://dozermapper.github.io/gitbook/documentation/collectionandarraymapping.html

Use a 'b-hint' element within a field mapping to specify the desired type of objects for the destination collection when converting between different collection types.

```xml
<field>
    <a>hintList</a>
    <b>hintList</b>
    <b-hint>com.github.dozermapper.core.vo.TheFirstSubClassPrime</b-hint>
</field>
```

--------------------------------

### Configure Custom Converter by ID in XML

Source: https://dozermapper.github.io/gitbook/documentation/customconverter.html

Reference a pre-configured custom converter instance by its ID at the field level. This is useful for reusing converter instances that have been defined elsewhere, potentially with specific configurations.

```xml
<mapping>
    <class-a>com.github.dozermapper.core.vo.SimpleObj</class-a>
    <class-b>com.github.dozermapper.core.vo.SimpleObjPrime2</class-b>
    <field custom-converter-id="CustomConverterWithId">
        <a>field1</a>
        <b>field1Prime</b>
    </field>
</mapping>
```

--------------------------------

### Enable new JAXB mapping engine

Source: https://dozermapper.github.io/gitbook/migration/v61-to-v62.html

To use the new JAXB-based XML mapping engine, set the 'dozer.xml.use-jaxb-mapping-engine' property to true in your configuration.

```properties
dozer.xml.use-jaxb-mapping-engine=true
```
Tokens:
Raw