Beispiel: N:M-Relationship zweiter Entity Beans

  @Entity()
  @NamedQuery(name="findAllKuchen", query="select o from KuchenNMBean o")
  public class KuchenNMBean implements Serializable
  {
    private static final long serialVersionUID = 1L;
  
    private Integer intId;
    private String strName;
  
    public KuchenNMBean()
    { 
    }
    
	@Column()
    @Id ()
    @GeneratedValue ()
    public Integer getId()
    {
      return this.intId;
    }
  
    public void setId(Integer int_Id)
    {
      this.intId = int_Id;
    }
    
    @Column()
    public String getName()
    {
      return this.strName;
    }
  
    public void setName(String str_Name)
    {
      this.strName = str_Name;
    }
  }

  @Entity()
  @NamedQuery(name="findAllZutaten", query="select o from ZutatNMBean o")
  public class ZutatNMBean implements Serializable
  {
    private static final long serialVersionUID = 1L;
  
    private Integer intId;
    private String strZutatName;
	
    public ZutatNMBean()
    { 
    }
    
	
    @Column()
    @Id ()
    @GeneratedValue ()
    public Integer getId()
    {
      return this.intId;
    }
  
    public void setId(Integer int_Id)
    {
      this.intId = int_Id;
    }
    
    @Column()
    public String getZutatName()
    {
      return this.strZutatName;
    }
  
    public void setZutatName(String str_ZutatName)
    {
      this.strZutatName = str_ZutatName;
    }
  }

  private Collection<ZutatBean> collZutaten = new ArrayList<ZutatBean>();

  @ManyToMany(mappedBy="kuchen", cascade={CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH}, fetch=FetchType.LAZY)
  public Collection<ZutatBean> getZutaten()
  {
    return this.collZutaten;
  }
  
  public void setZutaten (Collection<ZutatBean> coll_Zutaten)
  {
    this.collZutaten = coll_Zutaten;
  } 

  private Collection<KuchenBean> collKuchen = new ArrayList<KuchenBean>();

  @ManyToMany(cascade={CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH}, fetch=FetchType.LAZY)
  public Collection<KuchenBean> getKuchen()
  {
    return this.collKuchen;
  }
  
  public void setKuchen (Collection<KuchenBean> coll_Kuchen)
  {
    this.collKuchen = coll_Kuchen;
  } 

	<?xml version="1.0" encoding="UTF-8"?>
	<persistence xmlns="http://java.sun.com/xml/ns/persistence"
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
		version="1.0">
		<persistence-unit name="kuchenZutatNMPersistenceUnit">
			<jta-data-source>java:/DefaultDS</jta-data-source>
			<properties>
				<!-- Setzen dieser Property aktiviert das automatische Tabellen-Generieren und Löschen beim Deploy! -->
				<property name="hibernate.hbm2ddl.auto" value="create-drop" />
				<!-- SQL-Logging einschalten: -->
				<property name="hibernate.show_sql" value="true"></property>
			</properties>
		</persistence-unit>
	</persistence> 

  @Stateless
  public class KuchenZutatNMWorkerBean implements KuchenZutatNMWorkerLocal
  {
    @PersistenceContext(unitName="kuchenZutatNMPersistenceUnit")
    private EntityManager entityManager = null;

    public void saveKuchen (KuchenNMBean kuchen)
    {
      kuchen = this.entityManager.merge(kuchen);
    }
    
    public List<KuchenNMBean> getKuchen()
    {
      Query query = this.entityManager.createNamedQuery("findAllKuchen");
      List<KuchenNMBean> listKuchen = query.getResultList();
      return listKuchen;
    }
    
    public KuchenNMBean findKuchenById(Integer int_Id)
    {
      //Die Zutat im EntityManager laden.
      //Hier mit "find" arbeiten, da bei ungültiger ID "null" zurückkommen soll. 
      KuchenNMBean kuchen = this.entityManager.find(KuchenNMBean.class, int_Id);
    
      //Falls etwas gefunden wurde, dann die Relationship einlesen.
      if (kuchen != null)
      {
        //Da der FetchType der ManyToMany-Relation auf LAZY gesetzt ist müssen die Zutaten 
        //hier explizit abgerufen werden solange die KuchenNMBean noch nicht
        //detached ist. Später würde ansonsten ein Zugriff auf die Zutatenliste eine
        //Exception auslösen.
        Collection<ZutatNMBean> collZutaten = kuchen.getZutaten();
        //Wir müssen einen Zugriff auf die Collection selbst ausführen, Abrufen der Property alleine reicht nicht !
        logger.info ("Anzahl Zutaten: " + collZutaten.size());
      }
      
      return kuchen;
    }
    
    public void deleteKuchen (Integer intKuchenId)
    {
      //Den Kuchen im EntityManager laden.
      //Hier mit "getReference" arbeiten, damit eine böse EntityNotFoundException fliegt wenn Zutat nicht gefunden wird.
      KuchenNMBean kuchen = this.entityManager.getReference(KuchenNMBean.class, intKuchenId);
  
      //Jetzt wird es knifflig: wir müssen die Zutaten des Kuchens holen,
      //und aus den Kuchen-Collections der Zutaten den Kuchen entfernen.
      //Grund scheint zu sein dass der EntityManager ansonsten noch den
      //Kuchen in Zutaten hält und dabei in einen Fehlerzustand läuft.
      Collection listeZutaten = kuchen.getZutaten();
      Iterator iteratorZutat = listeZutaten.iterator();
      while (iteratorZutat.hasNext() == true) 
      {
        //Zutat wegwerfen:
        ZutatNMBean zutatVonKuchen = iteratorZutat.next();
        zutatVonKuchen.getKuchen().remove(kuchen);
      }
      
      //Jetzt löschen:
      this.entityManager.remove(kuchen);
    }
    
    public ZutatNMBean findZutatById(Integer int_Id)
    {
      ZutatNMBean zutat = this.entityManager.find(ZutatNMBean.class, int_Id);
      //Wenn nichts gefunden wurde, kommt hier "null" zurück.
      //Falls etwas gefunden wurde, dann die Relationship einlesen.
      if (zutat != null)
      {
        //Die Kuchen einmal abrufen solange die Bean unter
        //Container-Verwaltung ist.
        Collection<KuchenNMBean> collKuchen = zutat.getKuchen();
        //Wir müssen einen Zugriff auf die Collection selbst ausführen, Abrufen der Property alleine reicht nicht !
        logger.info ("Anzahl Kuchen: " + collKuchen.size());
      }
      
      return zutat;
    }
    
    public void deleteZutat (Integer intZutatId)
    {
      //Die Zutat im EntityManager laden.
      //Hier mit "getReference" arbeiten, damit eine böse EntityNotFoundException fliegt wenn Zutat nicht gefunden wird.
      ZutatNMBean zutat = this.entityManager.getReference(ZutatNMBean.class, intZutatId );
      
      //Jetzt wird es knifflig: wir müssen die Kuchen der Zutat holen,
      //und aus den Zutat-Collections der Kuchen die Zutat entfernen.
      //Grund scheint zu sein dass der EntityManager ansonsten noch die
      //Zutat im Kuchen hält und dabei in einen Fehlerzustand läuft.
      Collection<KuchenNMBean> listeKuchen = zutat.getKuchen();
      Iterator<KuchenNMBean> iteratorKuchen = listeKuchen.iterator();
      while (iteratorKuchen.hasNext() == true) 
      {
        //Zutat wegwerfen:
        KuchenNMBean kuchenMitZutat = iteratorKuchen.next();
        kuchenMitZutat.getZutaten().remove(zutat);
      }
  
      //Jetzt endlich dürfen wir die Zutat löschen.
      this.entityManager.remove(zutat);
    }
    
    public void saveZutat (ZutatNMBean zutat)
    {
      this.entityManager.merge(zutat);
    }
    
    public List<ZutatNMBean> getZutaten()
    {
      Query query = this.entityManager.createNamedQuery("findAllZutaten");
      
      List<ZutatNMBean> listZutaten = query.getResultList();
      return listZutaten;
    }
  } 

