JPA - Entität Relationships

Dieses Kapitel führt Sie durch die Beziehungen zwischen Entitäten. Im Allgemeinen sind die Beziehungen effektiver zwischen den Tabellen in der Datenbank. Hier werden die Entity-Klassen werden als relationale Tabellen (Konzept der JPA) behandelt werden, daher sind die Beziehungen zwischen Entität-Klassen wie folgt:

• @ viele zu ein relation
• @ein zu viele Relation
• @ein zu ein Relation
• @viele zu viele Relation

@viele zu ein Relation

viele zu ein Relation zwischen Entitäten existiert, wo ein Entitäten (Spalte oder set von Spalten) ist verwiesen mit einem anderen Entitäten (Spalte oder Spaltengruppe), haltigen die eindeutige Werte. In relationalen Datenbanken werden diese Beziehungen sind Angewandte durch unter Verwendung Fremdschlüssel / Primärschlüssel zwischen den Tabellen.

lassen Sie uns Betrachten ein Beispiel für einen relation zwischen Mitarbeiter-und Abteilungs Entitäten. In unidirektional Weise, dh, von Mitarbeiter zu Abteilung, Viele Zu Eine ist Beziehung anwendbar. Das bedeutet dass jeder Datensatz Von Mitarbeiter enthält eine Abteilung ID, die ein Primärschlüssel in der Tabelle Department sein sollte. Hier in der Employee-Tabelle, ist Abteilungs-ID des Fremdschlüssels.

Das folgende Diagramm zeigt die Viele-zu-Eine Verknüpfung zwischen den beiden Tabellen.

Erstellen Sie eine JPA-Projekt in Eclipse IDE mit dem Namen JPA_Eclipselink_MTO . Alle Module dieses Projektes werden im Folgenden erörtert.

Erstellen von Entitäten

Folgen Sie der oben angegebenen Diagramm für die Erstellung von Entitäten. Erstellen Sie ein Paket mit dem Namen 'com.tutorialspoin.eclipselink.entity' unter 'src' -Paket. Erstellen Sie eine Klasse mit dem Namen Department.java unter gegebenen Paket. Die Klasse Abteilung Unternehmen wird wie folgt dargestellt:

package com.howcodex.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Department 
{
   @Id 
   @GeneratedValue( strategy=GenerationType.AUTO )
   private int id;
   private String name;
   public int getId() 
   {
      return id;
   }
   public void setId(int id) 
   {
      this.id = id;
   }
    
   public String getName( )
   {
      return name;
   }
   public void setName( String deptName )
   {
      this.name = deptName;
   }
}

Erstellen Sie die zweite Einheit in dieser Beziehung - Mitarbeiter Entity-Klasse mit dem Namen Employee.java unter 'com.howcodex.eclipselink.entity' -Paket. Der Mitarbeiter Entity-Klasse wird wie folgt gezeigt:

package com.howcodex.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Employee 
{
   @Id
   @GeneratedValue( strategy= GenerationType.AUTO ) 
   private int eid;
   private String ename;
   private double salary;
   private String deg;
   @ManyToOne
   private Department department;
   public Employee(int eid, String ename, double salary, String deg) 
   {
      super( );
      this.eid = eid;
      this.ename = ename;
      this.salary = salary;
      this.deg = deg;
   }
   public Employee( ) 
   {
      super();
   }
   public int getEid( ) 
   {
      return eid;
   }
   public void setEid(int eid)  
   {
      this.eid = eid;
   }
   public String getEname( ) 
   {
      return ename;
   }
   public void setEname(String ename) 
   {
      this.ename = ename;
   }
   public double getSalary( ) 
   {
      return salary;
   }
   public void setSalary(double salary) 
   {
      this.salary = salary;
   }
   public String getDeg( ) 
   {
      return deg;
   }
   public void setDeg(String deg) 
   {
      this.deg = deg;
   }
   public Department getDepartment()
   {
      return department;
   }
   public void setDepartment(Department department)
   {
      this.department = department;
   }
}

Persistence.xml

persistence.xml Datei ist erforderlich, um die Datenbank und die Registrierung von Entity-Klassen konfigurieren.

Persitence.xml wird von der Eclipse-IDE erstellt werden während der Erstellung einer JPA-Projekt. Die Konfigurationsdetails sind Spezifikationen. Die persistence.xml Datei ist wie folgt dargestellt:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             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_2_0.xsd">
   <persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
   <class>com.howcodex.eclipselink.entity.Employee</class>
   <class>com.howcodex.eclipselink.entity.Department</class>
      <properties>
         <property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
         <property name="javax.persistence.jdbc.user" value="root"/>
         <property name="javax.persistence.jdbc.password"
                            value="root"/>
         <property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
         <property name="eclipselink.logging.level" value="FINE"/>
         <property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
      </properties>
   </persistence-unit>
