Как сопоставить коллекции в Dozer

Ответ 1

Цитата:

"Вложенные коллекции обрабатываются автоматически, но вы правы что коллекции верхнего уровня должны быть перевернулся. В настоящее время нет более элегантный способ справиться с этим".

Кто-то придумал способ сделать это без создания цикла в вашей базе кода, но я думаю, что это просто проще (и более удобочитаемым/поддерживаемым) в вашем коде. Надеюсь, они добавят эту способность раньше, чем позже.

Ответ 2

Я столкнулся с подобной проблемой и решил использовать универсальный метод утилиты, чтобы избежать повторения каждый раз, когда мне нужно было выполнить такое сопоставление.

public static <T, U> List<U> map(final Mapper mapper, final List<T> source, final Class<U> destType) {

    final List<U> dest = new ArrayList<>();

    for (T element : source) {
        dest.add(mapper.map(element, destType));
    }

    return dest;
}

Использование тогда было бы чем-то вроде:

    final List<CustomObject> accounts..... 
    final List<NewObject> actual = Util.map(mapper, accounts, NewObject.class);

Возможно, это может быть еще более упрощено.

Ответ 3

Что происходит, так это то, что вас укушают стирание типа. Во время выполнения java видит только ArrayList.class. Тип CustomObject и NewObject не существует, поэтому Dozer пытается сопоставить java.util.ArrayList, а не ваш CustomObject - NewObject.

Что должно работать (полностью непроверено):

List<CustomObject> ori = new ArrayList<CustomObject>();
List<NewObject> n = new ArrayList<NewObject>();
for (CustomObject co : ori) {
    n.add(MAPPER.map(co, CustomObject.class));
}

Ответ 4

вы можете сделать это следующим образом:

public <T,S> List<T> mapListObjectToListNewObject(List<S> objects, Class<T> newObjectClass) {
final List<T> newObjects = new ArrayList<T>();
for (S s : objects) {
    newObjects.add(mapper.map(s, newObjectClass));
}
return newObjects;

}

и используйте его:

ArrayList<CustomObject> objects = ....
List<NewObject> newObjects = mapListObjectToListNewObject(objects,NewObject.class);

Ответ 5

В этом случае я однажды написал небольшой вспомогательный класс:

import java.util.Collection;

/**
 * Helper class for wrapping top level collections in dozer mappings.
 * 
 * @author Michael Ebert
 * @param <E>
 */
public final class TopLevelCollectionWrapper<E> {

    private final Collection<E> collection;

    /**
     * Private constructor. Create new instances via {@link #of(Collection)}.
     * 
     * @see {@link #of(Collection)}
     * @param collection
     */
    private TopLevelCollectionWrapper(final Collection<E> collection) {
        this.collection = collection;
    }

    /**
     * @return the wrapped collection
     */
    public Collection<E> getCollection() {
        return collection;
    }

    /**
     * Create new instance of {@link TopLevelCollectionWrapper}.
     * 
     * @param <E>
     *            Generic type of {@link Collection} element.
     * @param collection
     *            {@link Collection}
     * @return {@link TopLevelCollectionWrapper}
     */
    public static <E> TopLevelCollectionWrapper<E> of(final Collection<E> collection) {
        return new TopLevelCollectionWrapper<E>(collection);
    }
}

Затем вы вызываете бульдозер следующим образом:

private Mapper mapper;

@SuppressWarnings("unchecked")
public Collection<MappedType> getMappedCollection(final Collection<SourceType> collection) {
    TopLevelCollectionWrapper<MappedType> wrapper = mapper.map(
            TopLevelCollectionWrapper.of(collection),
            TopLevelCollectionWrapper.class);

    return wrapper.getCollection();
}

Только недостаток: вы получаете предупреждение "без отметки" на mapper.map(...) из-за интерфейса буфера Dozers Mapping, не обрабатывающего общие типы.

Ответ 6

На самом деле не улучшение, скорее как синтаксический сахар, который может быть достигнут благодаря Guava (и, скорее всего, подобное возможно с помощью Apache Commons):

final List<MyPojo> mapped = Lists.newArrayList(Iterables.transform(inputList, new Function<MyEntity, MyPojo>() {
    @Override public MyPojo apply(final MyEntity arg) {
        return mapper.map(arg, MyPojo.class);
    }
}));

Это также можно превратить в общую функцию - как предложено в других ответах.

Ответ 7

Я сделал это с помощью Java 8 и dozer 5.5. Вам не нужны XML файлы для сопоставления. Вы можете сделать это на Java.

Вам не нужно дополнительное сопоставление для списков, только вам нужно

вам нужно добавить список в качестве поля в отображении

. См. Пример конфигурации bean ниже.

Spring класс конфигурации

@Configuration
public class Config {

@Bean
    public DozerBeanMapper dozerBeanMapper() throws Exception {
        DozerBeanMapper mapper = new DozerBeanMapper();
        mapper.addMapping( new BeanMappingBuilder() {
            @Override
            protected void configure() {
                mapping(Answer.class, AnswerDTO.class);
                mapping(QuestionAndAnswer.class, QuestionAndAnswerDTO.class).fields("answers", "answers");                  
            }
        });
        return mapper;
    }

}

//Класс ответа и классы AnswerDTO имеют одинаковые атрибуты

public class AnswerDTO {

    public AnswerDTO() {
        super();
    }

    protected int id;
    protected String value;

    //setters and getters
}

//Класс QuestionAndAnswerDTO имеет список ответов

public class QuestionAndAnswerDTO {

    protected String question;
    protected List<AnswerDTO> answers;

   //setters and getters
}

//Затем, чтобы использовать mapper в вашем коде, autwire it

@Autowired
private DozerBeanMapper dozerBeanMapper;
// in your method


 QuestionAndAnswerDTO questionAndAnswerDTO =
    dozerBeanMapper.map(questionAndAnswer, QuestionAndAnswerDTO.class);

Надеюсь, что это поможет кому-то следовать подходу Java вместо XML.

Ответ 8

Вы можете реализовать свой собственный класс сопоставления, который расширит отображение бульдозера. Пример: Создайте интерфейс, который добавляет дополнительный метод для dozer mapper:

public interface Mapper extends org.dozer.Mapper {
    <T> List<T> mapAsList(Iterable<?> sources, Class<T> destinationClass);
}

Следующий шаг: напишите свой собственный класс Mapper, выполнив описанный выше интерфейс.

добавьте ниже метод к вашему классу реализации:

public class MyMapper implements Mapper {
    @Override
    public <T> List<T> mapAsList(Iterable<?> sources, Class<T> destinationClass) {
        //can add validation methods to check if the object is iterable
        ArrayList<T> targets = new ArrayList<T>();
        for (Object source : sources) {
            targets.add(map(source, destinationClass));
        }
        return targets;
    }
    //other overridden methods.
}

Надеюсь, что это поможет