import org.modelmapper.convention.MatchingStrategies; //导入依赖的package包/类
public OrderMapper() {
    mapper = new ModelMapper();
    // use strict to prevent over eager matching (happens with ID fields)
    mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
    // create PropertyMap<source,target> here and add to mapper
    mapper.addMappings(new PropertyMap<OrderForm, OrderDto>() {
        @Override
        protected void configure() {
        }
    });
    mapper.addMappings(new PropertyMap<OrderDto, OrderForm>() {
        @Override
        protected void configure() {
        }
    });
    mapper.addMappings(new PropertyMap<OrderItemDto, OrderItem>() {
        @Override
        protected void configure() {
        }
    });
    // need to add the parent link to jpa order items (as these don't exist in dto form)
    mapper.getTypeMap(OrderDto.class, OrderForm.class)
            .setPostConverter(context -> {
                OrderForm target = context.getDestination();
                log.info("post-converter fixing OrderItem parent links {}", target);
                if (target.getItems() != null) {
                    target.getItems().stream().forEach((item) -> item.setOrder(target));
                }
                return target;
            });
}
 

import org.modelmapper.convention.MatchingStrategies; //导入依赖的package包/类
private ModelMapper ensureMapper() {
    if (mapper == null) {
        synchronized (this) {
            if (mapper == null) {
                mapper = newMapper();
                if (matchingStrategy != null) {
                    final Configuration configuration = mapper.getConfiguration();
                    try {
                        configuration.setMatchingStrategy(MatchingStrategy.class.cast(
                                MatchingStrategies.class.getDeclaredField(matchingStrategy.toUpperCase(Locale.ENGLISH)).get(null)));
                    } catch (final Exception e) {
                        try {
                            configuration.setMatchingStrategy(MatchingStrategy.class.cast(currentLoader().loadClass(matchingStrategy)));
                        } catch (final Exception e1) {
                            if (RuntimeException.class.isInstance(e)) {
                                throw RuntimeException.class.cast(e);
                            }
                            throw new IllegalStateException(e);
                        }
                    }
                }
            }
        }
    }
    return mapper;
}
 

import org.modelmapper.convention.MatchingStrategies; //导入依赖的package包/类
public ProjectDTO getProjectDtoFromEntity(Project project) {
	getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
	ProjectDTO projectDTO = map(project, ProjectDTO.class);
	mapFromOrganization(project, projectDTO);
	
	return projectDTO;
}
 

import org.modelmapper.convention.MatchingStrategies; //导入依赖的package包/类
@Override
public UserDTO updateUser(long id, UserUpdateDTO updateDTO) {
    Assert.notNull(updateDTO, "User update dto must not be null.");
    User userToUpdate = userRepository.findOne(id);
    if (userToUpdate != null) {
        modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STANDARD);
        modelMapper.map(updateDTO, userToUpdate.getDetails());
        modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.LOOSE);
        User saved = userRepository.save(userToUpdate);
        return modelMapper.map(saved, UserDTO.class);
    }
    return null;
}
 

import org.modelmapper.convention.MatchingStrategies; //导入依赖的package包/类
@Override
public boolean save(TransportCreateDTO createDTO, User owner) {
    Assert.notNull(createDTO, "Transport create dto must not be null!");

    Transport transportToSave = new Transport();
    modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
    modelMapper.map(createDTO, transportToSave);
    modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.LOOSE);

    transportToSave.setOwner(owner);
    Transport saved = transportRepository.save(transportToSave);
    return saved != null;
}
 

import org.modelmapper.convention.MatchingStrategies; //导入依赖的package包/类
public ProjectDTO getProjectDtoFromEntity(Project project){
	getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
	ProjectDTO projectDTO = map(project, ProjectDTO.class);
	projectDTO.setOrganizationName(project.getOrganization().getName());
	return projectDTO;
}
 

import org.modelmapper.convention.MatchingStrategies; //导入依赖的package包/类
public StoryDTO getStoryDtoFromEntity(Story story) {
    getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
    StoryDTO storyDTO = map(story, StoryDTO.class);
    return storyDTO;
}
 

import org.modelmapper.convention.MatchingStrategies; //导入依赖的package包/类
public Project getProjectEntityFromCreateProjectDto(CreateProjectDTO createProjectDTO){
	getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
	Project project = map(createProjectDTO, Project.class);
	project.setOrganization(organizationDAO.findOne(createProjectDTO.getOrganizationId()));
	return project;
}
 

import org.modelmapper.convention.MatchingStrategies; //导入依赖的package包/类
@Override
public void configure(Configuration configuration) {
    configuration.setMatchingStrategy(MatchingStrategies.STRICT);
}