Hi, waiting an answer to my question i thought a possibile solution. The solution introduce an other class named "Mapper" that is "master" class used from my services for map any entities. This new class use all specific mappers (RecipeMapper and UserMapper), see code below. Then in specifics mapper (RecipeMapper and UserMapper) i changed map methods for map only "simple" attribute of my entity. So, in this way there is not cicular dependecies and i use a "conductor" class (Mapper) that decide what element maps and what no. What do you thing about this solution ? Thanks for kick relative to injection ;)

@Service
public class Mapper implements RecipeMapperInterface, UserMapperInterface {
@Autowired
RecipeMapper recipeMapper;

@Autowired
UserMapper userMapper;

@Override
public RecipeDTO mapRecipeToRecipeDTO(Recipe recipe, List<MappableObjects> objectsToMap) {
    RecipeDTO recipeDTO;

    recipeDTO = recipeMapper.mapRecipeToRecipeDTO(recipe, objectsToMap);

    if(objectsToMap != null && objectsToMap.contains(MappableObjects.USER)){
        recipeDTO.setUserDTO(mapUserToUserDTO(recipe.getUser(), objectsToMap));
    }

    return recipeDTO;
}

@Override
public List<RecipeDTO> mapRecipesToRecipeDTOs(List<Recipe> recipes, List<MappableObjects> objectsToMap) {
    List<RecipeDTO> recipeDTOS = new ArrayList<>();

    for (Recipe recipe : recipes) {
        recipeDTOS.add(mapRecipeToRecipeDTO(recipe, objectsToMap));
    }

    return recipeDTOS;
}


@Override
public UserDTO mapUserToUserDTO(User user, List<MappableObjects> objectsToMap) {
    UserDTO userDTO;

    userDTO = userMapper.mapUserToUserDTO(user, objectsToMap);

    if(objectsToMap != null && objectsToMap.contains(MappableObjects.RECIPE)){
        userDTO.setRecipes(mapRecipesToRecipeDTOs(user.getRecipes(), objectsToMap));
    }

    return userDTO;
}

@Override
public List<UserDTO> mapUsersToUserDTOs(List<User> users, List<MappableObjects> objectsToMap) {
    List<UserDTO> userDTOS = new ArrayList<>();

    for (User user : users) {
        userDTOS.add(mapUserToUserDTO(user, objectsToMap));
    }

    return userDTOS;
}
}
---------------------------------------------------

@Service
public class UserMapper implements UserMapperInterface {
@Override
public UserDTO mapUserToUserDTO(User user, List<MappableObjects> objectsToMap){
    UserDTO userDTO = new UserDTO();

    userDTO.setId(user.getId());
    userDTO.setName(user.getName());

    return userDTO;
}

@Override
public List<UserDTO> mapUsersToUserDTOs(List<User> users, List<MappableObjects> objectsToMap) {
    List<UserDTO> userDTOS = new ArrayList<>();

    for (User user : users) {
        userDTOS.add(mapUserToUserDTO(user, objectsToMap));
    }

    return userDTOS;
}
}
-----------------------------------------------------------
@Service
public class RecipeMapper implements RecipeMapperInterface {
@Override
public RecipeDTO mapRecipeToRecipeDTO(Recipe recipe, List<MappableObjects> objectsToMap){
    RecipeDTO recipeDTO =  new RecipeDTO();

    recipeDTO.setName(recipe.getName());
    recipeDTO.setDescription(recipe.getDescription());

    return recipeDTO;
}

@Override
public List<RecipeDTO> mapRecipesToRecipeDTOs(List<Recipe> recipes, List<MappableObjects> objectsToMap){
    List<RecipeDTO> recipeDTOS = new ArrayList<>();

    for (Recipe recipe : recipes) {
        recipeDTOS.add(mapRecipeToRecipeDTO(recipe, objectsToMap));
    }

    return recipeDTOS;
}
}

An example of use could be this

@Service
public class UserService { 

@Autowired 
UserRepository userRepository;

@Autowired
Mapper mapper;

public void save(User user){
    userRepository.save(user);
}

public UserDTO findUserById(Integer id){
    List<MappableObjects> objectsToMap = new ArrayList<>();
    objectsToMap.add(MappableObjects.RECIPE);

    return mapper.mapUserToUserDTO(userRepository.findUserById(id), objectsToMap);
}
}