</persistence>

Service-Klassen

Dieses Modul enthält die Service-Klassen, die den relationalen Teil mit dem Attribut Initialisierung implementiert. Erstellen Sie ein Paket unter 'src' -Paket mit dem Namen 'com.howcodex.eclipselink.service' . Die DAO-Klasse mit dem Namen ManyToOne.java ist unter den gegebenen Paket erstellt. Die DAO-Klasse wird wie folgt dargestellt:

package com.howcodexeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.howcodex.eclipselink.entity.Department;
import com.howcodex.eclipselink.entity.Employee;

public class ManyToOne 
{
   public static void main( String[ ] args ) 
   {
      EntityManagerFactory emfactory = Persistence.
      createEntityManagerFactory( "Eclipselink_JPA" );
      EntityManager entitymanager = emfactory.
      createEntityManager( );
      entitymanager.getTransaction( ).begin( );

      //Create Department Entity
      Department department = new Department();
      department.setName("Development");

      //Store Department
      entitymanager.persist(department);

      //Create Employee1 Entity
      Employee employee1 = new Employee();
      employee1.setEname("Satish");
      employee1.setSalary(45000.0);
      employee1.setDeg("Technical Writer");
      employee1.setDepartment(department);

      //Create Employee2 Entity
      Employee employee2 = new Employee();
      employee2.setEname("Krishna");
      employee2.setSalary(45000.0);
      employee2.setDeg("Technical Writer");
      employee2.setDepartment(department);

      //Create Employee3 Entity
      Employee employee3 = new Employee();
      employee3.setEname("Masthanvali");
      employee3.setSalary(50000.0);
      employee3.setDeg("Technical Writer");
      employee3.setDepartment(department);

      //Store Employees
      entitymanager.persist(employee1);
      entitymanager.persist(employee2);
      entitymanager.persist(employee3);

      entitymanager.getTransaction().commit();
      entitymanager.close();
      emfactory.close();
   }
}

Nach dem Kompilieren und Ausführen des obigen Programms, werden Sie Meldungen auf der Konsole Panel von Eclipse-IDE zu bekommen. Für die Ausgabe überprüfen MySQL Workbench. In diesem Beispiel werden zwei Tabellen erstellt.

Übergeben Sie die folgende Abfrage in MySQL-Schnittstelle und das Ergebnis von Abteilung Tabelle wird wie folgt angezeigt werden:

Select * from department

Pass the following query in MySQL interface and the result of Employee table will be displayed as follows.

Select * from employee

In der obigen Tabelle Deparment_Id ist der Fremdschlüssel (Referenzfeld) aus der Abteilung Tisch.

@Ein zu Viele Relation

In dieser Beziehung, jede Zeile Von eine Entität ist zu vielen untergeordneten Datensätzen in anderen Entität verwiesen. Das Wichtigste ist, dass die Kinder Datensätzen können nicht haben mehrere Eltern. In einer Eins-zu-viele-Beziehung zwischen Tabelle A und Tabelle B, kann jeder Zeile in Tabelle A verknüpft eine oder mehrere Zeilen in der Tabelle B werden.

lassen Sie uns Betrachten wir das obige Beispiel. Angenommen, Mitarbeiter-und Department-Tabellen in dem obigen Beispiel werden in umgekehrter unidirektionale Weise verbunden, dann wird das Verhältnis eins-zu-Viele Verknüpfung. Erstellen Sie eine JPA-Projekt in Eclipse IDE mit dem Namen JPA_Eclipselink_OTM . Alle Module dieses Projektes werden im Folgenden erörtert.

Erstellen von Entitäten

Folgen Sie der oben angegebenen Diagramm für die Erstellung von Entitäten. Erstellen Sie ein Paket mit dem Namen 'com.tutorialspoin.eclipselink.entity' unter 'src' -Paket. Erstellen Sie eine Klasse mit dem Namen Department.java unter gegebenen Paket. Die Klasse Abteilung Unternehmen wird wie folgt dargestellt:

package com.howcodex.eclipselink.entity;

import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;

@Entity
public class Department 
{
   @Id 
   @GeneratedValue( strategy=GenerationType.AUTO )
   private int id;
   private String name;
   @OneToMany( targetEntity=Employee.class )
   private List employeelist;
   public int getId() 
   {
      return id;
   }
    
