Beispiel: N:M-Relationship mit Assoziationstabelle

Inhalt:

Aufbau des Beispieles

Definition der Relation als eigene Entity

import java.io.Serializable;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity()
public class KuchenZutatAssociationTableBean implements Serializable
{
  private Integer intKuchenId = null;
  private Integer intZutatId = null;
  
  @ManyToOne ()
  @Id
  @JoinColumn(name="KUCHENID"
  public KuchenAssociationTableBean getKuchen()
  {
    return this.kuchen;
  }

  public void setKuchen (KuchenAssociationTableBean kuchen)
  {
    this.kuchen = kuchen;
  }
  
  @ManyToOne ()
  @Id()
  @JoinColumn(name="ZUTATID")
  public ZutatAssociationTableBean getZutat()
  {
    return this.zutat;
  }

  public void setZutat (ZutatAssociationTableBean zutat)
  {
    this.zutat = zutat;
  }
}

import java.io.Serializable;

public class KuchenZutatPK implements Serializable
{
  private static final long serialVersionUID = 1L;

  private Integer kuchen = null;
  private Integer zutat = null;

  public Integer getKuchen()
  {
    return this.kuchen;
  }
  
  public void setKuchen(Integer int_KuchenId)
  {
    this.kuchen = int_KuchenId;
  }

  public Integer getZutat()
  {
    return this.zutat;
  }

  public void setZutat(Integer int_ZutatId)
  {
    this.zutat = int_ZutatId;
  }

  @Override
  public boolean equals(Object o)
  {
    if (o == this)
    {
      return true;
    }
    if (!(o instanceof KuchenZutatPK))
    {
      return false;
    }
    KuchenZutatPK other = (KuchenZutatPK) o;
    return true && (getKuchen() == null ? other.getKuchen() == null : getKuchen().equals(other.getKuchen()))
        && (getZutat() == null ? other.getZutat() == null : getZutat().equals(other.getZutat()));
  }

  @Override
  public int hashCode()
  {
    final int prime = 31;
    int result = 1;
    result = prime * result + (getKuchen() == null ? 0 : getKuchen().hashCode());
    result = prime * result + (getZutat() == null ? 0 : getZutat().hashCode());
    return result;
  }
}

import jakarta.persistence.IdClass;

@Entity()
@IdClass(value=KuchenZutatPK.class)
public class KuchenZutatAssociationTableBean implements Serializable
{
  ...

@Entity()
public class KuchenAssociationTableBean implements Serializable
{
  ...
  private Collection<KuchenZutatAssociationTableBean> collKuchenZutaten = new ArrayList<KuchenZutatAssociationTableBean>();
  ...
  @OneToMany(mappedBy="kuchen", cascade={CascadeType.ALL}, fetch=FetchType.LAZY)
  public Collection<KuchenZutatAssociationTableBean> getZutaten()
  {
    return this.collKuchenZutaten;
  }
  
  public void setZutaten (Collection<KuchenZutatAssociationTableBean> coll_KuchenZutaten)
  {
    this.collKuchenZutaten = coll_KuchenZutaten;
  }
  ...
}

@Entity()
public class ZutatAssociationTableBean implements Serializable
{
  ...
  private Collection<KuchenZutatAssociationTableBean> collKuchenVerknuepfungen = new ArrayList<KuchenZutatAssociationTableBean>();
  ...
  @OneToMany(mappedBy="zutat", cascade={CascadeType.ALL}, fetch=FetchType.LAZY)
  public Collection<KuchenZutatAssociationTableBean> getKuchen()
  {
    return this.collKuchenVerknuepfungen;
  }
  
  public void setKuchen (Collection<KuchenZutatAssociationTableBean> coll_KuchenVerknuepfungen)
  {
    this.collKuchenVerknuepfungen = coll_KuchenVerknuepfungen;
  }
  ...
}

Anlegen der Session Bean "KuchenZutatAssociationTableWorkerBean"

