Orika-如何映射抽象嵌套属性的字段

问题描述

我很难映射抽象嵌套属性的字段.这里有一个测试用例，可以更好地解释它:

Hi I'm having a hard time mapping an abstract nested property's fields. Here I have the test case that explains it better:

package com.mycompany.asd;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.MappingException;
import ma.glasnost.orika.impl.DefaultMapperFactory;

/**
 * Tests the mapping of abstract nested property's fields
 */
public class OrikaTest {

private MapperFactory mapperFactory;

@Before
public void createMapperFactoryAndDefineMapping() {
    mapperFactory = new DefaultMapperFactory.Builder()
            .useAutoMapping(false).build();
    mapperFactory.classMap(FakeBeanA.class, FakeBeanB.class)
            .field("fieldA", "fieldB.nestedField")
            .field("fieldA2", "fieldB.nestedField2") // Problem here.
            .register();
}

@Test(expected = MappingException.class)
public void cannotMapAbstractNestedPropertyWhenConcreteTypeIsNotRegistered() {

    // We expect to get a MappingException. Indeed, Orika doesn't know how
    // to create an
    // instance of AbstractNestedField (the type of FakeBeanB.fieldB)
    createAnInstanceOfFakeBeanAAndMapItToFakeBeanB();
}

@Test
public void mapAbstractNestedPropertyWhenConcreteTypeIsRegistered() {

    // Register concrete type for AbstractNestedType
    mapperFactory.registerConcreteType(AbstractNestedType.class,
            NestedType.class);

    // Orika should be able to create an instance of FieldB abstract type
    // (as we have explicitly defined above the concrete type to create and
    // the SimpleConstructorResolverStrategy is normally able to create an
    // instance of this concrete type)
    // Therefore, the mapping should work !
    createAnInstanceOfFakeBeanAAndMapItToFakeBeanB();
}

private void createAnInstanceOfFakeBeanAAndMapItToFakeBeanB() {

    // Create an instance of FakeBeanA and assign a value to its fieldA
    FakeBeanA fakeBeanA = new FakeBeanA();
    fakeBeanA.fieldA = 42;

    // Try the mapping from fakeBeanA to FakeBeanB
    FakeBeanB fakeBeanB = mapperFactory.getMapperFacade().map(fakeBeanA,
            FakeBeanB.class);

    // Assert the fieldA has been correctly mapped to fieldB.nestedField
    Assert.assertEquals(fakeBeanA.fieldA, fakeBeanB.fieldB.nestedField);
}

public static class FakeBeanA {
    public int fieldA;
    public int fieldA2;
}

public static class FakeBeanB {
    public AbstractNestedType fieldB;
}

public static class NestedType extends AbstractNestedType {
    public int nestedField2; // NEW ADDED
}

public static abstract class AbstractNestedType {
    public int nestedField;
}

}

推荐答案

这是不可能的，也没有道理，如果还有另一个AbstractNestedType子类没有nestedField2怎么办?

This is not possible, and does not make sense, what if there is another subclass of AbstractNestedType that does not have nestedField2 ?

您可以做的就是使用

.customize(new CustomMapper<> {
    void mapBToA(FakeBeanA a, FakeBeanB b) {
   if(b.fieldB instanceof NestedType) {
      a.fieldA2 = ((NestedType)b.fieldB).nestedField2;
   }
 }});

...

这篇关于Orika-如何映射抽象嵌套属性的字段的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！