ModelMapperExampleTest.java

import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;

import java.util.List;
import java.util.Locale;
import java.util.Map;

import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;

import org.springframework.data.mapping.model.MappingException;

import org.junit.Before;
import org.junit.Test;
import org.modelmapper.Converter;
import org.modelmapper.ModelMapper;
import org.modelmapper.convention.MatchingStrategies;
import org.modelmapper.convention.NameTokenizers;
import org.modelmapper.spi.ConditionalConverter;
import org.modelmapper.spi.MappingContext;

import com.fasterxml.jackson.databind.ObjectMapper;

@Slf4j
public class ModelMapperExampleTest {
	
	static final ObjectMapper OM = new ObjectMapper();
	
	private ModelMapper sut;
	
	@Before
	public void before() throws Exception {
		sut = new ModelMapper();
		sut.getConfiguration().setMatchingStrategy(MatchingStrategies.LOOSE);
		sut.getConfiguration().setSourceNameTokenizer(NameTokenizers.UNDERSCORE);
		sut.getConfiguration().setFieldMatchingEnabled(true)
			.setFieldAccessLevel(org.modelmapper.config.Configuration.AccessLevel.PRIVATE);
		sut.addConverter(StringToLocaleConverter.getInstance());
		sut.createTypeMap(String.class, List.class).setConverter(new ListDeserializeConverter(OM));
		sut.createTypeMap(List.class, String.class).setConverter(new ListSerializeConverter(OM));
		sut.createTypeMap(String.class, Map.class).setConverter(new MapDeserializeConverter(OM));
		sut.createTypeMap(Map.class, String.class).setConverter(new MapSerializeConverter(OM));
	}

	
	@Test
	public void test() {
		// setup
		String listString = "[{\"key\":\"aaa\",\"value\":\"111\"},{\"key\":\"bbb\",\"value\":\"222\"}]";
		String mapString = "{\"aaa\":{\"key\":\"aaa\",\"value\":\"111\"},\"bbb\":{\"key\":\"bbb\",\"value\":\"222\"}}";
		PersistentModel persistentModel1 = new PersistentModel(1L, "ja_jp", "X0001", "わいわい", listString, mapString);
		log.info("PM1 {}", persistentModel1);
		
		// exercise 1: PM1->DM1
		DomainModel domainModel1 = sut.map(persistentModel1, DomainModel.class);
		log.info("DM1 {}", domainModel1);
		
		// exercise 2: DM1->PM2
		PersistentModel persistentModel2 = sut.map(domainModel1, PersistentModel.class);
		log.info("PM2 {}", persistentModel2);
		
		// exercise 1: PM2->DM2
		DomainModel domainModel2 = sut.map(persistentModel2, DomainModel.class);
		log.info("DM2 {}", domainModel2);
		
		// verify
		assertThat(persistentModel2, is(equalTo(persistentModel1)));
		assertThat(domainModel2, is(equalTo(domainModel1)));
	}
}

//==== Models

@ToString
@EqualsAndHashCode
@AllArgsConstructor
@NoArgsConstructor(access = AccessLevel.PACKAGE)
class PersistentModel {
	
	@Getter
	@Setter(AccessLevel.PACKAGE)
	private long id;
	
	@Getter
	@Setter(AccessLevel.PACKAGE)
	private String lang;
	
	@Getter
	@Setter(AccessLevel.PACKAGE)
	private String code;
	
	@Getter
	@Setter
	private String value;
	
	@Getter
	@Setter
	private String subModelList;
	
	@Getter
	@Setter
	private String subModelMap;
	
}

@ToString
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
class DomainModel {
	
	@Getter(AccessLevel.PACKAGE)
	@Setter(AccessLevel.PACKAGE)
	private long id;
	
	@Getter
	@Setter(AccessLevel.PACKAGE)
	private Locale lang;
	
	@Getter
	@Setter(AccessLevel.PACKAGE)
	private String code;
	
	@Getter
	@Setter
	private String value;
	
	@Getter
	@Setter
	private List<DomainSubModel> subModelList;
	
	@Getter
	@Setter
	private Map<String, DomainSubModel> subModelMap;
	
}

@Data
@EqualsAndHashCode
@AllArgsConstructor
@NoArgsConstructor
class DomainSubModel {
	
	private String key;
	
	private String value;
	
}

@RequiredArgsConstructor
abstract class AbstractToStringConverter<S> {
	
	private final ObjectMapper objectMapper;
	
	public String convert(MappingContext<S, String> context) {
		try {
			return objectMapper.writeValueAsString(context.getSource());
		} catch (Exception e) {
			throw new MappingException(e.getMessage(), e);
		}
	}
}

@RequiredArgsConstructor
abstract class AbstractFromStringConverter<D> {
	
	private final ObjectMapper objectMapper;
	
	public D convert(MappingContext<String, D> context) {
		try {
			return objectMapper.readValue(context.getSource(), context.getDestinationType());
		} catch (Exception e) {
			throw new MappingException(e.getMessage(), e);
		}
	}
}

// ==== Converter implementations

@NoArgsConstructor(access = AccessLevel.PRIVATE)
class StringToLocaleConverter implements ConditionalConverter<String, Locale> {
	
	@Getter
	private static final StringToLocaleConverter instance = new StringToLocaleConverter();
	
	
	@Override
	public Locale convert(MappingContext<String, Locale> context) {
		return new Locale(context.getSource());
	}
	
	@Override
	public MatchResult match(Class<?> sourceType, Class<?> destinationType) {
		return sourceType.equals(String.class) && destinationType.equals(Locale.class) ? MatchResult.FULL
				: MatchResult.NONE;
	}
}

@SuppressWarnings("rawtypes")
class ListDeserializeConverter extends AbstractFromStringConverter<List> implements Converter<String, List> {

	public ListDeserializeConverter(ObjectMapper objectMapper) {
		super(objectMapper);
	}
}

@SuppressWarnings("rawtypes")
class ListSerializeConverter extends AbstractToStringConverter<List> implements Converter<List, String> {

	public ListSerializeConverter(ObjectMapper objectMapper) {
		super(objectMapper);
	}
}

@SuppressWarnings("rawtypes")
class MapDeserializeConverter extends AbstractFromStringConverter<Map> implements Converter<String, Map> {

	public MapDeserializeConverter(ObjectMapper objectMapper) {
		super(objectMapper);
	}
}

@SuppressWarnings("rawtypes")
class MapSerializeConverter extends AbstractToStringConverter<Map> implements Converter<Map, String> {

	public MapSerializeConverter(ObjectMapper objectMapper) {
		super(objectMapper);
	}
}