   public void setId(int id) 
   {
      this.id = id;
   }
    
   public String getName( )
   {
     	return name;
   }
    
   public void setName( String deptName )
   {
     	this.name = deptName;
   }

   public List getEmployeelist() 
   {
      return employeelist;
   }
   public void setEmployeelist(List employeelist) 
   {
      this.employeelist = employeelist;
   }
}

Erstellen Sie die zweite Einheit in dieser Beziehung -Employee Entity-Klasse, mit dem Namen Employee.java unter 'com.howcodex.eclipselink.entity' -Paket. Der Mitarbeiter Entity-Klasse wird wie folgt dargestellt:

package com.howcodex.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee 
{
   @Id
   @GeneratedValue( strategy= GenerationType.AUTO ) 
   private int eid;
   private String ename;
   private double salary;
   private String deg;

   public Employee(int eid, String ename, double salary, String deg) 
   {
      super( );
      this.eid = eid;
      this.ename = ename;
      this.salary = salary;
      this.deg = deg;
   }

   public Employee( ) 
   {
      super();
   }

   public int getEid( ) 
   {
      return eid;
   }
   public void setEid(int eid)  
   {
      this.eid = eid;
   }

   public String getEname( ) 
   {
      return ename;
   }
   public void setEname(String ename) 
   {
      this.ename = ename;
   }

   public double getSalary( ) 
   {
      return salary;
   }
   public void setSalary(double salary) 
   {
      this.salary = salary;
   }

   public String getDeg( ) 
   {
      return deg;
   }
   public void setDeg(String deg) 
   {
      this.deg = deg;
   }
}

Persistence.xml

Die persistence.xml Datei ist wie folgt:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             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_2_0.xsd">
   <persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
   <class>com.howcodex.eclipselink.entity.Employee</class>
   <class>com.howcodex.eclipselink.entity.Department</class>
      <properties>
         <property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
         <property name="javax.persistence.jdbc.user" value="root"/>
         <property name="javax.persistence.jdbc.password" 
                            value="root"/>
         <property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
         <property name="eclipselink.logging.level" value="FINE"/>
         <property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
      </properties>
   </persistence-unit>
</persistence>

Service-Klassen

Dieses Modul enthält die Service-Klassen, die den relationalen Teil mit dem Attribut Initialisierung implementiert. Erstellen Sie ein Paket unter 'src' -Paket mit dem Namen 'com.howcodex.eclipselink.service' . Die DAO-Klasse mit dem Namen OneToMany.java ist unter den gegebenen Paket erstellt. Die DAO-Klasse wird wie folgt dargestellt:

package com.howcodexeclipselink.service;

import java.util.List;
import java.util.ArrayList;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.howcodex.eclipselink.entity.Department;
import com.howcodex.eclipselink.entity.Employee;

public class OneToMany 
{
   public static void main(String[] args) 
   {
      EntityManagerFactory emfactory = Persistence.
      createEntityManagerFactory( "Eclipselink_JPA" );
      EntityManager entitymanager = emfactory.
      createEntityManager( );
      entitymanager.getTransaction( ).begin( );

      //Create Employee1 Entity
      Employee employee1 = new Employee();
      employee1.setEname("Satish");
      employee1.setSalary(45000.0);
      employee1.setDeg("Technical Writer");

      //Create Employee2 Entity
      Employee employee2 = new Employee();
      employee2.setEname("Krishna");
      employee2.setSalary(45000.0);
      employee2.setDeg("Technical Writer");

      //Create Employee3 Entity
      Employee employee3 = new Employee();
      employee3.setEname("Masthanvali");
      employee3.setSalary(50000.0);
      employee3.setDeg("Technical Writer");

      //Store Employee
      entitymanager.persist(employee1);
      entitymanager.persist(employee2);
      entitymanager.persist(employee3);

      //Create Employeelist
      List<Employee> emplist = new ArrayList();
      emplist.add(employee1);
      emplist.add(employee2);
      emplist.add(employee3);

      //Create Department Entity
      Department department= new Department();
      department.setName("Development");
      department.setEmployeelist(emplist);

      //Store Department
      entitymanager.persist(department);

      entitymanager.getTransaction().commit();
      entitymanager.close();
      emfactory.close();
   }
}

Nach der Kompilierung und Ausführung des oben genannten Programms werden Sie Meldungen in der Konsole Panel von Eclipse-IDE zu bekommen. Für die Ausgabe überprüfen MySQL Workbench wie folgt.

