Model Mapper

  1package com.demo.project85;
  2
  3import java.util.ArrayList;
  4import java.util.List;
  5
  6import lombok.AllArgsConstructor;
  7import lombok.Builder;
  8import lombok.Data;
  9import lombok.NoArgsConstructor;
 10import lombok.extern.slf4j.Slf4j;
 11import org.junit.jupiter.api.Assertions;
 12import org.junit.jupiter.api.Test;
 13import org.modelmapper.Converter;
 14import org.modelmapper.ModelMapper;
 15import org.modelmapper.PropertyMap;
 16
 17@Slf4j
 18public class ModelMapperTest {
 19
 20    @Test
 21    public void test_directCall() {
 22        Person person = getPerson();
 23        ModelMapper modelMapper = new ModelMapper();
 24        modelMapper.addMappings(personMap);
 25        PersonView personView = modelMapper.map(person, PersonView.class);
 26        log.info("personView: {}", personView);
 27        Assertions.assertEquals(personView.getFirstName(), person.getFirstName());
 28        Assertions.assertEquals(personView.getLastName(), person.getFamilyName().toUpperCase());
 29    }
 30
 31    @Test
 32    public void test_directCallJava8() {
 33        Person person = getPerson();
 34        ModelMapper modelMapper = new ModelMapper();
 35        PersonView personView = modelMapper
 36                .typeMap(Person.class, PersonView.class)
 37                .addMappings(mapper -> {
 38                    mapper.using(toUppercase)
 39                        .map(src -> src.getFamilyName(), PersonView::setLastName);
 40                    mapper.using(workStatusConvertor)
 41                            .map(src -> src.getWorkStatus(), PersonView::setWorkStatusName);
 42                    mapper.map(Person::getAge, PersonView::setAgeStr);
 43                })
 44                .map(person);
 45        log.info("personView: {}", personView);
 46        Assertions.assertEquals(personView.getFirstName(), person.getFirstName());
 47        Assertions.assertEquals(personView.getLastName(), person.getFamilyName().toUpperCase());
 48        Assertions.assertEquals(personView.getAgeStr(), String.valueOf(person.getAge()));
 49    }
 50
 51    @Test
 52    public void test_genericHelperClass() {
 53        Person person = getPerson();
 54        MapperHelper<Person, PersonView> entityMapperHelper = new MapperHelper<>(Person.class, PersonView.class);
 55        entityMapperHelper.mapper.typeMap(Person.class, PersonView.class)
 56                .addMappings(mapper -> {
 57                    mapper.using(toUppercase)
 58                            .map(src -> src.getFamilyName(), PersonView::setLastName);
 59                    mapper.using(workStatusConvertor)
 60                            .map(src -> src.getWorkStatus(), PersonView::setWorkStatusName);
 61                    mapper.map(Person::getAge, PersonView::setAgeStr);
 62                });
 63        PersonView personView = entityMapperHelper.toModel(person);
 64        log.info("personView: {}", personView);
 65        Assertions.assertEquals(personView.getFirstName(), person.getFirstName());
 66    }
 67
 68    @Test
 69    public void test_listConvertGenericHelperClass() {
 70        List<Person> personList = getListOfPersons();
 71        MapperHelper<Person,PersonView> entityMapperHelper = new MapperHelper<>(Person.class, PersonView.class);
 72        List<PersonView> personViewList = entityMapperHelper.toListModel(personList);
 73        log.info("personView: {}", personViewList);
 74        Assertions.assertEquals(personViewList.size(), personList.size());
 75    }
 76
 77    PropertyMap<Person, PersonView> personMap = new PropertyMap<>() {
 78        protected void configure() {
 79            using(toUppercase).map().setLastName(source.getFamilyName());
 80        }
 81    };
 82
 83    Converter<String, String> toUppercase =
 84            context -> context.getSource() == null ? null : context.getSource().toUpperCase();
 85
 86    Converter<WorkStatus, String> workStatusConvertor =
 87            context -> context.getSource() == null ? null : context.getSource().getStatus();
 88
 89    public static List<Person> getListOfPersons() {
 90        List<Person> personList = new ArrayList<>();
 91        personList.add(Person.builder()
 92                .firstName("luke")
 93                .familyName("skywalker")
 94                .age(30)
 95                .workStatus(WorkStatus.EMPLOYEED)
 96                .build());
 97        personList.add(Person.builder()
 98                .firstName("han")
 99                .familyName("solo")
100                .age(35)
101                .workStatus(WorkStatus.EMPLOYEED)
102                .build());
103        return personList;
104    }
105
106    public static Person getPerson() {
107        return Person.builder()
108                .firstName("luke")
109                .familyName("skywalker")
110                .workStatus(WorkStatus.EMPLOYEED)
111                .age(30)
112                .build();
113    }
114}
115
116@Data
117@Builder
118@NoArgsConstructor
119@AllArgsConstructor
120class Person {
121    String firstName;
122    String familyName;
123    WorkStatus workStatus;
124    int age;
125}
126
127enum WorkStatus {
128    EMPLOYEED("Employeed"),
129    UN_EMPLOYEED("Unemployeed");
130
131    String status;
132    WorkStatus(String status) {
133        this.status = status;
134    }
135
136    public String getStatus() {
137        return status;
138    }
139}
140
141@Data
142@Builder
143@NoArgsConstructor
144@AllArgsConstructor
145class PersonView {
146    String firstName;
147    String lastName;
148    WorkStatus workStatus;
149    String workStatusName;
150    String ageStr;
151}

 1package com.demo.project85;
 2
 3import java.util.List;
 4import java.util.stream.Collectors;
 5
 6import org.modelmapper.ModelMapper;
 7import org.springframework.data.domain.Page;
 8
 9public class MapperHelper<E, M> {
10    public MapperHelper(Class<E> entityType, Class<M> modelType) {
11        this.entityType = entityType;
12        this.modelType = modelType;
13        this.mapper = new ModelMapper();
14    }
15
16    public E toEntity(M model) {
17        return mapper.map(model, entityType);
18    }
19
20    public M toModel(E entity) {
21        return mapper.map(entity, modelType);
22    }
23
24    public Page<M> toPagedModel(Page<E> entities) {
25        return entities.map(this::toModel);
26    }
27
28    public List<M> toListModel(List<E> source) {
29        return source
30                .stream()
31                .map(this::toModel)
32                .collect(Collectors.toList());
33    }
34
35    Class<E> entityType;
36    Class<M> modelType;
37    ModelMapper mapper;
38}