Dozer bidirektionales mapping (String, String) mit custom comverter unmöglich?

Ich hatte das gleiche problem und derzeit (Raupen-5.5.x) es gibt keinen einfachen Weg, aber es ist Komplex.

Beachten Sie, dass es stützt sich auf keine security-manager aktiviert, die in der JVM, oder sonst müssen Sie einige Berechtigungen in der Sicherheit Regeln. Das ist, weil diese Lösung verwendet reflektion, um Zugriff auf private Felder von Raupen-Klassen.

Müssen Sie erstrecken sich 2 Klassen: DozerBeanMapper und MappingProcessor. Sie müssen auch enum-Element für die Richtung und die Schnittstelle verwenden, um die Richtung vom oben genannten Klassen.

Enum:

public enum Direction {
    TO,
    FROM;
}

Schnittstelle:

public interface DirectionAware {
    Direction getDirection();
}

Die Klasse, die sich DozerBeanMapper:

public class DirectionAwareDozerBeanMapper extends DozerBeanMapper implements DirectionAware {
    private Direction direction;

    public DirectionAwareDozerBeanMapper(Direction direction) {
        super();
        this.direction = direction;
    }

    public DirectionAwareDozerBeanMapper(Direction direction, List<String> mappingFiles) {
        super(mappingFiles);
        this.direction = direction;
    }

    @Override
    protected Mapper getMappingProcessor() {
        try {
            Method m = DozerBeanMapper.class.getDeclaredMethod("initMappings");
            m.setAccessible(true);
            m.invoke(this);
        } catch (NoSuchMethodException|SecurityException|IllegalAccessException|IllegalArgumentException|InvocationTargetException e) {
            //Handle the exception as you want
        }

        ClassMappings arg1 = (ClassMappings)getField("customMappings");
        Configuration arg2 = (Configuration)getFieldValue("globalConfiguration");
        CacheManager arg3 = (CacheManager)getField("cacheManager");
        StatisticsManager arg4 = (StatisticsManager)getField("statsMgr");
        List<CustomConverter> arg5 = (List<CustomConverter>)getField("customConverters");
        DozerEventManager arg6 = (DozerEventManager)getField("eventManager");
        Map<String, CustomConverter> arg7 = (Map<String, CustomConverter>)getField("customConvertersWithId");

        Mapper mapper = new DirectionAwareMappingProcessor(arg1, arg2, arg3, arg4, arg5,
                                arg6, getCustomFieldMapper(), arg7, direction);

        return mapper;
    }

    private Object getField(String fieldName) {
        try {
            Field field = DozerBeanMapper.class.getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(this);
        } catch (NoSuchFieldException|SecurityException|IllegalArgumentException|IllegalAccessException e) {
            //Handle the exception as you want
        }
        return null;
    }

    public Direction getDirection() {
        return direction;
    }
}

Die Klasse, die sich MappingProcessor:

public class DirectionAwareMappingProcessor extends MappingProcessor implements DirectionAware {
    private Direction direction;

    protected DirectionAwareMappingProcessor(ClassMappings arg1, Configuration arg2, CacheManager arg3, StatisticsManager arg4, List<CustomConverter> arg5, DozerEventManager arg6, CustomFieldMapper arg7, Map<String, CustomConverter> arg8, Direction direction) {
        super(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
        this.direction = direction;
    }

    public Direction getDirection() {
        return direction;
    }
}

Nun, die Nutzung.

1) jedes mal, wenn Sie wollen, die Karte der gleichen primitiven Typ (z.B. String-String), verwenden Sie DozerConverter mit dieser Art für beide Argumente ein custom-Konverter in Ihrem Raupen-mappings-Datei. Die Umsetzung solcher Konverter erweitern sollten: DozerConverter<String,String> und implementieren MapperAware - Schnittstelle. Dies ist wichtig, dass Sie MapperAware verfügbar, da haben die mapper Sie werden in der Lage sein, um Sie zu wirken, um DirectionAware und dann die Richtung.

Beispiel:

public class MyMapper extends DozerConverter<String, String> implements MapperAware {
    private DirectionAware dirAware;

    public MyMapper(Class<String> cls) {
        super(cls, cls);
    }

    @Override
    public Object convert(Object existingDestinationFieldValue, Object sourceFieldValue, Class<String> destinationClass, Class<String> sourceClass) {
        if (dirAware.getDirection() == Direction.FROM) {
            //TODO convert sourceFieldValue for "FROM" direction and return it
        } else {
            //TODO convert sourceFieldValue for "TO" direction and return it
        }
    }

    @Override
    public void setMapper(Mapper mapper) {
        dirAware = (DirectionAware)mapper;
    }
}

2) müssen Sie 2 global Raupen-mapper-Objekte, die eine pro-mapping-Richtung. Sie sollten so konfiguriert werden, mit dem gleichen mapping-Dateien, aber mit unterschiedlicher Richtung-argument. Zum Beispiel:

DirectionAwareDozerBeanMapper mapperFrom = DirectionAwareDozerBeanMapper(mappingFiles, Direction.FROM);
DirectionAwareDozerBeanMapper mapperTo = DirectionAwareDozerBeanMapper(mappingFiles, Direction.TO);

Natürlich müssen Sie die ordnungsgemäße Verwendung von mapper (von/bis) Angaben zu custom Mapper auf, in welche Richtung Sie kartographierten.