  public void addZutatToKuchen (Integer intKuchenId, Integer intZutatId, String strMenge)
  {
    //Kuchen und Zutat laden:
    //Es wird "getReference" verwendet, um eine Exception zu provozieren falls kein Datensatz gefunden wird.
    KuchenAssociationTableBean kuchen = this.entityManager.getReference(KuchenAssociationTableBean.class, intKuchenId );
    ZutatAssociationTableBean zutat = this.entityManager.getReference(ZutatAssociationTableBean.class, intZutatId );
    
    //Neues Mapping erzeugen:
    KuchenZutatAssociationTableBean kuchen2Zutat = new KuchenZutatAssociationTableBean();
    kuchen2Zutat.setZutat(zutat);
    kuchen2Zutat.setKuchen(kuchen);
    kuchen2Zutat.setMenge(strMenge);
    
    //Jetzt BEIDEN Seiten des Mappings zufügen!
    //Würde man das nicht tun, gäbe es zwar keinen Fehler, aber es würde auch nix
    //in die Datenbank gespeichert!
    kuchen.getZutaten().add(kuchen2Zutat);
    zutat.getKuchen().add(kuchen2Zutat);
    
    //Und eine Seite des Mappings speichern (hier dürfen wir "persist" nehmen, da alle beteiligten Entities
    //unter Kontrolle des Persistence-Managers sind, "merge" ist nicht nötig).
    this.entityManager.persist(kuchen);
  }

 
  public void removeZutatFromKuchen (Integer intKuchenId, Integer intZutatId)
  {
    //Aus Kuchen und Zutat einen PK zusammenbasteln:
    KuchenZutatPK kuchenZutatPK = new KuchenZutatPK();
    kuchenZutatPK.setKuchen(intKuchenId);
    kuchenZutatPK.setZutat(intZutatId);
    
    //Mapping laden:
    KuchenZutatAssociationTableBean kuchen2Zutat = this.entityManager.getReference(KuchenZutatAssociationTableBean.class, kuchenZutatPK);
    
    //Killen:
    this.entityManager.remove (kuchen2Zutat);

  }

Anlegen des Webclients

Blick in die Datenbank

In der Datenbank sieht das so aus (mit rotem Rahmen markiert ist die Tabelle der Relation):

Im rechten Teil des Screenshots sind die Inhalte aller drei beteiligten Tabellen dargestellt.

Für die Tabelle "kuchenzutatassociationtablebean" sind außer dem Primary Key auch zwei Foreign Keys angezeigt.

Alternative: @jakarta.persistence.EmbeddedId

• Die Primary-Key-Klasse KuchenZutatPK erhält die Annotation @jakarta.persistence.Embeddable.

  import jakarta.persistence.Column;
  import jakarta.persistence.Embeddable;
    
  @Embeddable
  public class KuchenZutatPK implements Serializable
  {
    private Integer zutatId = null;
    private Integer kuchenId = null;
  
    @Column(name="KUCHENID")
    public Integer getKuchenId()
    {
      return this.intKuchenId;
    }
   
    public void setKuchenId(Integer kuchenId)
    {
      this.kuchenId = kuchenId;
    }
  
    @Column(name="ZUTATID")
    public Integer getZutatId()
    {
      return this.intZutatId;
    }
  
    public void setZutatId(Integer zutatId)
    {
      this.zutatId = zutatId;
    }
  
    ...equals, hashCode...

  Außerdem müssen die @jakarta.persistence.Column-Annotations in diese Klasse geschoben werden!
  
  
• In der Entity KuchenZutatAssociationTableBean gibt es eine Membervariable vom Typ der Primary-Key-Klasse. Ihre Property wird mit der Annotation jakarta.persistence.EmbeddedId versehen:
  

  import jakarta.persistence.EmbeddedId;
  ...
    private KuchenZutatPK pk;
  
    @EmbeddedId
    @SuppressWarnings("unused")
    private KuchenZutatPK getPk()
    {
      return this.pk;
    }
  
    @SuppressWarnings("unused")
    private void setPk(KuchenZutatPK pk)
    {
      this.pk = pk;
    }

  Diese Property hat nur private getter/setter. Dadurch ergibt sich der angenehme Zustand, dass kein fremder Code darauf zugreifen konnte und deshalb keine Änderungen außerhalb der Entity Bean nötig sind (sprich: die Klasse kapselt ihre interne Implementierung des PK sauber).
  
