如何在Dozer/Orika中指定静态方法创建目标Bean实例？

Hey there! Great question—both Dozer and Orika fully support using a static factory method to create instances of your unmodifiable third-party class B, which is exactly what you need here. Let's walk through how to set this up with each library:

You were on the right track with the XML configuration snippet you found! Dozer lets you explicitly define a static factory method for your target class in its mapping configuration.

Suppose your third-party class TypeB has a static factory method like public static TypeB createInstance(). Here's how to configure the mapping:

<mappings>
  <mapping>
    <class-a>com.yourpackage.TypeA</class-a>
    <class-b>com.thirdparty.TypeB</class-b>
    
    <!-- Configure the static factory for TypeB -->
    <class-b-factory>
      <factory-bean-class>com.thirdparty.TypeB</factory-bean-class>
      <factory-method>createInstance</factory-method>
    </class-b-factory>

    <!-- Optional: Define explicit field mappings if property names don't match -->
    <field>
      <a>userName</a>
      <b>accountName</b>
    </field>
  </mapping>
</mappings>

If your static factory method requires parameters, Dozer also supports passing them via <factory-parameter> elements. For parameters sourced from TypeA's properties, you might need a custom converter, but for most no-arg factory scenarios, the above configuration works perfectly.

Orika leans into code-based configuration, which gives you more flexibility for custom instance creation. You'll need to register a custom ObjectFactory that calls TypeB's static method, then wire it into your mapper setup.

Here's a code example:

// Initialize the Orika mapper factory
MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

// Register a custom factory for TypeB that uses its static creation method
mapperFactory.registerObjectFactory(new ObjectFactory<TypeB>() {
    @Override
    public TypeB create(Object source, Class<?> sourceType, Class<TypeB> targetType) {
        // Call TypeB's static factory method here
        return TypeB.createInstance();
    }
}, TypeB.class);

// Define the mapping between TypeA and TypeB
mapperFactory.classMap(TypeA.class, TypeB.class)
        .field("email", "contactEmail") // Map mismatched property names
        .byDefault() // Auto-map all matching property names
        .register();

// Get the mapper facade and perform the mapping
Mapper mapper = mapperFactory.getMapperFacade();
TypeB mappedB = mapper.map(yourTypeAInstance, TypeB.class);

If your static factory needs parameters from TypeA, you can easily access the source instance (the TypeA object) in the create method to extract and pass those values—super flexible for complex scenarios.

Both libraries handle your use case smoothly: Dozer is great if you prefer XML-based configuration, while Orika shines when you want code-driven, customizable mappings.

内容的提问来源于stack exchange，提问作者RDM