JPA - Relations d'entité
Ce chapitre vous présente les relations entre les entités. En général, les relations sont plus efficaces entre les tables de la base de données. Ici, les classes d'entités sont traitées comme des tables relationnelles (concept de JPA), donc les relations entre les classes d'entités sont les suivantes:
- @ManyToOne Relation
- Relation @OneToMany
- Relation @OneToOne
- @ManyToMany Relation
@ManyToOne Relation
Relation plusieurs-à-un entre entités: lorsqu'une entité (colonne ou ensemble de colonnes) est / sont référencée avec une autre entité (colonne ou ensemble de colonnes) qui contient des valeurs uniques. Dans les bases de données relationnelles, ces relations sont applicables en utilisant une clé étrangère / clé primaire entre les tables.
Prenons un exemple de relation entre les entités Employé et Département. De manière unidirectionnelle, c'est-à-dire de l'employé au service, la relation plusieurs-à-un est applicable. Cela signifie que chaque enregistrement d'employé contient un identifiant de service, qui doit être une clé primaire dans la table Department. Ici, dans la table Employee, l'ID de service est une clé étrangère.
Le diagramme explique la relation plusieurs-à-un comme suit:
Créer un projet JPA dans l'EDI eclipse nommé JPA_Eclipselink_MTO. Tous les modules de ce projet sont présentés comme suit:
Créer des entités
Suivez le diagramme ci-dessus pour créer des entités. Créez un package nommé‘com.tutorialspoin.eclipselink.entity’ en dessous de ‘src’paquet. Créez une classe nomméeDepartment.javasous le paquet donné. L'entité de classe Department est représentée comme suit:
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;
}
}
Créez la deuxième entité dans cette relation - Classe d'entité Employee nommée Employee.java en dessous de ‘com.tutorialspoint.eclipselink.entity’paquet. La classe d'entité Employee se présente comme suit:
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
Le fichier Persistence.xml est requis pour configurer la base de données et l'enregistrement des classes d'entités.
Persitence.xml sera créé par l'EDI eclipse lors de la création d'un projet JPA. Les détails de configuration sont les spécifications de l'utilisateur. Le fichier persistence.xml est présenté comme suit:
<?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>
Classes de service
Ce module contient les classes de service, qui implémentent la partie relationnelle à l'aide de l'initialisation d'attribut. Créez un package sous‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’. La classe DAO nomméeManyToOne.javaest créé sous un package donné. La classe DAO est représentée comme suit:
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();
}
}
Après la compilation et l'exécution du programme ci-dessus, vous recevrez des notifications dans le panneau de la console d'Eclipse IDE. Pour la sortie, consultez MySQL workbench. Dans cet exemple, deux tables sont créées.
Passez la requête suivante dans l'interface MySQL et le résultat de Department table au format tabulaire s'affiche comme suit dans la requête:
Select * from department;
Id Name
101 Development
Passez la requête suivante dans l'interface MySQL et le résultat de Employee table au format tabulaire s'affiche comme suit dans la requête:
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
Dans la table ci-dessus Deparment_Id est la clé étrangère (champ de référence) de la table Department.
Relation @OneToMany
Dans cette relation, chaque ligne d'une entité est référencée à de nombreux enregistrements enfants dans une autre entité. L'important est que les enregistrements enfants ne peuvent pas avoir plusieurs parents. Dans une relation un-à-plusieurs entre le tableau A et le tableau B, chaque ligne du tableau A est liée à 0, 1 ou plusieurs lignes du tableau B.
Prenons l'exemple ci-dessus. SiEmployee et Departmentest d'une manière unidirectionnelle inverse, la relation est une relation plusieurs-à-un. Créer un projet JPA dans l'EDI eclipse nomméJPA_Eclipselink_OTM. Tous les modules de ce projet sont présentés comme suit:
Créer des entités
Suivez le diagramme ci-dessus pour créer des entités. Créez un package nommé‘com.tutorialspoin.eclipselink.entity’ en dessous de ‘src’paquet. Créez une classe nomméeDepartment.javasous le paquet donné. L'entité de classe Department est représentée comme suit:
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;
}
}
Créez la deuxième entité dans cette relation -Employee entity class, nommée Employee.java en dessous de ‘com.tutorialspoint.eclipselink.entity’paquet. La classe d'entité Employee se présente comme suit:
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 sera créé par l'EDI eclipse lors de la création d'un projet JPA. Les détails de configuration sont les spécifications de l'utilisateur. Le fichier persistence.xml est présenté comme suit:
<?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>
Classes de service
Ce module contient les classes de service, qui implémentent la partie relationnelle à l'aide de l'initialisation d'attribut. Créez un package sous‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’. La classe DAO nomméeOneToMany.javaest créé sous un package donné. La classe DAO est représentée comme suit:
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();
}
}
Après la compilation et l'exécution du programme ci-dessus, vous recevrez des notifications dans le panneau de la console d'Eclipse IDE. Pour la sortie, vérifiez le workbench MySQL comme suit. Dans ce projet, trois tables sont créées.
Passez la requête suivante dans l'interface MySQL et le résultat de department_employee table au format tabulaire s'affiche comme suit dans la requête:
Select * from department_Id;
Department_Id Employee_Eid
254 251
254 252
254 253
Dans le tableau ci-dessus, les champs deparment_id et employee_id sont les clés étrangères (champs de référence) des tables department et employee.
Passez la requête suivante dans l'interface MySQL et le résultat de la table de service dans un format tabulaire est affiché comme suit dans la requête:
Select * from department;
Id Name
254 Development
Passez la requête suivante dans l'interface MySQL et le résultat de la table des employés dans un format tabulaire est affiché comme suit dans la requête:
Select * from employee;
Eid Deg Ename Salary
251 Technical Writer Satish 45000
252 Technical Writer Krishna 45000
253 Technical Writer Masthanvali 50000
Relation @OneToOne
Dans une relation un-à-un, un élément ne peut appartenir qu'à un seul autre élément. Cela signifie que chaque ligne d'une entité est référencée à une et une seule ligne d'une autre entité.
Prenons l'exemple ci-dessus. Employee et Departmentde manière unidirectionnelle inverse, la relation est une relation un-à-un. Cela signifie que chaque employé appartient à un seul service. Créer un projet JPA dans l'EDI eclipse nomméJPA_Eclipselink_OTO. Tous les modules de ce projet sont présentés comme suit:
Créer des entités
Suivez le diagramme ci-dessus pour créer des entités. Créez un package nommé‘com.tutorialspoin.eclipselink.entity’ en dessous de ‘src’paquet. Créez une classe nomméeDepartment.javasous le paquet donné. L'entité de classe Department est représentée comme suit:
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;
}
}
Créez la deuxième entité dans cette relation -Employee entity class, nommée Employee.java en dessous de ‘com.tutorialspoint.eclipselink.entity’paquet. La classe d'entité Employee se présente comme suit:
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 sera créé par l'EDI eclipse lors de la création d'un projet JPA. Les détails de configuration sont les spécifications de l'utilisateur. Le fichier persistence.xml est présenté comme suit:
<?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>
Classes de service
Ce module contient les classes de service, qui implémentent la partie relationnelle à l'aide de l'initialisation d'attribut. Créez un package sous‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’. La classe DAO nomméeOneToOne.javaest créé sous le package donné. La classe DAO est représentée comme suit:
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();
}
}
Après la compilation et l'exécution du programme ci-dessus, vous recevrez des notifications dans le panneau de la console d'Eclipse IDE. Pour la sortie, vérifiez le workbench MySQL comme suit. Dans l'exemple ci-dessus, deux tables sont créées.
Passez la requête suivante dans l'interface MySQL et le résultat de department table au format tabulaire s'affiche comme suit dans la requête:
Select * from department
Id Name
301 Development
Passez la requête suivante dans l'interface MySQL et le résultat de employee table au format tabulaire s'affiche comme suit dans la requête:
Select * from employee
Eid Deg Ename Salary Department_id
302 Technical Writer Satish 45000 301
@ManyToMany Relation
La relation plusieurs-à-plusieurs est le cas où une ou plusieurs lignes d'une entité sont associées à plusieurs lignes d'une autre entité.
Prenons un exemple de relation entre les entités Classe et Enseignant. De manière bidirectionnelle, la classe et l'enseignant ont une relation plusieurs-à-un. Cela signifie que chaque enregistrement de classe est référencé par l'ensemble de l'enseignant (identifiants de l'enseignant), qui doit être des clés primaires dans la table des enseignants et stockées dans la table de l'enseignant_classe et vice versa. Ici, la table Teachers_Class contient les deux champs de clé étrangère. Créer un projet JPA dans l'EDI eclipse nomméJPA_Eclipselink_MTM. Tous les modules de ce projet sont présentés comme suit:
Créer des entités
Suivez le diagramme ci-dessus pour créer des entités. Créez un package nommé‘com.tutorialspoin.eclipselink.entity’ en dessous de ‘src’paquet. Créez une classe nomméeClas.javasous le paquet donné. L'entité de classe Department est représentée comme suit:
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;
}
}
Créez la deuxième entité dans cette relation -Employee entity class, nommée Teacher.java en dessous de ‘com.tutorialspoint.eclipselink.entity’paquet. La classe d'entité Employee se présente comme suit:
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 sera créé par l'EDI eclipse lors de la création d'un projet JPA. Les détails de configuration sont les spécifications de l'utilisateur. Le fichier persistence.xml est présenté comme suit:
<?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>
Classes de service
Ce module contient les classes de service, qui implémentent la partie relationnelle à l'aide de l'initialisation d'attribut. Créez un package sous‘src’ package nommé ‘com.tutorialspoint.eclipselink.service’. La classe DAO nomméeManyToMany.javaest créé sous un package donné. La classe DAO est représentée comme suit:
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( );
}
}
Après la compilation et l'exécution du programme ci-dessus, vous recevrez des notifications dans le panneau de la console d'Eclipse IDE. Pour la sortie, vérifiez le workbench MySQL comme suit. Dans cet exemple de projet, trois tables sont créées.
Passez la requête suivante dans l'interface MySQL et le résultat de teacher_clas table au format tabulaire est présentée comme suit dans la requête.
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
Dans la table ci-dessus, teacher_tid est la clé étrangère de la table des enseignants et classet_cid est la clé étrangère de la table de classe. Par conséquent, différents enseignants sont affectés à des classes différentes.
Transmettez la requête suivante dans l'interface MySQL et le résultat de la table des enseignants dans un format tabulaire est affiché comme suit dans la requête:
Select * from teacher;
Tid Subject Tname
354 Java Satish
355 Adv Java Krishna
356 DB2 Masthanvali
Passez la requête suivante dans l'interface MySQL et le résultat de clas table au format tabulaire s'affiche comme suit dans la requête:
Select * from clas;
cid Cname
351 1st
352 2nd
353 3rd