JPA - Relaciones entre entidades
Este capítulo lo lleva a través de las relaciones entre entidades. Generalmente, las relaciones son más efectivas entre tablas en la base de datos. Aquí las clases de entidad se tratan como tablas relacionales (concepto de JPA), por lo tanto, las relaciones entre las clases de entidad son las siguientes:
- @ManyToOne Relation
- Relación @OneToMany
- Relación @OneToOne
- @ManyToMany Relation
@ManyToOne Relation
Relación de varios a uno entre entidades: donde una entidad (columna o conjunto de columnas) se hace referencia a otra entidad (columna o conjunto de columnas) que contiene valores únicos. En las bases de datos relacionales, estas relaciones son aplicables mediante el uso de clave externa / clave primaria entre tablas.
Consideremos un ejemplo de relación entre las entidades Empleado y Departamento. De manera unidireccional, de empleado a departamento, se aplica la relación de varios a uno. Eso significa que cada registro de empleado contiene una identificación de departamento, que debe ser una clave principal en la tabla de departamentos. Aquí, en la tabla Empleado, el ID de departamento es una clave externa.
El diagrama explica la relación de varios a uno de la siguiente manera:
Cree un proyecto JPA en eclipse IDE llamado JPA_Eclipselink_MTO. Todos los módulos de este proyecto se muestran a continuación:
Creando Entidades
Siga el diagrama dado arriba para crear entidades. Crea un paquete llamado‘com.tutorialspoin.eclipselink.entity’ debajo ‘src’paquete. Crea una clase llamadaDepartment.javabajo paquete dado. La entidad de la clase Departamento se muestra a continuación:
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;
}
}
Cree la segunda entidad en esta relación: clase de entidad de empleado denominada Employee.java debajo ‘com.tutorialspoint.eclipselink.entity’paquete. La clase de entidad Empleado se muestra a continuación:
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
Se requiere el archivo Persistence.xml para configurar la base de datos y el registro de clases de entidad.
Persitence.xml será creado por el IDE de eclipse mientras crea un proyecto JPA. Los detalles de configuración son especificaciones del usuario. El archivo persistence.xml se muestra a continuación:
<?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>
Clases de servicio
Este módulo contiene las clases de servicio, que implementa la parte relacional utilizando la inicialización de atributos. Crea un paquete debajo‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’. La clase DAO llamadaManyToOne.javase crea bajo el paquete dado. La clase DAO se muestra a continuación:
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();
}
}
Después de la compilación y ejecución del programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Para obtener resultados, consulte MySQL workbench. En este ejemplo se crean dos tablas.
Pase la siguiente consulta en la interfaz MySQL y el resultado de Department La tabla en formato tabular se muestra de la siguiente manera en la consulta:
Select * from department;
Id Name
101 Development
Pase la siguiente consulta en la interfaz MySQL y el resultado de Employee La tabla en formato tabular se muestra de la siguiente manera en la consulta:
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
En la tabla anterior Deparment_Id es la clave externa (campo de referencia) de la tabla Departamento.
Relación @OneToMany
En esta relación, cada fila de una entidad hace referencia a muchos registros secundarios en otra entidad. Lo importante es que los registros secundarios no pueden tener varios padres. En una relación de uno a muchos entre la Tabla A y la Tabla B, cada fila de la Tabla A está vinculada a 0, 1 o muchas filas de la Tabla B.
Consideremos el ejemplo anterior. SiEmployee y Departmentes de una manera unidireccional inversa, la relación es una relación Muchos-a-Uno. Cree un proyecto JPA en eclipse IDE llamadoJPA_Eclipselink_OTM. Todos los módulos de este proyecto se muestran a continuación:
Creando Entidades
Siga el diagrama dado arriba para crear entidades. Crea un paquete llamado‘com.tutorialspoin.eclipselink.entity’ debajo ‘src’paquete. Crea una clase llamadaDepartment.javabajo paquete dado. La entidad de la clase Departamento se muestra a continuación:
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;
}
}
Cree la segunda entidad en esta relación: clase de entidad de empleado, denominada Employee.java debajo ‘com.tutorialspoint.eclipselink.entity’paquete. La clase de entidad Empleado se muestra a continuación:
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 será creado por el IDE de eclipse mientras crea un proyecto JPA. Los detalles de configuración son especificaciones del usuario. El archivo persistence.xml se muestra a continuación:
<?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>
Clases de servicio
Este módulo contiene las clases de servicio, que implementa la parte relacional utilizando la inicialización de atributos. Crea un paquete debajo‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’. La clase DAO llamadaOneToMany.javase crea bajo el paquete dado. La clase DAO se muestra a continuación:
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();
}
}
Después de la compilación y ejecución del programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Para obtener resultados, verifique el banco de trabajo MySQL de la siguiente manera. En este proyecto se crean tres tablas.
Pase la siguiente consulta en la interfaz MySQL y el resultado de department_employee La tabla en formato tabular se muestra de la siguiente manera en la consulta:
Select * from department_Id;
Department_Id Employee_Eid
254 251
254 252
254 253
En la tabla anterior, los campos deparment_id y employee_id son las claves externas (campos de referencia) de las tablas de departamento y empleado.
Pase la siguiente consulta en la interfaz MySQL y el resultado de la tabla de departamentos en formato tabular se muestra de la siguiente manera en la consulta:
Select * from department;
Id Name
254 Development
Pase la siguiente consulta en la interfaz MySQL y el resultado de la tabla de empleados en formato tabular se muestra de la siguiente manera en la consulta:
Select * from employee;
Eid Deg Ename Salary
251 Technical Writer Satish 45000
252 Technical Writer Krishna 45000
253 Technical Writer Masthanvali 50000
Relación @OneToOne
En la relación uno a uno, un elemento puede pertenecer solo a otro elemento. Significa que cada fila de una entidad se refiere a una y solo una fila de otra entidad.
Consideremos el ejemplo anterior. Employee y Departmentde manera unidireccional inversa, la relación es una relación Uno-a-Uno. Significa que cada empleado pertenece a un solo departamento. Cree un proyecto JPA en eclipse IDE llamadoJPA_Eclipselink_OTO. Todos los módulos de este proyecto se muestran a continuación:
Creando Entidades
Siga el diagrama dado arriba para crear entidades. Crea un paquete llamado‘com.tutorialspoin.eclipselink.entity’ debajo ‘src’paquete. Crea una clase llamadaDepartment.javabajo paquete dado. La entidad de la clase Departamento se muestra a continuación:
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;
}
}
Cree la segunda entidad en esta relación: clase de entidad de empleado, denominada Employee.java debajo ‘com.tutorialspoint.eclipselink.entity’paquete. La clase de entidad Empleado se muestra a continuación:
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 será creado por el IDE de eclipse al crear un proyecto JPA. Los detalles de configuración son especificaciones del usuario. El archivo persistence.xml se muestra a continuación:
<?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>
Clases de servicio
Este módulo contiene las clases de servicio, que implementa la parte relacional utilizando la inicialización de atributos. Crea un paquete debajo‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’. La clase DAO llamadaOneToOne.javase crea bajo el paquete dado. La clase DAO se muestra a continuación:
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();
}
}
Después de la compilación y ejecución del programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Para obtener resultados, consulte MySQL workbench de la siguiente manera. En el ejemplo anterior se crean dos tablas.
Pase la siguiente consulta en la interfaz MySQL y el resultado de department La tabla en formato tabular se muestra de la siguiente manera en la consulta:
Select * from department
Id Name
301 Development
Pase la siguiente consulta en la interfaz MySQL y el resultado de employee La tabla en formato tabular se muestra de la siguiente manera en la consulta:
Select * from employee
Eid Deg Ename Salary Department_id
302 Technical Writer Satish 45000 301
@ManyToMany Relation
La relación de varios a varios es donde una o más filas de una entidad están asociadas con más de una fila en otra entidad.
Consideremos un ejemplo de relación entre las entidades Clase y Maestro. De manera bidireccional, tanto la clase como el profesor tienen una relación de varios a uno. Eso significa que cada registro de Clase es referido por el conjunto de profesores (ID de profesor), que deben ser claves primarias en la tabla de profesores y almacenarse en la tabla Teacher_Class y viceversa. Aquí, la tabla Teachers_Class contiene ambos campos de clave externos. Cree un proyecto JPA en eclipse IDE llamadoJPA_Eclipselink_MTM. Todos los módulos de este proyecto se muestran a continuación:
Creando Entidades
Siga el diagrama dado arriba para crear entidades. Crea un paquete llamado‘com.tutorialspoin.eclipselink.entity’ debajo ‘src’paquete. Crea una clase llamadaClas.javabajo paquete dado. La entidad de la clase Departamento se muestra a continuación:
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;
}
}
Cree la segunda entidad en esta relación: clase de entidad de empleado, denominada Teacher.java debajo ‘com.tutorialspoint.eclipselink.entity’paquete. La clase de entidad Empleado se muestra a continuación:
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 será creado por el IDE de eclipse mientras se desarrolla un proyecto JPA. Los detalles de configuración son especificaciones del usuario. El archivo persistence.xml se muestra a continuación:
<?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>
Clases de servicio
Este módulo contiene las clases de servicio, que implementa la parte relacional utilizando la inicialización de atributos. Crea un paquete debajo‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’. La clase DAO llamadaManyToMany.javase crea bajo el paquete dado. La clase DAO se muestra a continuación:
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( );
}
}
Después de la compilación y ejecución del programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Para obtener resultados, consulte MySQL workbench de la siguiente manera. En este proyecto de ejemplo, se crean tres tablas.
Pase la siguiente consulta en la interfaz MySQL y el resultado de teacher_clas La tabla en formato tabular se muestra a continuación en la consulta.
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
En la tabla anterior, teacher_tid es la clave externa de la tabla de maestros, y classet_cid es la clave externa de la tabla de clases. Por lo tanto, se asignan diferentes profesores a diferentes clases.
Pase la siguiente consulta en la interfaz MySQL y el resultado de la tabla del profesor en formato tabular se muestra de la siguiente manera en la consulta:
Select * from teacher;
Tid Subject Tname
354 Java Satish
355 Adv Java Krishna
356 DB2 Masthanvali
Pase la siguiente consulta en la interfaz MySQL y el resultado de clas La tabla en formato tabular se muestra de la siguiente manera en la consulta:
Select * from clas;
cid Cname
351 1st
352 2nd
353 3rd