Argthtjtr

I have a Person class which has a Company class which also have a List of Person .

Everything works great, the List have the same references to the parent Person. Not having any duplicate of Person. (I think hibernate achieves this, IDK)

Now in DTO, i want to copy the DAO (Person,Company) to (PersonDTO,CompanyDTO)

How can I copy the list of Person so that it has the same Person objects.

public class Person {

String name;

String address;

Company Company;

}

public class Company {

    String name;

    String phoneNumber;

    List<Person> Persons;

}

You can use external libraries for that like ModelMapper, Dozer or MapStruct.

Here is an overview of mapping frameworks.

Assuming you are using Spring or Apache Commons utils to do the copying:

public static CompanyDTO convertToDTO(Company dao) {

    return dao != null ? convertToDTO(dao, null, null) : null;

}



public static PersonDTO convertToDTO(Person dao) {

    return dao != null ? convertToDTO(dao, null) : null;

}



private static CompanyDTO convertToDTO(Company dao, Person original, PersonDTO converted) {

    CompanyDTO dto = new CompanyDTO();

    BeanUtils.copyProperties(dao, dto, "persons");

    dto.setPersons(new ArrayList<>());



    for (Person person : dao.getPersons()) {

        if (person.equals(original)) {

            dto.getPersons().add(converted);

            continue;

        }



        PersonDTO personDTO = convertToDTO(person, dto);

        dto.getPersons().add(personDTO);

    }



    return dto;

}



private static PersonDTO convertToDTO(Person dao, Company converted) {

    PersonDTO dto = new PersonDTO();

    BeanUtils.copyProperties(dao, dto, "company");



    if (converted == null) {

        converted = convertToDTO(dao.getCompany(), dao, dto);

    }



    dto.setCompany(converted);



    return dto;

}

It's pretty manual here, but it should get the job done. Also note that it may be more reusable if you create more methods that take in objects using generics.

P.S. I didn't test this as I wrote it directly onto SO, so it may not work, or may contain some typoes.

Edit

Usually, DTOs are created without any form of caching, even for non-circular dependency entities. That means if I have a list of Person, and there are multiple people with the same date of birth, the same Date (or LocalDate) is going to be created multiple times.

You can definitely do a cached of created DTOs:

public final class DTOManager {

    private final Map<Class<?>, List<SoftReference<Object>>> cache = new HashMap<>();



    public static CompanyDTO convertToDTO(Company dao) {

        return dao != null ? convertToDTO(dao, null, null) : null;

    }



    public static PersonDTO convertToDTO(Person dao) {

        return dao != null ? convertToDTO(dao, null) : null;

    }



    private static CompanyDTO convertToDTO(Company dao, Person original, PersonDTO converted) {

        List<SoftReference<Object>> c = cache.get(CompanyDTO.class);

        Optional<Object> cachedDTO = (c == null) ? Optional.empty() : c.stream()

             .filter(ref ->

                 ref.get() != null &&

                 ref.get().getPrimaryKey() == dao.getPrimaryKey()) // Use equal() if string key

             .findAny();



        if (cachedDTO.isPresent()) {

            return (CompanyDTO) cachedDTO.get();

        }



        CompanyDTO dto = new CompanyDTO();

        BeanUtils.copyProperties(dao, dto, "persons");

        dto.setPersons(new ArrayList<>());



        for (Person person : dao.getPersons()) {

            if (person.equals(original)) {

                dto.getPersons().add(converted);

                continue;

            }



            PersonDTO personDTO = convertToDTO(person, dto);

            dto.getPersons().add(personDTO);

        }



        if (c == null) {

            c = new ArrayList<>();

            cache.put(CompanyDTO.class, c);

        }



        c.add(new SoftReference<>(dto));



        return dto;

    }



    private static PersonDTO convertToDTO(Person dao, Company converted) {

        List<SoftReference<Object>> c = cache.get(PersonDTO.class);

        Optional<Object> cachedDTO = (c == null) ? Optional.empty() : c.stream()

             .filter(ref ->

                 ref.get() != null &&

                 ref.get().getPrimaryKey() == dao.getPrimaryKey()) // Use equal() if string key

             .findAny();



        if (cachedDTO.isPresent()) {

            return (PersonDTO) cachedDTO.get();

        }



        PersonDTO dto = new PersonDTO();

        BeanUtils.copyProperties(dao, dto, "company");



        if (converted == null) {

            converted = convertToDTO(dao.getCompany(), dao, dto);

        }



        dto.setCompany(converted);



        if (c == null) {

            c = new ArrayList<>();

            cache.put(PersonDTO.class, c);

        }



        c.add(new SoftReference<>(dto));



        return dto;

    }

}

This method comes with the cost of accuracy - objects in the cache may not be the most updated. You can implement your own cache, mine is just a simple example. My example is also not thread-safe, so you may want to take note.

In my opinion, it is not worth it to implement caching, since DTOs are supposed to be use-and-dump. This is only plausible if you are expecting retrieval of very huge amount of entities in a single transaction. Otherwise, it might be better to let it create more objects, then let the data transfer process take place, and thereafter let the garbage collector reclaim back those memory.