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