• Die Zutat muss der Zutatenliste des Kuchens zugefügt werden:
  kuchen.getZutaten().add(zutat);
• Der Kuchen muss der Kuchenliste der Zutat zugefügt werden:
  zutat.getKuchen().add(kuchen);

    public void addZutatToKuchen (Integer intKuchenId, Integer intZutatId)
    {
      //Kuchen und Zutat laden:
      //Es wird "getReference" verwendet, um eine Exception zu provozieren falls kein Datensatz gefunden wird.
      KuchenNMBean kuchen = this.entityManager.getReference(KuchenNMBean.class, intKuchenId );
      ZutatNMBean zutat = this.entityManager.getReference(ZutatNMBean.class, intZutatId );
      
      //Jetzt BEIDEN Seiten des Mappings zufügen !
      kuchen.getZutaten().add(zutat);
      zutat.getKuchen().add(kuchen);
      
      //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)
    {
      //Kuchen und Zutat laden:
      //Es wird "getReference" verwendet, um eine Exception zu provozieren falls kein Datensatz gefunden wird.
      KuchenNMBean kuchen = this.entityManager.getReference(KuchenNMBean.class, intKuchenId );
      ZutatNMBean zutat = this.entityManager.getReference(ZutatNMBean.class, intZutatId);
      
      //Jetzt in BEIDEN Seiten des Mappings entfernen !
      kuchen.getZutaten().remove(zutat);
      zutat.getKuchen().remove(kuchen);
      
      //Und eine Seite des Mappings speichern (hier dürfen wir "Persist" nehmen, da alle beteiligten Entities
      //unter Kontrolle des Persistence-Managers sind).
      this.entityManager.persist(kuchen);
    }	

• Im "findKuchenById" bzw. "findZutatById" gehe ich davon aus, dass hier eine ungültige ID übergeben werden kann, und gebe in diesem Fall null zurück. EntityManager.find(...) ist hier die Methode unserer Wahl, da diese keine Exception wirft.
  Ein Verwender muss natürlich höllisch aufpassen, dass hier kein null, und jeweils entsprechende Prüfungen einbauen. Das ist in den Clients dieses Beispiels allerdings noch nicht geschehen.
  
• Beim Löschen eines Kuchens/einer Zutat oder beim Verknüpfen von Kuchen und Zutat wäre es ein schwerer Fehler, wenn eines der beiden Objekte nicht gefunden wird. Deshalb verwende ich hier EntityManager.getReference(...), denn diese Methode wirft eine (unchecked) javax.persistence.EntityNotFoundException.

<ejb-local-ref>
	<ejb-ref-name>ejb/KuchenZutatNMWorkerLocal</ejb-ref-name>
	<ejb-ref-type>Entity</ejb-ref-type>
	<local>de.fhw.komponentenarchitekturen.knauf.kuchenzutatnm.KuchenZutatNMWorkerLocal</local>
</ejb-local-ref> 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jboss-web PUBLIC
	"-//JBoss//DTD Web Application 5.0//EN"
	"http://www.jboss.org/j2ee/dtd/jboss-web_5_0.dtd">
<jboss-web>
	<context-root>KuchenZutatNMWeb</context-root>
	<ejb-local-ref>
		<ejb-ref-name>ejb/KuchenZutatNMWorkerLocal</ejb-ref-name>
		<local-jndi-name>KuchenZutatNM/KuchenZutatNMWorkerBean/local</local-jndi-name>
	</ejb-local-ref>
</jboss-web>

<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar id="ejb-jar_ID" version="3.0"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                           http://java.sun.com/xml/ns/javaee/ejb-jar_3_0.xsd">
	<display-name>
	KuchenZutatNMEJB</display-name>
	
	<enterprise-beans>
		<session>
			<description>
				<![CDATA[Stateless Session Bean für das Arbeiten mit Kuchen und Zutaten.]]>
			</description>
			<display-name>KuchenZutatNMWorkerBean</display-name>
			<ejb-name>KuchenZutatNMWorkerBean</ejb-name>
			<business-local>de.fhw.komponentenarchitekturen.knauf.kuchenzutatnm.KuchenZutatNMWorkerLocal</business-local>
			<ejb-class>de.fhw.komponentenarchitekturen.knauf.kuchenzutatnm.KuchenZutatNMWorkerBean</ejb-class>
			<session-type>Stateless</session-type>
			<!--EntityManager-Injection -->
			<persistence-context-ref>
				<persistence-context-ref-name>KuchenZutatNMPersistenceUnitRef</persistence-context-ref-name>
				<persistence-unit-name>kuchenZutatNMPersistenceUnit</persistence-unit-name>
				<injection-target>
					<injection-target-class>
						de.fhw.komponentenarchitekturen.knauf.kuchenzutatnm.KuchenZutatNMWorkerBean
					</injection-target-class>
					<injection-target-name>entityManager</injection-target-name>
				</injection-target>
			</persistence-context-ref>
		</session>
	</enterprise-beans>
	
</ejb-jar>

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_1_0.xsd"
	version="1.0">
	<named-query name="findAllKuchen">
		<query>select o from KuchenNMBean o</query>
	</named-query>
	<named-query name="findAllZutaten">
		<query>select o from ZutatNMBean o</query>
	</named-query>

	<entity class="de.fhw.komponentenarchitekturen.knauf.kuchenzutatnm.KuchenNMBean" access="PROPERTY"
		metadata-complete="true">
		<attributes>
			<id name="id">
				<generated-value />
			</id>
			<basic name="name">
			</basic>
			<many-to-many name="zutaten" mapped-by="kuchen" fetch="LAZY"
				target-entity="de.fhw.komponentenarchitekturen.knauf.kuchenzutatnm.ZutatNMBean">
				<cascade>
					<cascade-persist />
					<cascade-merge />
					<cascade-refresh />
				</cascade>
			</many-to-many>
		</attributes>
	</entity>

	<entity class="de.fhw.komponentenarchitekturen.knauf.kuchenzutatnm.ZutatNMBean" access="PROPERTY"
		metadata-complete="true">
		<attributes>
			<id name="id">
				<generated-value />
			</id>
			<basic name="zutatName">
			</basic>
			<many-to-many name="kuchen" fetch="LAZY"
				target-entity="de.fhw.komponentenarchitekturen.knauf.kuchenzutatnm.KuchenNMBean">
				<cascade>
					<cascade-persist />
					<cascade-merge />
					<cascade-refresh />
				</cascade>
			</many-to-many>
		</attributes>
	</entity>
</entity-mappings>