JPA-엔티티 관계
이 장에서는 엔티티 간의 관계에 대해 설명합니다. 일반적으로 관계는 데이터베이스의 테이블간에 더 효과적입니다. 여기서 엔티티 클래스는 관계형 테이블 (JPA 개념)로 취급되므로 엔티티 클래스 간의 관계는 다음과 같습니다.
- @ManyToOne 관계
- @OneToMany 관계
- @OneToOne 관계
- @ManyToMany 관계
@ManyToOne 관계
엔터티 간의 다 대일 관계 : 한 엔터티 (열 또는 열 집합)가 고유 한 값을 포함하는 다른 엔터티 (열 또는 열 집합)와 참조되는 경우. 관계형 데이터베이스에서 이러한 관계는 테이블간에 외래 키 / 기본 키를 사용하여 적용 할 수 있습니다.
Employee와 Department 엔터티 간의 관계 예를 고려해 보겠습니다. 단방향, 즉 직원에서 부서로 다 대일 관계가 적용됩니다. 즉, 직원의 각 레코드에는 부서 테이블의 기본 키 여야하는 부서 ID가 하나씩 포함됩니다. 여기 Employee 테이블에서 Department id는 외래 키입니다.
다이어그램은 다음과 같이 다 대일 관계를 설명합니다.
Eclipse IDE에서 JPA 프로젝트를 작성하십시오. JPA_Eclipselink_MTO. 이 프로젝트의 모든 모듈은 다음과 같이 표시됩니다.
엔티티 생성
엔티티를 생성하려면 위의 주어진 다이어그램을 따르십시오. 이름이 지정된 패키지 만들기‘com.tutorialspoin.eclipselink.entity’ 아래에 ‘src’꾸러미. 이름이 지정된 클래스 만들기Department.java주어진 패키지에서. 클래스 Department 엔티티는 다음과 같이 표시됩니다.
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;
}
}
이 관계에서 두 번째 엔터티 만들기-Employee 엔터티 클래스 이름 Employee.java 아래에 ‘com.tutorialspoint.eclipselink.entity’꾸러미. Employee 엔티티 클래스는 다음과 같이 표시됩니다.
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
Persistence.xml 파일은 데이터베이스를 구성하고 엔티티 클래스를 등록하는 데 필요합니다.
Persitence.xml은 JPA 프로젝트를 생성하는 동안 Eclipse IDE에 의해 생성됩니다. 구성 세부 사항은 사용자 사양입니다. persistence.xml 파일은 다음과 같이 표시됩니다.
<?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>
서비스 등급
이 모듈에는 속성 초기화를 사용하여 관계형 부분을 구현하는 서비스 클래스가 포함되어 있습니다. 아래에 패키지 만들기‘src’ 패키지 이름 ‘com.tutorialspoint.eclipselink.service’. 명명 된 DAO 클래스ManyToOne.java주어진 패키지 아래에 생성됩니다. DAO 클래스는 다음과 같이 표시됩니다.
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();
}
}
위 프로그램을 컴파일하고 실행하면 Eclipse IDE의 콘솔 패널에 알림이 표시됩니다. 출력의 경우 MySQL 워크 벤치를 확인하십시오. 이 예에서는 두 개의 테이블이 생성됩니다.
MySQL 인터페이스에서 다음 쿼리를 전달하고 Department 테이블 형식의 테이블은 쿼리에서 다음과 같이 표시됩니다.
Select * from department;
Id Name
101 Development
MySQL 인터페이스에서 다음 쿼리를 전달하고 Employee 테이블 형식의 테이블은 쿼리에서 다음과 같이 표시됩니다.
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
위 테이블에서 Deparment_Id는 Department 테이블의 외래 키 (참조 필드)입니다.
@OneToMany 관계
이 관계에서 한 엔터티의 각 행은 다른 엔터티의 많은 하위 레코드를 참조합니다. 중요한 것은 하위 레코드가 여러 상위를 가질 수 없다는 것입니다. 테이블 A와 테이블 B 간의 일대 다 관계에서 테이블 A의 각 행은 테이블 B의 0, 1 또는 여러 행에 연결됩니다.
위의 예를 살펴 보겠습니다. 만약Employee 과 Department역 단방향 방식으로 관계는 다 대일 관계입니다. Eclipse IDE에서 JPA 프로젝트를 작성하십시오.JPA_Eclipselink_OTM. 이 프로젝트의 모든 모듈은 다음과 같이 표시됩니다.
엔티티 생성
엔티티를 생성하려면 위의 주어진 다이어그램을 따르십시오. 이름이 지정된 패키지 만들기‘com.tutorialspoin.eclipselink.entity’ 아래에 ‘src’꾸러미. 이름이 지정된 클래스 만들기Department.java주어진 패키지에서. 클래스 Department 엔티티는 다음과 같이 표시됩니다.
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;
}
}
이 관계 -Employee 엔터티 클래스에서 두 번째 엔터티를 만듭니다. Employee.java 아래에 ‘com.tutorialspoint.eclipselink.entity’꾸러미. Employee 엔티티 클래스는 다음과 같이 표시됩니다.
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은 JPA 프로젝트를 생성하는 동안 Eclipse IDE에 의해 생성됩니다. 구성 세부 사항은 사용자 사양입니다. persistence.xml 파일은 다음과 같이 표시됩니다.
<?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>
서비스 등급
이 모듈에는 속성 초기화를 사용하여 관계형 부분을 구현하는 서비스 클래스가 포함되어 있습니다. 아래에 패키지 만들기‘src’ 패키지 이름 ‘com.tutorialspoint.eclipselink.service’. 명명 된 DAO 클래스OneToMany.java주어진 패키지 아래에 생성됩니다. DAO 클래스는 다음과 같이 표시됩니다.
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();
}
}
위 프로그램을 컴파일하고 실행하면 Eclipse IDE의 콘솔 패널에 알림이 표시됩니다. 출력을 위해 다음과 같이 MySQL 워크 벤치를 확인하십시오. 이 프로젝트에서는 세 개의 테이블이 생성됩니다.
MySQL 인터페이스에서 다음 쿼리를 전달하고 department_employee 테이블 형식의 테이블은 쿼리에서 다음과 같이 표시됩니다.
Select * from department_Id;
Department_Id Employee_Eid
254 251
254 252
254 253
위 테이블에서 deparment_id 및 employee_id 필드는 부서 및 직원 테이블의 외래 키 (참조 필드)입니다.
MySQL 인터페이스에서 다음 쿼리를 전달하면 테이블 형식의 부서 테이블 결과가 쿼리에 다음과 같이 표시됩니다.
Select * from department;
Id Name
254 Development
MySQL 인터페이스에서 다음 쿼리를 전달하면 테이블 형식의 employee 테이블 결과가 쿼리에 다음과 같이 표시됩니다.
Select * from employee;
Eid Deg Ename Salary
251 Technical Writer Satish 45000
252 Technical Writer Krishna 45000
253 Technical Writer Masthanvali 50000
@OneToOne 관계
일대일 관계에서 한 항목은 다른 항목 하나에 만 속할 수 있습니다. 이는 한 엔티티의 각 행이 다른 엔티티의 한 행만 참조됨을 의미합니다.
위의 예를 살펴 보겠습니다. Employee 과 Department역 단방향 방식으로 관계는 일대일 관계입니다. 이는 각 직원이 한 부서에만 속함을 의미합니다. Eclipse IDE에서 JPA 프로젝트를 작성하십시오.JPA_Eclipselink_OTO. 이 프로젝트의 모든 모듈은 다음과 같이 표시됩니다.
엔티티 생성
엔티티를 생성하려면 위의 주어진 다이어그램을 따르십시오. 이름이 지정된 패키지 만들기‘com.tutorialspoin.eclipselink.entity’ 아래에 ‘src’꾸러미. 이름이 지정된 클래스 만들기Department.java주어진 패키지에서. 클래스 Department 엔티티는 다음과 같이 표시됩니다.
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;
}
}
이 관계 -Employee 엔터티 클래스에서 두 번째 엔터티를 만듭니다. Employee.java 아래에 ‘com.tutorialspoint.eclipselink.entity’꾸러미. Employee 엔티티 클래스는 다음과 같이 표시됩니다.
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은 JPA 프로젝트를 생성하는 동안 Eclipse IDE에 의해 생성됩니다. 구성 세부 사항은 사용자 사양입니다. persistence.xml 파일은 다음과 같이 표시됩니다.
<?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>
서비스 등급
이 모듈에는 속성 초기화를 사용하여 관계형 부분을 구현하는 서비스 클래스가 포함되어 있습니다. 아래에 패키지 만들기‘src’ 패키지 이름 ‘com.tutorialspoint.eclipselink.service’. 명명 된 DAO 클래스OneToOne.java주어진 패키지 아래에 생성됩니다. DAO 클래스는 다음과 같이 표시됩니다.
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();
}
}
위 프로그램을 컴파일하고 실행하면 Eclipse IDE의 콘솔 패널에 알림이 표시됩니다. 출력의 경우 다음과 같이 MySQL 워크 벤치를 확인하십시오. 위의 예에서는 두 개의 테이블이 생성됩니다.
MySQL 인터페이스에서 다음 쿼리를 전달하고 department 테이블 형식의 테이블은 쿼리에서 다음과 같이 표시됩니다.
Select * from department
Id Name
301 Development
MySQL 인터페이스에서 다음 쿼리를 전달하고 employee 테이블 형식의 테이블은 쿼리에서 다음과 같이 표시됩니다.
Select * from employee
Eid Deg Ename Salary Department_id
302 Technical Writer Satish 45000 301
@ManyToMany 관계
다 대다 관계는 한 엔터티의 하나 이상의 행이 다른 엔터티의 두 개 이상의 행과 연결되는 경우입니다.
Class와 Teacher 엔티티 간의 관계 예를 고려해 보겠습니다. 양방향 방식으로 Class와 Teacher는 다 대일 관계를 갖습니다. 즉, Class의 각 레코드는 Teacher 세트 (교사 ID)에 의해 참조되며 이는 Teacher 테이블의 기본 키 여야하며 Teacher_Class 테이블에 저장되어야하며 그 반대의 경우도 마찬가지입니다. 여기에서 Teachers_Class 테이블에는 두 외래 키 필드가 모두 포함됩니다. Eclipse IDE에서 JPA 프로젝트를 작성하십시오.JPA_Eclipselink_MTM. 이 프로젝트의 모든 모듈은 다음과 같이 표시됩니다.
엔티티 생성
엔티티를 생성하려면 위의 주어진 다이어그램을 따르십시오. 이름이 지정된 패키지 만들기‘com.tutorialspoin.eclipselink.entity’ 아래에 ‘src’꾸러미. 이름이 지정된 클래스 만들기Clas.java주어진 패키지에서. 클래스 Department 엔티티는 다음과 같이 표시됩니다.
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;
}
}
이 관계 -Employee 엔터티 클래스에서 두 번째 엔터티를 만듭니다. Teacher.java 아래에 ‘com.tutorialspoint.eclipselink.entity’꾸러미. Employee 엔티티 클래스는 다음과 같이 표시됩니다.
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은 JPA 프로젝트를 만드는 동안 Eclipse IDE에 의해 생성됩니다. 구성 세부 사항은 사용자 사양입니다. persistence.xml 파일은 다음과 같이 표시됩니다.
<?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>
서비스 등급
이 모듈에는 속성 초기화를 사용하여 관계형 부분을 구현하는 서비스 클래스가 포함되어 있습니다. 아래에 패키지 만들기‘src’ 패키지 이름 ‘com.tutorialspoint.eclipselink.service’. 명명 된 DAO 클래스ManyToMany.java주어진 패키지 아래에 생성됩니다. DAO 클래스는 다음과 같이 표시됩니다.
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( );
}
}
위 프로그램을 컴파일하고 실행하면 Eclipse IDE의 콘솔 패널에 알림이 표시됩니다. 출력의 경우 다음과 같이 MySQL 워크 벤치를 확인하십시오. 이 예제 프로젝트에서는 세 개의 테이블이 생성됩니다.
MySQL 인터페이스에서 다음 쿼리를 전달하고 teacher_clas 테이블 형식의 테이블은 쿼리에서 다음과 같이 표시됩니다.
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
위 테이블에서 teacher_tid는 teacher 테이블의 외래 키이고 classet_cid는 클래스 테이블의 외래 키입니다. 따라서 다른 교사는 다른 클래스에 할당됩니다.
MySQL 인터페이스에서 다음 쿼리를 전달하면 테이블 형식의 teacher 테이블 결과가 쿼리에 다음과 같이 표시됩니다.
Select * from teacher;
Tid Subject Tname
354 Java Satish
355 Adv Java Krishna
356 DB2 Masthanvali
MySQL 인터페이스에서 다음 쿼리를 전달하고 clas 테이블 형식의 테이블은 쿼리에서 다음과 같이 표시됩니다.
Select * from clas;
cid Cname
351 1st
352 2nd
353 3rd