  Nur im Setter von Kuchen und Zutat, wo im vorherigen Beispiel direkt die ID-Membervariable gesetzt werden konnte, muss der Code angepaßt werden: eventuell wird die PK-Klasse erzeugt, und die ID wird danach in diese geschrieben:

    public void setKuchen (KuchenAssociationTableBean kuchen)
    {
      this.kuchen = kuchen;
      
      //Kuchen-ID außerdem in Membervariable übernehmen. 
      //Eventuell wird PK-Klasse erzeugt:
      if (this.pk == null)
      {
        this.pk = new KuchenZutatPK();
      }
      //Für den Fall "NULL" wird die ID auf "NULL" gesetzt.
      if (kuchen != null)
      {
        this.pk.setKuchenId(kuchen.getId());
      }
      else
      {
        this.pk.setKuchenId(null);
      }
    }
    
    public void setZutat (ZutatAssociationTableBean zutat)
    {
      this.zutat = zutat;
      
      //Zutat-ID außerdem in Membervariable übernehmen.
      //Eventuell wird PK-Klasse erzeugt:
      if (this.pk == null)
      {
        this.pk = new KuchenZutatPK();
      }
      //Für den Fall "NULL" wird die ID auf "NULL" gesetzt.
      if (zutat != null)
      {
        this.pk.setZutatId(zutat.getId());
      }
      else
      {
        this.pk.setZutatId(null);
      }
    }

  
  Außerdem müssen hier die Relations-Annotations deklariert sein:
  

    @ManyToOne()
    @JoinColumn(name = "KUCHENID", insertable=false, updatable=false)
    public KuchenAssociationTableBean getKuchen()
    {
      return this.kuchen;
    }
  
    @ManyToOne()
    @JoinColumn(name = "ZUTATID", insertable=false, updatable=false)
    public ZutatAssociationTableBean getZutat()
    {
      return this.zutat;
    }

  Besonderheit ist hier die @jakarta.persistence.JoinColumn: Sie gibt an, welcher Name für die Fremdschlüsselfelder verwendet werden sollen. Hier steht der gleiche Wert wie in den @jakarta.persistence.Column-Annotations der EmbeddedId-Klasse. Machen wir das nicht und kommt es zu unterschiedlichen Feldnamen, würde der Server im ungünstigsten Fall vier Felder nach seiner Standard-Namenskonvention erzeugen ("KUCHEN_ID", "KUCHEN", "ZUTAT_ID" und "ZUTAT").
  Die Attribute "insertable" und "updateable" müssen auf "false" gesetzt werden, da der Server sonst eine Fehlermeldung spuckt: das Feld würde ansonsten zweimal beschrieben:
  

  Caused by: org.hibernate.MappingException: Column 'KUCHENID' is duplicated in mapping for entity 'de.hsrm.jakartaee.knauf.kuchenzutatassociationtable.KuchenZutatAssociationTableBean' (use '@Column(insertable=false, updatable=false)' when mapping multiple properties to the same column)
  	at org.hibernate@6.2.13.Final//org.hibernate.mapping.Value.checkColumnDuplication(Value.java:203)
  	at org.hibernate@6.2.13.Final//org.hibernate.mapping.MappingHelper.checkPropertyColumnDuplication(MappingHelper.java:249)
  	at org.hibernate@6.2.13.Final//org.hibernate.mapping.PersistentClass.checkColumnDuplication(PersistentClass.java:1071)
  	at org.hibernate@6.2.13.Final//org.hibernate.mapping.PersistentClass.validate(PersistentClass.java:755)
  	at org.hibernate@6.2.13.Final//org.hibernate.mapping.RootClass.validate(RootClass.java:288)
  	at org.hibernate@6.2.13.Final//org.hibernate.boot.internal.MetadataImpl.validate(MetadataImpl.java:497)
  	at org.hibernate@6.2.13.Final//org.hibernate.internal.SessionFactoryImpl.(SessionFactoryImpl.java:251)
  	at org.hibernate@6.2.13.Final//org.hibernate.boot.internal.SessionFactoryBuilderImpl.build(SessionFactoryBuilderImpl.java:444)
  	at org.hibernate@6.2.13.Final//org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.build(EntityManagerFactoryBuilderImpl.java:1458)
  	... 12 more
  	
  
    

• In der WorkerBean sieht die Methode "addZutatToKuchen" noch genauso aus wie im letzten Beispiel: da mein Code den Primärschlüssel nur mit privaten gettern und settern versehen hat, werden hier direkt die Methoden "setKuchen" und "setZutat" aufgerufen, statt die EmbeddedId-Klasse zu erzeugen und in "KuchenZutatAssociationTableBean" zu setzen:
  

