La programmation d'un un-à-plusieurs relations

Il n'y a pas 100% infaillible moyen de maintenir l'intégrité.

L'approche qui est généralement adoptée consiste à utiliser une méthode pour construire la relation et de construire le sens d'autres dans la même méthode. Mais, comme vous le dites, cela ne veut pas garder quelqu'un de jouer avec elle.

La prochaine étape serait de faire certaines des méthodes du package accessible, de sorte qu'au moins un code qui n'a rien à voir avec les vôtres ne peut pas le casser:

class Parent {

  private Collection<Child> children;

  //note the default accessibility modifiers
  void addChild(Child) {
    children.add(child);
  }

  void removeChild(Child) {
    children.remove(child);
  }
}

class Child {

   private Parent parent;
   public void setParent(Parent parent){
     if (this.parent != null)
       this.parent.removeChild(this);
     this.parent = parent;
     this.parent.addChild(this);
   }
}

En réalité, vous n'aurez pas souvent le modèle de cette relation dans vos classes. Au lieu de cela, vous allez chercher tous les enfants d'un parent dans une sorte de référentiel.

OriginalL'auteur Joeri Hendrickx

Vous pouvez vous assurer qu'il n'y a pas de doublons à l'aide d'un Ensemble mise en œuvre comme HashSet au lieu d'utiliser d'autres structures de données.
Et au lieu d'ajouter Travail à un client, créer une finale intérieure de la classe dans la catégorie d'Emplois a constructeur privé. Que de s'assurer que l'enveloppe intérieure ne peut être créé que par un objet de la tâche. Vous faire de l'Emploi constructeur de prendre en jobID et le client en tant que paramètre. Pour maintenir la cohérence,- si le client est Null jeter l'Exception en tant que mannequin d'emplois ne devrait pas être créée .

Dans ajouter méthode de la Clientèle, vérifier pour voir si le Travail enveloppé par JobUnit a le même ID de client comme son propre id, si ce n'est jeter l'Exception.

Lors du remplacement d'un client en classe d'Emploi retirer la JobUnit à l'aide de la méthode fournie par le Client de la classe et d'ajouter lui-même à la nouvelle clientèle et de modifier le client de référence pour le nouvellement adoptée à la clientèle.
De cette façon, vous pouvez raisonner avec votre code mieux.

Voici ce que votre client de classe pourrait ressembler.

public class Customer {

    Set<JobUnit> jobs=new HashSet<JobUnit>();    
    private Long id;
    public Customer(Long id){        
        this.id = id;
    }

    public boolean add(JobUnit unit) throws Exception{
       if(!unit.get().getCustomer().id.equals(id))
           throw new Exception(" cannot assign job to this customer");
        return jobs.add(unit);
    }

     public boolean remove(JobUnit unit){
        return jobs.remove(unit);
    }

    public Long getId() {
        return id;
    }

}

Et la Classe d'Emploi:

public class Job {
Customer customer;
private Long id;

final JobUnit unité;

public Job(Long id,Customer customer) throws Exception{
    if(customer==null)
        throw new Exception("Customer cannot be null");
    this.customer = customer; 
   unit= new JobUnit(this);       
    this.customer.add(unit);
}

public void replace(Customer c) throws Exception{      
    this.customer.remove(unit);
    c.add(unit);
    this.customer=c;
}

public Customer getCustomer(){
    return customer;
}

/**
 * @return the id
 */
public Long getId() {
    return id;
}

public final class JobUnit{
    private final Job j;


    private JobUnit(Job j){
        this.j = j;

    }
    public Job get(){
        return j;
    }
 }
}

Une chose, mais je suis curieux de savoir pourquoi avez-vous encore besoin d'ajouter des tâches à un client de l'objet?
Si vous souhaitez vérifier est de voir que le client a été assignée d'emploi, il suffit de l'inspection du Travail vous donnera cette information. En général j'essaie de ne pas créer des références circulaires, à moins inévitable.
Aussi en cas de remplacement d'un client à partir d'un emploi une fois qu'il a été créé n'est pas nécessaire, il suffit de faire le champ client Final dans le Travail de classe et de supprimer la méthode de ensemble ou remplacer.

La restriction de l'attribution de la clientèle pour un travail doit être maintenu dans la base de données et la saisie de données doit être utilisé comme un remède.
Comme pour l'ajout d'emplois à la clientèle qui ont été fait pour quelqu'un d'autre, vous pouvez vérifier pour référence client dans un travail pour s'assurer que le client pour lequel un travail est en cours d'ajout est le même que celui qu'elle détient ou encore mieux-simplement supprimer toute référence à la clientèle pour le Boulot et ça va simplifier les choses pour vous.

OriginalL'auteur anzaan

Faire un bon poseur-fonction qui permet de maintenir la cohérence. Par exemple, lorsque vous créez une tâche, vous devez fournir le client dans le constructeur. Le travail de constructeur, puis ajoute à la clientèle de la liste de tâches.
Ou chaque fois que vous ajoutez une tâche à un client, l'ajout d'une fonction pour vérifier que le travail du client est le client, c'est d'être ajoutés.
Ou une combinaison de cela et les choses semblables à ce qui convient à vos besoins.

OriginalL'auteur Matsemann

Je sais que c'est tard, mais je pense qu'un autre moyen pour cela serait de regarder le problème un peu différemment. Depuis le client détient une collection de tous les emplois attribués par ou réalisé pour un client, vous pourriez envisager de la catégorie d'emplois à une sous-classe de client avec des informations supplémentaires d'avoir toutes les tâches accomplies par le client. Ensuite, vous n'avez qu'à maintenir l'id du client dans la classe principale, et il serait héréditaire. Cette conception permettrait de s'assurer que chaque tâche peut être lié à un client. Aussi, si un client vous voulez savoir combien d'emplois sont présents que trop également être obtenu.

OriginalL'auteur prashant