web-dev-qa-db-fra.com

ModelMapper, mappage de la liste des entités à la liste des objets DTO

J'écris une application web de blog simple en utilisant le framework Spring MVC. Je suis prêt à ajouter la couche DTO à mon application.

J'ai décidé d'utiliser ModelMapper framework pour la conversion de Entity objets en DTO objets utilisés dans mes vues.

J'ai juste un problème. Sur ma page principale, je montre une liste de messages sur mon blog. À mon avis, c'est juste une liste d'objets Post (Entity). Je souhaite le modifier pour transmettre une liste d'objets PostDTO à ma vue. Existe-t-il un moyen de mapper List des Post objets à List de PostDTO objet avec un seul appel de méthode? Je pensais à écrire convertisseur qui convertira ceci mais je ne suis pas sûr que ce soit un bon moyen de le faire.

En outre, j'utilise Lists de Entities dans quelques autres endroits comme le panneau d'administration ou les commentaires sous chaque publication sur ma page.

Lien vers le code de mon application sur le référentiel GitHub: référentiel

javamodelmapper
9
Gromo

Vous pouvez créer une classe util:

public class ObjectMapperUtils {

    private static ModelMapper modelMapper = new ModelMapper();

    /**
     * Model mapper property setting are specified in the following block.
     * Default property matching strategy is set to Strict see {@link MatchingStrategies}
     * Custom mappings are added using {@link ModelMapper#addMappings(PropertyMap)}
     */
    static {
        modelMapper = new ModelMapper();
        modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
    }

    /**
     * Hide from public usage.
     */
    private ObjectMapperUtils() {
    }

    /**
     * <p>Note: outClass object must have default constructor with no arguments</p>
     *
     * @param <D>      type of result object.
     * @param <T>      type of source object to map from.
     * @param entity   entity that needs to be mapped.
     * @param outClass class of result object.
     * @return new object of <code>outClass</code> type.
     */
    public static <D, T> D map(final T entity, Class<D> outClass) {
        return modelMapper.map(entity, outClass);
    }

    /**
     * <p>Note: outClass object must have default constructor with no arguments</p>
     *
     * @param entityList list of entities that needs to be mapped
     * @param outCLass   class of result list element
     * @param <D>        type of objects in result list
     * @param <T>        type of entity in <code>entityList</code>
     * @return list of mapped object with <code><D></code> type.
     */
    public static <D, T> List<D> mapAll(final Collection<T> entityList, Class<D> outCLass) {
        return entityList.stream()
                .map(entity -> map(entity, outCLass))
                .collect(Collectors.toList());
    }

    /**
     * Maps {@code source} to {@code destination}.
     *
     * @param source      object to map from
     * @param destination object to map to
     */
    public static <S, D> D map(final S source, D destination) {
        modelMapper.map(source, destination);
        return destination;
    }
}

Et utilisez-le pour vos besoins:

List<PostDTO> listOfPostDTO = ObjectMapperUtils.mapAll(listOfPosts, PostDTO.class);
23
Andrew Nepogoda

considérant que vous disposez d'une liste de Post Entity (postEntityList) et d'une classe PostDTO, vous pouvez essayer de suivre:

utilisez les importations suivantes pour obtenir les résultats souhaités

import org.modelmapper.ModelMapper;
import org.modelmapper.TypeToken;
import Java.lang.reflect.Type;

utilisez le code ci-dessous

Type listType = new TypeToken<List<PostDTO>>(){}.getType();
List<PostDTO> postDtoList = modelmapper.map(postEntityList,listType);
19
André Carvalho

Essayez la méthode simple suivante:

List<PostDTO> postDtoList = Arrays.asList(modelMapper.map(postEntityList, PostDTO[].class));
5
Jingchao Luan

puisque vous voulez convertir Entity en Dto, vous pouvez essayer le suivant

List<PostDTO> entityToDto = modelMapper.map(postEntity, new TypeToken<List<PostDTO>>(){}.getType());
3
karthick S

Supposons que vous lisez à partir de la base de données et que vous souhaitez convertir des entités de la base de données en DTO

La couche de service peut être séparée du contrôleur (toujours la meilleure approche), puis procédez comme suit:

Code de couche de service:

@Override
    public List<PostDTO> convertEntityToDTOList( ){
            List<Post> post = postRepository.findAll();
            Type listType = new TypeToken<List<PostDTO>>(){}.getType();
            List<PostDTO> postDTOList = modelMapper.map(post, listType);
            return postDTOList;
        }

Ensuite, dans votre contrôleur, ajoutez ceci:

public ResponseEntity<?> list(){
        List<PostDTO> postDTOList = iPost.convertEntityToDTOList();
        return new ResponseEntity<>(postDTOList, HttpStatus.OK);
    }

Notez que l'iPost est une interface qui définit la méthode. Ça y est:

public interface iPost {
   List<PostDTO> convertEntityToDTOList();
}

Crédits à @ André Carvalho

0
ken4ward