In diesem Projekt drei Tabellen angelegt. Übergeben Sie die folgende Abfrage in MySQL-Schnittstelle und das Ergebnis der department_employee Tabelle wird angezeigt, wie folgt:

Select * from department_Id;

In der obigen Tabelle, deparment_id und employee_id sind die Fremdschlüssel (Referenzfelder) aus Abteilung und Mitarbeiter Tabellen.

Übergeben Sie die folgende Abfrage in MySQL-Schnittstelle und das Ergebnis der Abteilungstabelle wird in einer Tabelle angezeigt werden wie folgt.

Select * from department;

Übergeben Sie die folgende Abfrage in MySQL-Schnittstelle und das Ergebnis der Mitarbeitertabelle wird angezeigt wie folgt:

Select * from employee;

@ein zu ein Relation

In Eins-zu-eins-Beziehung, kann man Artikel mit nur einem anderen Artikel verknüpft werden. Es bedeutet, jede Zeile von einem Unternehmen auf eine und nur eine Zeile von einem anderen Unternehmen bezeichnet.

lassen Sie uns Betrachten wir das obige Beispiel. Mitarbeiter und Abteilung in umgekehrter unidirektional, ist die Beziehung One-To-One-Beziehung. Es bedeutet, jeder Mitarbeiter gehört nur einem Abteilung. Erstellen Sie eine JPA-Projekt in Eclipse IDE mit dem Namen JPA_Eclipselink_OTO . Alle Module dieses Projektes werden im Folgenden erörtert.

Erstellen von Entitäten

Folgen Sie der oben angegebenen Diagramm für die Erstellung von Entitäten. Erstellen Sie ein Paket mit dem Namen 'com.tutorialspoin.eclipselink.entity' unter 'src' -Paket. Erstellen Sie eine Klasse mit dem Namen Department.java unter gegebenen Paket. Die Klasse Abteilung Unternehmen wird wie folgt dargestellt:

package com.howcodex.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Department 
{
   @Id 
   @GeneratedValue( strategy=GenerationType.AUTO )
   private int id;
   private String name;
   public int getId() 
   {
      return id;
   }
    
   public void setId(int id) 
   {
      this.id = id;
   }
    
   public String getName( )
   {
      return name;
   }
    
   public void setName( String deptName )
   {
      this.name = deptName;
   }
}

Erstellen Sie die zweite Einheit in dieser Beziehung -Employee Entity-Klasse, mit dem Namen Employee.java unter 'com.howcodex.eclipselink.entity' -Paket. Der Mitarbeiter Entity-Klasse wird wie folgt dargestellt:

package com.howcodex.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Employee 
{
   @Id
   @GeneratedValue( strategy= GenerationType.AUTO ) 
   private int eid;
   private String ename;
   private double salary;
   private String deg;

   @OneToOne
   private Department department;

   public Employee(int eid, 
   String ename, double salary, String deg) 
   {
      super( );
      this.eid = eid;
      this.ename = ename;
      this.salary = salary;
      this.deg = deg;
   }

   public Employee( ) 
   {
      super();
   }

   public int getEid( ) 
   {
      return eid;
   }
   public void setEid(int eid)  
   {
      this.eid = eid;
   }

   public String getEname( ) 
   {
      return ename;
   }
   public void setEname(String ename) 
   {
      this.ename = ename;
   }

   public double getSalary( ) 
   {
      return salary;
   }
   public void setSalary(double salary) 
   {
      this.salary = salary;
   }

   public String getDeg( ) 
   {
      return deg;
   }
   public void setDeg(String deg) 
   {
      this.deg = deg;
   }

   public Department getDepartment() 
   {
      return department;
   }

   public void setDepartment(Department department) 
   {
      this.department = department;
   }
}

Persistence.xml

persistence.xml Datei wie folgt:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             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_2_0.xsd">
   <persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
   <class>com.howcodex.eclipselink.entity.Employee</class>
   <class>com.howcodex.eclipselink.entity.Department</class>
      <properties>
      <property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
         <property name="javax.persistence.jdbc.user" value="root"/>
         <property name="javax.persistence.jdbc.password" 
                            value="root"/>
         <property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
         <property name="eclipselink.logging.level" value="FINE"/>
         <property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
      </properties>
   </persistence-unit>
</persistence>

Service-Klassen

