编写一个按id显示两个类的函数

Question

我有小型网络服务，我有团队和人员。我为两个类写了服务，创建了dto，make entions，关系和webcontrollers。现在我想写一个方法，我想把我的人输入这个团队。我有很多问题如何开始编写那种方法。我应该在哪个服务中创建此方法？那个方法应该怎么样？ 我向你展示我的人员和团队服务： 人员服务：

package com.softwaremind.crew.people.service;

import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;

import org.modelmapper.ModelMapper;
import org.modelmapper.TypeToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import com.softwaremind.crew.people.model.Person;
import com.softwaremind.crew.people.model.dto.PersonDto;
import com.softwaremind.crew.people.repository.PersonRepository;

/**
 * PersonService class for managing {@link PersonRepository}
 *
 * @since 09.04.2018
 */
@Service
@Transactional
public class PersonService {

    private final PersonRepository personRepository;
    private final ModelMapper modelMapper;

    @Autowired
    public PersonService(PersonRepository personRepository, ModelMapper modelMapper) {
        this.personRepository = personRepository;
        this.modelMapper = modelMapper;
    }

    /**
     * This method return a list of Persons
     *
     * @return
     */
    public List<PersonDto> findAll() {
        return modelMapper.map(personRepository.findAll(), new TypeToken<List<PersonDto>>() {
        }.getType());
    }

    /**
     * Method returns a Person by id
     *
     * @param id
     * @return
     */
    public Optional<PersonDto> findById(Long id) {
        Assert.notNull(id, "id can't be null");
        return personRepository
                .findById(id)
                .map(p -> modelMapper.map(p, PersonDto.class));

    }

    /**
     * This method delete person by id
     *
     * @param id
     */

    public Optional<PersonDto> deletePerson(Long id) {
        Assert.notNull(id, "id can't be null");
        Optional<Person> personOptional = personRepository.findById(id);
        personRepository.deleteById(id);
        return personOptional.map(p -> modelMapper.map(p, PersonDto.class));
    }

    /**
     * This method create new person
     *
     * @param personDto
     * @return
     */
    public void addPerson(PersonDto personDto) {
        Assert.notNull(personDto);
        Assert.notNull(personDto.getFirstName());
        personRepository.save(modelMapper.map(personDto, Person.class));
    }

    /**
     * This method update person by id
     *
     * @param id
     * @param personDto
     * @return
     */

    public void updatePersonById(long id, PersonDto personDto) throws NoSuchElementException {
        Assert.notNull(id, "id can't be null");
        Assert.notNull(personDto, "personDto can't be null");
        personRepository.findById(id)
                .map(person -> {
                    Person personEntity = personRepository.getOne(id);
                    personEntity.setFirstName(personDto.getFirstName());
                    personEntity.setLastName(personDto.getLastName());
                    personEntity.setLocation(personDto.getLocation());
                    personEntity.setEmail(personDto.getEmail());
                    personEntity.setRole(personDto.getRole());
                    personEntity.setStatus(personDto.getStatus());
                    return personRepository.save(personEntity);
                }).orElseThrow(NoSuchElementException::new);
    }

}

这是我的团队服务：

/**
 * This class have methods to manage teams
 *
 * @since 09.04.2018
 */
@Service
public class TeamService {

    private final TeamRepository teamRepository;
    private final ModelMapper modelMapper;

    @Autowired
    public TeamService(TeamRepository teamRepository, ModelMapper modelMapper) {
        this.teamRepository = teamRepository;
        this.modelMapper = modelMapper;
    }

    /**
     * This method return a list of teams
     *
     * @return list of Teams
     */
    public List<TeamDto> findAll() {
        return modelMapper.map(teamRepository.findAll(), new TypeToken<List<TeamDto>>() {
        }.getType());
    }

    /**
     * Method finds Team by id
     * 
     * @param id
     *            of team
     * @return Team object
     */
    public Optional<TeamDto> findTeamById(Long id) {
        Assert.notNull(id, "ID must exist ");
        return teamRepository
                .findById(id)
                .map(p -> modelMapper.map(p, TeamDto.class));
    }

    /**
     * Method update Team by id
     *
     * @param id
     *            of team
     * @param teamDto
     *            represent Team object
     */
    @Transactional
    public void updateTeamById(Long id, TeamDto teamDto) {
        Assert.notNull(id, "Id can't be null ! ");
        Assert.notNull(teamDto, "Object can't be null!");
        Assert.notNull(teamDto.getId(), "Passing id is required while updating an Object!");
        teamRepository.findById(id)
                .map(team -> {
                    Team teamEntity = teamRepository.getOne(id);
                    teamEntity.setId(teamDto.getId());
                    teamEntity.setName(teamDto.getName());
                    teamEntity.setCity(teamDto.getCity());
                    teamEntity.setDescription(teamDto.getDescription());
                    teamEntity.setHeadcount(teamDto.getHeadcount());
                    return teamRepository.save(teamEntity);
                }).orElseThrow(NoEntityFoundException::new);
    }

    /**
     * Method removes team from database
     * 
     * @param id
     *            of team
     */
    @Transactional
    public void deleteTeamById(Long id) {
        Assert.notNull(id, "Id can't be null !");
        try {
            teamRepository.deleteById(id);
        } catch (Exception e) {
            throw new IllegalStateException("Team with given id, does not exist ! ");
        }
    }

    /**
     * Method creates new Team
     * 
     * @param teamDto
     *            represent Team object
     */
    @Transactional
    public void createTeam(TeamDto teamDto) {
        Assert.notNull(teamDto, "Object can't be null!");
        try {
            Assert.notNull(teamDto.getName());
            teamRepository.save(modelMapper.map(teamDto, Team.class));
        } catch (Exception e) {
            throw new CreateEntityException();
        }
    }
}

也许有人在过去写过类似的事情来联系人与团队