JPA - Relazioni tra entità

Questo capitolo ti guida attraverso le relazioni tra le entità. Generalmente le relazioni sono più efficaci tra le tabelle nel database. Qui le classi di entità sono trattate come tabelle relazionali (concetto di JPA), quindi le relazioni tra le classi di entità sono le seguenti:

  • @ManyToOne Relation
  • @OneToMany Relation
  • @OneToOne Relation
  • @ManyToMany Relation

@ManyToOne Relation

Relazione molti-a-uno tra entità: dove un'entità (colonna o insieme di colonne) fa riferimento a un'altra entità (colonna o insieme di colonne) che contiene valori univoci. Nei database relazionali queste relazioni sono applicabili utilizzando la chiave esterna / chiave primaria tra le tabelle.

Consideriamo un esempio di relazione tra le entità Dipendente e Dipartimento. In modo unidirezionale, vale a dire dal dipendente al dipartimento, è applicabile la relazione molti a uno. Ciò significa che ogni record di dipendente contiene un ID reparto, che dovrebbe essere una chiave primaria nella tabella Dipartimento. Qui nella tabella Employee, l'ID reparto è la chiave esterna.

Il diagramma spiega la relazione molti-a-uno come segue:

Crea un progetto JPA in eclipse IDE denominato JPA_Eclipselink_MTO. Tutti i moduli di questo progetto sono mostrati come segue:

Creazione di entità

Segui il diagramma sopra indicato per creare entità. Crea un pacchetto denominato‘com.tutorialspoin.eclipselink.entity’ sotto ‘src’pacchetto. Crea una classe denominataDepartment.javasotto dato pacchetto. L'entità Department della classe viene visualizzata come segue:

package com.tutorialspoint.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;
   }
}

Crea la seconda entità in questa relazione: la classe di entità Employee denominata Employee.java sotto ‘com.tutorialspoint.eclipselink.entity’pacchetto. La classe di entità Employee viene mostrata come segue:

package com.tutorialspoint.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

Il file Persistence.xml è necessario per configurare il database e la registrazione delle classi di entità.

Persitence.xml verrà creato dall'IDE di eclipse durante la creazione di un progetto JPA. I dettagli di configurazione sono le specifiche dell'utente. Il file persistence.xml viene mostrato come segue:

<?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.tutorialspoint.eclipselink.entity.Employee</class>
      <class>com.tutorialspoint.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>

Classi di servizio

Questo modulo contiene le classi di servizio, che implementa la parte relazionale utilizzando l'inizializzazione dell'attributo. Crea un pacchetto in‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’. La classe DAO denominataManyToOne.javaviene creato in un determinato pacchetto. La classe DAO è mostrata come segue:

package com.tutorialspointeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.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();
   }
}

Dopo la compilazione e l'esecuzione del programma di cui sopra riceverai le notifiche nel pannello della console di Eclipse IDE. Per l'output, controlla MySQL workbench. In questo esempio vengono create due tabelle.

Passa la seguente query nell'interfaccia MySQL e il risultato di Department tabella in un formato tabulare è mostrata come segue nella query:

Select * from department;

Id	Name
101	Development

Passa la seguente query nell'interfaccia MySQL e il risultato di Employee tabella in un formato tabulare è mostrata come segue nella query:

Select * from employee;

Eid Deg                 Ename	        Salary	Department_Id
102 Technical Writer	Satish	        45000	101
103 Technical Writer	Krishna	        45000	101
104 Technical Writer	Masthan Wali	50000	101

Nella tabella precedente Deparment_Id è la chiave esterna (campo di riferimento) dalla tabella Department.

@OneToMany Relation

In questa relazione ogni riga di un'entità fa riferimento a molti record figlio in un'altra entità. La cosa importante è che i record figlio non possono avere più genitori. In una relazione uno-a-molti tra la tabella A e la tabella B, ogni riga nella tabella A è collegata a 0, 1 o più righe nella tabella B.

Consideriamo l'esempio sopra. SeEmployee e Departmentè in modo unidirezionale inverso, la relazione è relazione Molti-A-Uno. Crea un progetto JPA in eclipse IDE denominatoJPA_Eclipselink_OTM. Tutti i moduli di questo progetto sono mostrati come segue:

Creazione di entità

Segui il diagramma sopra indicato per creare entità. Crea un pacchetto denominato‘com.tutorialspoin.eclipselink.entity’ sotto ‘src’pacchetto. Crea una classe denominataDepartment.javasotto dato pacchetto. L'entità Department della classe viene visualizzata come segue:

package com.tutorialspoint.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;
   }
}

Crea la seconda entità in questa relazione -Classe di entità dipendente, denominata Employee.java sotto ‘com.tutorialspoint.eclipselink.entity’pacchetto. La classe di entità Employee viene mostrata come segue:

package com.tutorialspoint.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

Persistence.xml verrà creato dall'IDE eclipse durante la creazione di un progetto JPA. I dettagli di configurazione sono le specifiche dell'utente. Il file persistence.xml viene mostrato come segue:

<?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.tutorialspoint.eclipselink.entity.Employee</class>
      <class>com.tutorialspoint.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>

Classi di servizio

Questo modulo contiene le classi di servizio, che implementa la parte relazionale utilizzando l'inizializzazione dell'attributo. Crea un pacchetto in‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’. La classe DAO denominataOneToMany.javaviene creato in un determinato pacchetto. La classe DAO è mostrata come segue:

package com.tutorialspointeclipselink.service;

import java.util.List;
import java.util.ArrayList;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.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();
   }
}

Dopo la compilazione e l'esecuzione del programma di cui sopra riceverai le notifiche nel pannello della console di Eclipse IDE. Per l'output controllare il workbench MySQL come segue. In questo progetto vengono create tre tabelle.

Passa la seguente query nell'interfaccia MySQL e il risultato di department_employee tabella in un formato tabulare è mostrata come segue nella query:

Select * from department_Id;

Department_Id	Employee_Eid
254	        251
254	        252
254	        253

Nella tabella sopra, i campi deparment_id e dipendente_id sono le chiavi esterne (campi di riferimento) dalle tabelle reparto e dipendente.

Passa la seguente query nell'interfaccia MySQL e il risultato della tabella di reparto in formato tabulare viene mostrato come segue nella query:

Select * from department;

Id	Name
254	Development

Passa la seguente query nell'interfaccia MySQL e il risultato della tabella dei dipendenti in formato tabulare viene mostrato come segue nella query:

Select * from employee;

Eid	Deg	                Ename	       Salary
251	Technical Writer	Satish	       45000
252	Technical Writer	Krishna	       45000
253	Technical Writer	Masthanvali    50000

@OneToOne Relation

Nella relazione uno-a-uno, un elemento può appartenere solo a un altro elemento. Significa che ogni riga di un'entità è riferita a una e solo una riga di un'altra entità.

Consideriamo l'esempio sopra. Employee e Departmentin modo unidirezionale inverso, la relazione è una relazione uno-a-uno. Significa che ogni dipendente appartiene a un solo dipartimento. Crea un progetto JPA in eclipse IDE denominatoJPA_Eclipselink_OTO. Tutti i moduli di questo progetto sono mostrati come segue:

Creazione di entità

Segui il diagramma sopra indicato per creare entità. Crea un pacchetto denominato‘com.tutorialspoin.eclipselink.entity’ sotto ‘src’pacchetto. Crea una classe denominataDepartment.javasotto dato pacchetto. L'entità Department della classe viene visualizzata come segue:

package com.tutorialspoint.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;
   }
}

Crea la seconda entità in questa relazione -Classe di entità dipendente, denominata Employee.java sotto ‘com.tutorialspoint.eclipselink.entity’pacchetto. La classe di entità Employee viene mostrata come segue:

package com.tutorialspoint.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 verrà creato dall'IDE eclipse durante la creazione di un progetto JPA. I dettagli di configurazione sono le specifiche dell'utente. Il file persistence.xml viene mostrato come segue:

<?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.tutorialspoint.eclipselink.entity.Employee</class>
      <class>com.tutorialspoint.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>

Classi di servizio

Questo modulo contiene le classi di servizio, che implementa la parte relazionale utilizzando l'inizializzazione dell'attributo. Crea un pacchetto in‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’. La classe DAO denominataOneToOne.javaviene creato nel pacchetto specificato. La classe DAO è mostrata come segue:

package com.tutorialspointeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.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();
   }
}

Dopo la compilazione e l'esecuzione del programma di cui sopra riceverai le notifiche nel pannello della console di Eclipse IDE. Per l'output, controlla il workbench MySQL come segue. Nell'esempio precedente vengono create due tabelle.

Passa la seguente query nell'interfaccia MySQL e il risultato di department tabella in un formato tabulare è mostrata come segue nella query:

Select * from department

Id	Name
301	Development

Passa la seguente query nell'interfaccia MySQL e il risultato di employee tabella in un formato tabulare è mostrata come segue nella query:

Select * from employee

Eid	Deg	                Ename	Salary	Department_id
302	Technical Writer	Satish	45000	301

@ManyToMany Relation

La relazione molti-a-molti è dove una o più righe di un'entità sono associate a più righe in un'altra entità.

Consideriamo un esempio di relazione tra le entità Classe e Insegnante. In modo bidirezionale, sia la classe che l'insegnante hanno una relazione molti-a-uno. Ciò significa che ogni record di Classe viene indicato dal set Insegnante (ID insegnante), che dovrebbe essere chiavi primarie nella tabella Insegnante e memorizzato nella tabella Insegnante_Classe e viceversa. Qui, la tabella Teachers_Class contiene entrambi i campi chiave esterni. Crea un progetto JPA in eclipse IDE denominatoJPA_Eclipselink_MTM. Tutti i moduli di questo progetto sono mostrati come segue:

Creazione di entità

Segui il diagramma sopra indicato per creare entità. Crea un pacchetto denominato‘com.tutorialspoin.eclipselink.entity’ sotto ‘src’pacchetto. Crea una classe denominataClas.javasotto dato pacchetto. L'entità Department della classe viene visualizzata come segue:

package com.tutorialspoint.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;
   }	  
}

Crea la seconda entità in questa relazione -Classe di entità dipendente, denominata Teacher.java sotto ‘com.tutorialspoint.eclipselink.entity’pacchetto. La classe di entità Employee viene mostrata come segue:

package com.tutorialspoint.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 verrà creato dall'IDE di eclipse durante la creazione di un progetto JPA. I dettagli di configurazione sono le specifiche dell'utente. Il file persistence.xml viene mostrato come segue:

<?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.tutorialspoint.eclipselink.entity.Employee</class>
      <class>com.tutorialspoint.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>

Classi di servizio

Questo modulo contiene le classi di servizio, che implementa la parte relazionale utilizzando l'inizializzazione dell'attributo. Crea un pacchetto in‘src’ pacchetto denominato ‘com.tutorialspoint.eclipselink.service’. La classe DAO denominataManyToMany.javaviene creato in un determinato pacchetto. La classe DAO è mostrata come segue:

package com.tutorialspoint.eclipselink.service;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import com.tutorialspoint.eclipselink.entity.Clas;
import com.tutorialspoint.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( );
   }
}

Dopo la compilazione e l'esecuzione del programma di cui sopra riceverai le notifiche nel pannello della console di Eclipse IDE. Per l'output, controlla il workbench MySQL come segue. In questo progetto di esempio vengono create tre tabelle.

Passa la seguente query nell'interfaccia MySQL e il risultato di teacher_clas tabella in un formato tabulare viene mostrata come segue nella query.

Select * form teacher_clas;

Teacher _tid	Classet_cid
354	        351
355	        351
356	        351
354	        352
355	        352
356	        352
354	        353
355	        353
356	        353

Nella tabella precedente, teacher_tid è la chiave esterna dalla tabella dell'insegnante e classet_cid è la chiave esterna dalla tabella della classe. Pertanto, diversi insegnanti sono assegnati a classi diverse.

Passa la seguente query nell'interfaccia MySQL e il risultato della tabella dell'insegnante in formato tabulare viene mostrato come segue nella query:

Select * from teacher;

Tid	Subject	    Tname
354	Java	    Satish
355	Adv Java    Krishna
356	DB2         Masthanvali

Passa la seguente query nell'interfaccia MySQL e il risultato di clas tabella in un formato tabulare è mostrata come segue nella query:

Select * from clas;

cid	Cname
351	1st
352	2nd
353	3rd