Erstellen Sie ein Paket unter 'src' -Paket mit dem Namen 'com.howcodex.eclipselink.service' . Die DAO-Klasse mit dem Namen OneToOne.java ist unter den gegebenen Paket erstellt. Die DAO-Klasse wird wie folgt dargestellt:

package com.howcodexeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.howcodex.eclipselink.entity.Department;
import com.howcodex.eclipselink.entity.Employee;

public class OneToOne 
{
   public static void main(String[] args) 
   {
      EntityManagerFactory emfactory = Persistence.
      createEntityManagerFactory( "Eclipselink_JPA" );
      EntityManager entitymanager = emfactory.
      createEntityManager( );
      entitymanager.getTransaction( ).begin( );

      //Create Department Entity
      Department department = new Department();
      department.setName("Development");

      //Store Department
      entitymanager.persist(department);

      //Create Employee Entity
      Employee employee = new Employee();
      employee.setEname("Satish");
      employee.setSalary(45000.0);
      employee.setDeg("Technical Writer");
      employee.setDepartment(department);

      //Store Employee
      entitymanager.persist(employee);

      entitymanager.getTransaction().commit();
      entitymanager.close();
      emfactory.close();
   }
}

Nach der Kompilierung und Ausführung des oben genannten Programms werden Sie Meldungen in der Konsole Panel von Eclipse-IDE zu bekommen. Für die Ausgabe überprüfen MySQL Workbench wie folgt.

Im obigen Beispiel werden zwei Tabellen erzeugt. Passieren die folgende Abfrage in MySQL-Schnittstelle und das Ergebnis der Abteilungstabelle wird wie folgt angezeigt werden:

Select * from department

Übergeben Sie die folgende Abfrage in MySQL-Schnittstelle und das Ergebnis von Mitarbeiter Tabelle wird wie folgt angezeigt werden:

Select * from employee

@viele zu viele Relation

Viele-zu-viele-Beziehung ist, wo eine oder mehrere Zeilen von einem Entität sind zugeordnet mit mehr als einer Zeile in anderen Entität.

lassen Sie unsBetrachten wir ein Beispiel einer Beziehung zwischen zwei Entitäten: Klasse und Lehrer . In bidirektional sowohl Klasse und Lehrer haben viele-zu-eins-Verhältnis. Das bedeutet, dass jeder Datensatz der Klasse wird von Lehrer-Set (Lehrer IDS), die Primärschlüssel in der Lehrertisch und in der Tabelle gespeichert Teacher_Class sollte und umgekehrt bezeichnet. Hier wird die Teachers_Class Tabelle enthält sowohl die Fremdschlüsselfelder. Erstellen Sie eine JPA-Projekt in Eclipse IDE mit dem Namen JPA_Eclipselink_MTM . Alle Module dieses Projektes werden im Folgenden erörtert.

Erstellen von Entitäten

Entitäten erstellen durch in der obigen Abbildung folgende Schema. Erstellen Sie ein Paket mit dem Namen 'com.tutorialspoin.eclipselink.entity' unter 'src' -Paket. Erstellen Sie eine Klasse mit dem Namen Clas.java unter gegebenen Paket. Die Klasse Abteilung Entitäten wird wie folgt dargestellt:

package com.howcodex.eclipselink.entity;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Clas 
{
   @Id
   @GeneratedValue( strategy = GenerationType.AUTO )
   private int cid;
   private String cname;

   @ManyToMany(targetEntity=Teacher.class)
   private Set teacherSet;

   public Clas() 
   {
      super();
   }
   public Clas(int cid, 
   String cname, Set teacherSet) 
   {
      super();
      this.cid = cid;
      this.cname = cname;
      this.teacherSet = teacherSet;
   }
   public int getCid() 
   {
      return cid;
   }
   public void setCid(int cid) 
   {
      this.cid = cid;
   }
   public String getCname() 
   {
      return cname;
   }
   public void setCname(String cname) 
   {
      this.cname = cname;
   }
   public Set getTeacherSet() 
   {
      return teacherSet;
   }
   public void setTeacherSet(Set teacherSet) 
   {
      this.teacherSet = teacherSet;
   }  
}

Erstellen Sie die zweite Einheit in dieser Beziehung -Employee Entity-Klasse, mit dem Namen Teacher.java unter 'com.howcodex.eclipselink.entity' -Paket. Der Mitarbeiter Entity-Klasse wird wie folgt dargestellt

