JPA - Relações de Entidade
Este capítulo apresenta as relações entre as entidades. Geralmente as relações são mais eficazes entre as tabelas do banco de dados. Aqui, as classes de entidade são tratadas como tabelas relacionais (conceito de JPA), portanto, as relações entre as classes de entidade são as seguintes:
- Relação @ManyToOne
- Relação @OneToMany
- Relação @OneToOne
- Relação @ManyToMany
Relação @ManyToOne
Relação muitos para um entre entidades: onde uma entidade (coluna ou conjunto de colunas) é / são referenciados com outra entidade (coluna ou conjunto de colunas) que contém valores únicos. Em bancos de dados relacionais, essas relações são aplicáveis usando chave estrangeira / chave primária entre tabelas.
Vamos considerar um exemplo de relação entre entidades de Funcionário e Departamento. De maneira unidirecional, ou seja, de funcionário para departamento, é aplicável a relação muitos para um. Isso significa que cada registro de funcionário contém um ID de departamento, que deve ser uma chave primária na tabela Departamento. Aqui na tabela Employee, Department id é uma chave estrangeira.
O diagrama explica a relação Muitos para Um da seguinte forma:
Crie um projeto JPA no Eclipse IDE chamado JPA_Eclipselink_MTO. Todos os módulos deste projeto são mostrados a seguir:
Criando Entidades
Siga o diagrama fornecido acima para criar entidades. Crie um pacote chamado‘com.tutorialspoin.eclipselink.entity’ debaixo ‘src’pacote. Crie uma classe chamadaDepartment.javasob determinado pacote. A classe entidade Department é mostrada da seguinte forma:
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;
}
}
Crie a segunda entidade nesta relação - classe de entidade de funcionário chamada Employee.java debaixo ‘com.tutorialspoint.eclipselink.entity’pacote. A classe de entidade Employee é mostrada da seguinte forma:
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
O arquivo Persistence.xml é necessário para configurar o banco de dados e o registro das classes de entidade.
Persitence.xml será criado pelo Eclipse IDE ao criar um Projeto JPA. Os detalhes da configuração são especificações do usuário. O arquivo persistence.xml é mostrado da seguinte forma:
<?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 serviço
Este módulo contém as classes de serviço, que implementam a parte relacional utilizando a inicialização do atributo. Crie um pacote em‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’. A classe DAO chamadaManyToOne.javaé criado sob determinado pacote. A classe DAO é mostrada da seguinte forma:
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();
}
}
Após a compilação e execução do programa acima, você receberá notificações no painel do console do Eclipse IDE. Para saída, verifique o ambiente de trabalho MySQL. Neste exemplo, duas tabelas são criadas.
Passe a seguinte consulta na interface MySQL e o resultado de Department tabela em formato tabular é mostrada da seguinte forma na consulta:
Select * from department;
Id Name
101 Development
Passe a seguinte consulta na interface MySQL e o resultado de Employee tabela em formato tabular é mostrada da seguinte forma na 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
Na tabela acima, Deparment_Id é a chave estrangeira (campo de referência) da tabela Departamento.
Relação @OneToMany
Nesse relacionamento, cada linha de uma entidade é referenciada a muitos registros filho em outra entidade. O importante é que os registros de filhos não podem ter vários pais. Em uma relação de um para muitos entre a Tabela A e a Tabela B, cada linha da Tabela A está ligada a 0, 1 ou muitas linhas da Tabela B.
Vamos considerar o exemplo acima. E seEmployee e Departmentestá em uma maneira unidirecional reversa, a relação é uma relação Muitos-para-um. Crie um projeto JPA no Eclipse IDE chamadoJPA_Eclipselink_OTM. Todos os módulos deste projeto são mostrados a seguir:
Criando Entidades
Siga o diagrama fornecido acima para criar entidades. Crie um pacote chamado‘com.tutorialspoin.eclipselink.entity’ debaixo ‘src’pacote. Crie uma classe chamadaDepartment.javasob determinado pacote. A classe entidade Department é mostrada da seguinte forma:
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;
}
}
Crie a segunda entidade nesta relação - classe de entidade do empregado, chamada Employee.java debaixo ‘com.tutorialspoint.eclipselink.entity’pacote. A classe de entidade Employee é mostrada da seguinte forma:
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á criado pelo eclipse IDE durante a criação de um projeto JPA. Os detalhes da configuração são especificações do usuário. O arquivo persistence.xml é mostrado da seguinte forma:
<?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 serviço
Este módulo contém as classes de serviço, que implementam a parte relacional utilizando a inicialização do atributo. Crie um pacote em‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’. A classe DAO chamadaOneToMany.javaé criado sob determinado pacote. A classe DAO é mostrada da seguinte forma:
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();
}
}
Após a compilação e execução do programa acima, você receberá notificações no painel do console do Eclipse IDE. Para a saída, verifique o ambiente de trabalho MySQL da seguinte maneira. Neste projeto três tabelas são criadas.
Passe a seguinte consulta na interface MySQL e o resultado de department_employee tabela em formato tabular é mostrada da seguinte forma na consulta:
Select * from department_Id;
Department_Id Employee_Eid
254 251
254 252
254 253
Na tabela acima, os campos deparment_id e employee_id são as chaves estrangeiras (campos de referência) das tabelas de departamento e funcionário.
Passe a seguinte consulta na interface MySQL e o resultado da tabela de departamento em formato tabular é mostrado a seguir na consulta:
Select * from department;
Id Name
254 Development
Passe a seguinte consulta na interface MySQL e o resultado da tabela de funcionários em formato tabular é mostrado a seguir na consulta:
Select * from employee;
Eid Deg Ename Salary
251 Technical Writer Satish 45000
252 Technical Writer Krishna 45000
253 Technical Writer Masthanvali 50000
Relação @OneToOne
No relacionamento Um para Um, um item pode pertencer a apenas um outro item. Isso significa que cada linha de uma entidade se refere a uma e apenas uma linha de outra entidade.
Vamos considerar o exemplo acima. Employee e Departmentde maneira unidirecional reversa, a relação é uma relação Um-para-Um. Isso significa que cada funcionário pertence a apenas um departamento. Crie um projeto JPA no Eclipse IDE chamadoJPA_Eclipselink_OTO. Todos os módulos deste projeto são mostrados a seguir:
Criando Entidades
Siga o diagrama fornecido acima para criar entidades. Crie um pacote chamado‘com.tutorialspoin.eclipselink.entity’ debaixo ‘src’pacote. Crie uma classe chamadaDepartment.javasob determinado pacote. A classe entidade Department é mostrada da seguinte forma:
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;
}
}
Crie a segunda entidade nesta relação - classe de entidade do empregado, chamada Employee.java debaixo ‘com.tutorialspoint.eclipselink.entity’pacote. A classe de entidade Employee é mostrada da seguinte forma:
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á criado pelo eclipse IDE durante a criação de um projeto JPA. Os detalhes da configuração são especificações do usuário. O arquivo persistence.xml é mostrado da seguinte forma:
<?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 serviço
Este módulo contém as classes de serviço, que implementam a parte relacional utilizando a inicialização do atributo. Crie um pacote em‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’. A classe DAO chamadaOneToOne.javaé criado no pacote fornecido. A classe DAO é mostrada da seguinte forma:
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();
}
}
Após a compilação e execução do programa acima, você receberá notificações no painel do console do Eclipse IDE. Para saída, verifique o ambiente de trabalho MySQL da seguinte maneira. No exemplo acima, duas tabelas são criadas.
Passe a seguinte consulta na interface MySQL e o resultado de department tabela em formato tabular é mostrada da seguinte forma na consulta:
Select * from department
Id Name
301 Development
Passe a seguinte consulta na interface MySQL e o resultado de employee tabela em formato tabular é mostrada da seguinte forma na consulta:
Select * from employee
Eid Deg Ename Salary Department_id
302 Technical Writer Satish 45000 301
Relação @ManyToMany
O relacionamento muitos para muitos é onde uma ou mais linhas de uma entidade são associadas a mais de uma linha em outra entidade.
Vamos considerar um exemplo de relação entre as entidades Classe e Professor. Na maneira bidirecional, tanto a classe quanto o professor têm relação muitos para um. Isso significa que cada registro de Aula é referido por conjunto de Professor (ids de professor), que devem ser chaves primárias na tabela Professor e armazenados na tabela Professor_Classe e vice-versa. Aqui, a tabela Teachers_Class contém ambos os campos de chave estrangeira. Crie um projeto JPA no Eclipse IDE chamadoJPA_Eclipselink_MTM. Todos os módulos deste projeto são mostrados a seguir:
Criando Entidades
Siga o diagrama fornecido acima para criar entidades. Crie um pacote chamado‘com.tutorialspoin.eclipselink.entity’ debaixo ‘src’pacote. Crie uma classe chamadaClas.javasob determinado pacote. A classe entidade Department é mostrada da seguinte forma:
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;
}
}
Crie a segunda entidade nesta relação - classe de entidade do empregado, chamada Teacher.java debaixo ‘com.tutorialspoint.eclipselink.entity’pacote. A classe de entidade Employee é mostrada da seguinte forma:
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á criado pelo Eclipse IDE enquanto cria um projeto JPA. Os detalhes da configuração são especificações do usuário. O arquivo persistence.xml é mostrado da seguinte forma:
<?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 serviço
Este módulo contém as classes de serviço, que implementam a parte relacional utilizando a inicialização do atributo. Crie um pacote em‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’. A classe DAO chamadaManyToMany.javaé criado sob determinado pacote. A classe DAO é mostrada da seguinte forma:
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( );
}
}
Após a compilação e execução do programa acima, você receberá notificações no painel do console do Eclipse IDE. Para saída, verifique o ambiente de trabalho MySQL da seguinte maneira. Neste projeto de exemplo, três tabelas são criadas.
Passe a seguinte consulta na interface MySQL e o resultado de teacher_clas tabela em um formato tabular é mostrada como segue na 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
Na tabela acima, teacher_tid é a chave estrangeira da tabela do professor e classet_cid é a chave estrangeira da tabela da classe. Portanto, professores diferentes são atribuídos a classes diferentes.
Passe a seguinte consulta na interface MySQL e o resultado da tabela do professor em formato tabular é mostrado a seguir na consulta:
Select * from teacher;
Tid Subject Tname
354 Java Satish
355 Adv Java Krishna
356 DB2 Masthanvali
Passe a seguinte consulta na interface MySQL e o resultado de clas tabela em formato tabular é mostrada da seguinte forma na consulta:
Select * from clas;
cid Cname
351 1st
352 2nd
353 3rd