    public void addZutatToKuchen (Integer intKuchenId, Integer intZutatId,
        String strMenge)
    {
      KuchenAssociationTableBean kuchen = this.entityManager.getReference(KuchenAssociationTableBean.class, intKuchenId );
      ZutatAssociationTableBean zutat = this.entityManager.getReference(ZutatAssociationTableBean.class, intZutatId );
  
      KuchenZutatAssociationTableBean kuchen2Zutat = new KuchenZutatAssociationTableBean();
      kuchen2Zutat.setKuchen(kuchen);
      kuchen2Zutat.setZutat(zutat);
      kuchen2Zutat.setMenge(strMenge);
  
      kuchen.getZutaten().add(kuchen2Zutat);
      zutat.getKuchen().add(kuchen2Zutat);
  
      this.entityManager.persist(kuchen);
    }

Ohne Annotations

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="https://jakarta.ee/xml/ns/persistence/orm"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence/orm https://jakarta.ee/xml/ns/persistence/orm/orm_3_1.xsd"
	version="3.1">
	<named-query name="findAllKuchen">
		<query>select o from KuchenAssociationTableBean o</query>
	</named-query>
	<named-query name="findAllZutaten">
		<query>select o from ZutatAssociationTableBean o</query>
	</named-query>

	<entity class="de.hsrm.jakartaee.knauf.kuchenzutatassociationtable.KuchenAssociationTableBean" access="PROPERTY"
		metadata-complete="true">
		<attributes>
			<id name="id">
				<generated-value />
			</id>
			<basic name="name">
			</basic>
			<one-to-many name="zutaten" mapped-by="kuchen" fetch="LAZY"
				target-entity="de.hsrm.jakartaee.knauf.knauf.kuchenzutatassociationtable.KuchenZutatAssociationTableBean">
				<cascade>
					<cascade-all/>
				</cascade>
			</one-to-many>
		</attributes>
	</entity>

	<entity class="de.hsrm.jakartaee.knauf.kuchenzutatassociationtable.ZutatAssociationTableBean" access="PROPERTY"
		metadata-complete="true">
		<attributes>
			<id name="id">
				<generated-value />
			</id>
			<basic name="zutatName">
			</basic>
			<one-to-many name="kuchen" mapped-by="zutat" fetch="LAZY"
				target-entity="de.hsrm.jakartaee.knauf.kuchenzutatassociationtable.KuchenZutatAssociationTableBean">
				<cascade>
					<cascade-all/>
				</cascade>
			</one-to-many>
		</attributes>
	</entity>
	
	<entity class="de.hsrm.jakartaee.knauf.kuchenzutatassociationtable.KuchenZutatAssociationTableBean" access="PROPERTY"
		metadata-complete="true">
		<id-class class="de.hsrm.jakartaee.knauf.kuchenzutatassociationtable.KuchenZutatPK"/>
		<attributes>
			<basic name="menge">
			</basic>
			
			<many-to-one name="kuchen" id="true"
				target-entity="de.hsrm.jakartaee.knauf.kuchenzutatassociationtable.KuchenAssociationTableBean">
				
				<join-column name="KUCHENID"/>
			</many-to-one>
			
			<many-to-one name="zutat" id="true"
				target-entity="de.hsrm.jakartaee.knauf.kuchenzutatassociationtable.ZutatAssociationTableBean">
				<join-column name="ZUTATID" />
			</many-to-one>
		</attributes>
	</entity>
</entity-mappings>