package com.howcodex.eclipselink.entity;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Teacher 
{
   @Id
   @GeneratedValue( strategy = GenerationType.AUTO )
   private int tid;
   private String tname;
   private String subject;

   @ManyToMany(targetEntity=Clas.class)
   private Set clasSet;

   public Teacher() 
   {
      super();
   }
   public Teacher(int tid, String tname, String subject, Set clasSet)
   {
      super();
      this.tid = tid;
      this.tname = tname;
      this.subject = subject;
      this.clasSet = clasSet;
   }
   public int getTid() 
   {
      return tid;
   }
   public void setTid(int tid) 
   {
      this.tid = tid;
   }
   public String getTname() 
   {
      return tname;
   }
   public void setTname(String tname) 
   {
      this.tname = tname;
   }
   public String getSubject() 
   {
      return subject;
   }
   public void setSubject(String subject) 
   {
      this.subject = subject;
   }
   public Set getClasSet() 
   {
      return clasSet;
   }
   public void setClasSet(Set clasSet) 
   {
      this.clasSet = clasSet;
   }
}

Persistence.xml

persistence.xml Datei wie folgt:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             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_2_0.xsd">
   <persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
   <class>com.howcodex.eclipselink.entity.Employee</class>
   <class>com.howcodex.eclipselink.entity.Department</class>
      <properties>
         <property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
         <property name="javax.persistence.jdbc.user" value="root"/>
         <property name="javax.persistence.jdbc.password" 
                            value="root"/>
         <property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
         <property name="eclipselink.logging.level" value="FINE"/>
         <property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
      </properties>
   </persistence-unit>
</persistence>

Service-Klassen

Erstellen Sie ein Paket unter 'src' -Paket mit dem Namen 'com.howcodex.eclipselink.service' . Die DAO-Klasse mit dem Namen ManyToMany.java ist unter den gegebenen Paket erstellt. Die DAO-Klasse wird wie folgt dargestellt:

package com.howcodex.eclipselink.service;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.howcodex.eclipselink.entity.Clas;
import com.howcodex.eclipselink.entity.Teacher;

public class ManyToMany 
{
   public static void main(String[] args) 
   {
      EntityManagerFactory emfactory = Persistence.
      createEntityManagerFactory( "Eclipselink_JPA" );
      EntityManager entitymanager = emfactory.
      createEntityManager( );
      entitymanager.getTransaction( ).begin( );

      //Create Clas Entity
      Clas clas1=new Clas(0,"1st",null);
      Clas clas2=new Clas(0,"2nd",null);
      Clas clas3=new Clas(0,"3rd",null);

      //Store Clas
      entitymanager.persist(clas1);
      entitymanager.persist(clas2);
      entitymanager.persist(clas3);

      //Create Clas Set1
      Set<Clas> classSet1 = new HashSet();
      classSet1.add(clas1);
      classSet1.add(clas2);
      classSet1.add(clas3);

      //Create Clas Set2
      Set<Clas> classSet2 = new HashSet();
      classSet2.add(clas3);
      classSet2.add(clas1);
      classSet2.add(clas2);

      //Create Clas Set3
      Set<Clas> classSet3 = new HashSet();
      classSet3.add(clas2);
      classSet3.add(clas3);
      classSet3.add(clas1);

      //Create Teacher Entity
      Teacher teacher1 = new Teacher(0,
      "Satish","Java",classSet1);
      Teacher teacher2 = new Teacher(0,
      "Krishna","Adv Java",classSet2);
      Teacher teacher3 = new Teacher(0,
      "Masthanvali","DB2",classSet3);

      //Store Teacher
      entitymanager.persist(teacher1);
      entitymanager.persist(teacher2);
      entitymanager.persist(teacher3);

      entitymanager.getTransaction( ).commit( );
      entitymanager.close( );
      emfactory.close( );
   }
}

In diesem Beispiel-Projekt werden drei Tabellen erstellt. Übergeben Sie die folgende Abfrage in MySQL-Schnittstelle und das Ergebnis der teacher_clas Tabelle wird wie folgt angezeigt:

Select * form teacher_clas

In der obigen Tabelle teacher_tid ist der Fremdschlüssel von Lehrertisch und classet_cid ist der Fremdschlüssel von Klassentabelle. Daher verschiedene Lehrer an anderen Klasse zugeteilt.

Übergeben Sie die folgende Abfrage in MySQL-Schnittstelle und das Ergebnis der Lehrer Tabelle wird angezeigt, wie folgt:

Select * from teacher

Übergeben Sie die folgende Abfrage in MySQL-Schnittstelle und das Ergebnis von Clas Tabelle wird wie folgt angezeigt:

Select * from clas