Merhaba Arkadaslar
Bu bolumde Entity Relationship konusuna giris yapacagiz ve Single–Valued Relationships konusunu inceleyecegiz. ManyToOne ve OneToOne iliskiler Single–Valued Relationship ozelligi gosterir. Burada ilk olarak ManyToOne iliskiyi inceleyecegiz.

Entity Relationships

Onceki bolumde , konsepti daha iyi anlayabilmek icin alt yapi bilgilerini vermeye calistik.
Her bir Mapping icin source ve target (kaynak ve hedef) rol icin cardinality(nicelik) ismi kullanilir. Cardinality(nicelik) olarak ya One ya da Many olma durumu soz konusudur. Bu nedenle su 4 durum ortaya cikacaktir.

• Many to One
• One to One
• One to Many
• Many to Many

Bu Mapping isimleri ayni isimde annotationlara karsilik gelmektedir.

• @ManyToOne
• @OneToOne
• @OneToMany
• @ManyToMany

Unidirectional vs Bidirectional Relationship
Onceki bolumde Directionality kavramini incelemistik.Bir iliskide  bu 2 Entity’den sadece bir tanesi digerini gosteriyorsa bu durumda iliski unidirectional ‘dir. Eger ikiside birbirlerini gosteriyorsa bu durumda iliski bidirectional ‘dir.

• Entity Relationship/Iliskiler bidirectional ya da unidirectional olabilir.
• Bidirectional relationship hem owning side hem inverse(ters) side’a sahiptir.
• Unidirectional relationship sadece owning side’a sahiptir.

Single-Valued Relationships

Bir iliskide target/hedef Cardinality “One” ise bu iliski turu Single-Valued ‘tur.

• ManyToOne
• OneToOne iliskiler Single Valued Relationship ozelligi gosterirler.

Many To One Mapping

ManyToOne iliskiye ornek olarak Employee ve Department iliskisini verebiliriz. Bir calisan(Employee) bir departmanda calisir , bir departmanda ise birden fazla isci calisir.

Unidirectional Many To One Relationship
Burada Unidirectional ManyToOne Mapping’i inceleyecegiz. OneToMany Mapping’i inceledigimizde bidirectional OneToMany/ManyToOne iliskisini de inceleyecegiz.

Employee ve Department olmak uzere 2 tane Entity’miz olsun. Employee14 ManyToOne iliskide Many tarafi olacaktir , bu nedenle @ManyToOne annotation’i Employee14 sinifimizda yer alacaktir.

Employee14.java

package _14.manyToOne.uni.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Employee14 {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private int id;
	private String name;
	private String surname;
	private int salary;

	@ManyToOne
	private Department department;

	//constructors 
	//getters and setter
	//toString

}

Employee14 sinifimizda Department sinifi tipinde bir instance variable/field yer almaktadir. @ManyToOne annotation’i Employee14 sinifimizda bu degisken uzerine yazariz , cunku Many tarafi Employee14 One tarafi Department ‘dir.

ManyToOne
Employee14--->Many , owning side
Department--->One

Department.java

package _14.manyToOne.uni.model;

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;

	//constructors
	//getters and setters
        //toString

}

Department sinifimizda herhangi bir ekstra durum bulunmamaktadir. Basit olarak bir Entity tanimi yapiyoruz. Unidirectional bir iliski oldugu icin Department sinifinda Employee14 sinifi tipinde bir instance variable yer almamaktadir.

Yani unidirectional bir iliskide sadece bir tarafta diger sinif tipinde bir instance variable/field yer alabilir , karsilikli olarak her iki sinifta da yer aldigi durumda iliski unidirectional degil bidirectional olacaktir.

Siniflarimizi EclipseLink icin persistence.xml dosyamiza ekleyelim ;

	<class>_14.manyToOne.uni.model.Employee14</class>
	<class>_14.manyToOne.uni.model.Department</class>

EmployeeService.java

package _14.manyToOne.uni.service;

import _14.manyToOne.uni.model.Employee14;

public interface EmployeeService {

	public Employee14 createEmployee(String name, String surname, int salary);

	public Employee14 findEmployee(int id);
}

EmployeeServiceImpl.java

package _14.manyToOne.uni.service;

import javax.persistence.EntityManager;

import _14.manyToOne.uni.model.Employee14;

public class EmployeeServiceImpl implements EmployeeService {

	private EntityManager entityManager;

	public EmployeeServiceImpl(EntityManager entityManager) {
		this.entityManager = entityManager;
	}

	@Override
	public Employee14 createEmployee(String name, String surname, int salary) {
		Employee14 employee = new Employee14(name, surname, salary);
		entityManager.persist(employee);
		return employee;
	}

	@Override
	public Employee14 findEmployee(int id) {
		return entityManager.find(Employee14.class, id);
	}

}

DepartmentService.java

package _14.manyToOne.uni.service;

import _14.manyToOne.uni.model.Department;

public interface DepartmentService {

	public Department createDepartment(String name);
}

DepartmentServiceImpl.java

package _14.manyToOne.uni.service;

import javax.persistence.EntityManager;

import _14.manyToOne.uni.model.Department;

public class DepartmentServiceImpl implements DepartmentService{

	private EntityManager entityManager;

	public DepartmentServiceImpl(EntityManager entityManager) {
		this.entityManager = entityManager;
	}

	public Department createDepartment(String name) {
		Department dept = new Department(name);
		entityManager.persist(dept);

		return dept;
	}
}

EmployeeTest.java

package _14.manyToOne.uni.test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

import _14.manyToOne.uni.model.Department;
import _14.manyToOne.uni.model.Employee14;
import _14.manyToOne.uni.service.DepartmentService;
import _14.manyToOne.uni.service.DepartmentServiceImpl;
import _14.manyToOne.uni.service.EmployeeService;
import _14.manyToOne.uni.service.EmployeeServiceImpl;

public class EmployeeTest {

	public static void main(String[] args) {
		EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("EmployeePersistenceUnit");
		EntityManager entityManager = entityManagerFactory.createEntityManager();
		EntityTransaction entityTransaction = entityManager.getTransaction();

		EmployeeService employeeService = new EmployeeServiceImpl(entityManager);

		entityTransaction.begin();
		Employee14 employee = employeeService.createEmployee("Levent", "Erguder", 1000);
		Employee14 employee2 = employeeService.createEmployee("James", "Gosling", 10000);
		Employee14 employee3 = employeeService.createEmployee("Joshua", "Bloch", 10000);
		entityTransaction.commit();

		System.out.println("Persisted :" + employee);
		System.out.println("Persisted :" + employee2);
		System.out.println("Persisted :" + employee3);

		DepartmentService departmentService = new DepartmentServiceImpl(entityManager);

		entityTransaction.begin();
		Department department = departmentService.createDepartment("Junior Developers Dept.");
		Department department2 = departmentService.createDepartment("Master Developers Dept.");
		entityTransaction.commit();

		System.out.println("Persisted :" + department);
		System.out.println("Persisted :" + department2);

		entityTransaction.begin();
		employee.setDepartment(department);
		employee2.setDepartment(department2);
		employee3.setDepartment(department2);
		entityTransaction.commit();

		System.out.println("Finding...");
		Employee14 emp = employeeService.findEmployee(1);
		System.out.println(emp);

		entityManager.close();
		entityManagerFactory.close();

	}
}

Kodu inceleyecek olursak , onceki orneklerde oldugu gibi 3 tane Employee(14) objemizi olusturduk ve veritabanina kaydettik/persist. Daha sonrasinda benzer sekilde 2 tane Department objesi olusturduk ve veritabanina kaydettik/persist.
Son olarak Employee(14) objeleri referans degiskenleri uzerinden setDepartment metodunu cagirdik, bu metotlara arguman olarak Department obje referanslari veriyoruz. Burada onemli olan nokta bu set isleminin bir transaction icerisinde yapilmis olmasi. Boylelikle yapilan bu degisiklik veritabanina yansitilmaktadir.

Ornegimizi calistirdigimizda Employee14 ve Department tablolarimiz olusacaktir.

Employee14 ve Department tablomuz arasindaki ManyToOne iliskisi sonucu Employee tablomuzda “department_id” foreign key kolonu olusacaktir. Employee14 sinifimizda “department” field degeri (instance variable) ve Department sinifimizda “id” field degeri(instance variable) kullanilir. Dolayisiyla “department_id” kolonu olusacaktir.

Eger Field Access yerine Property Access yaklasimi kullanilsaydi bu durumda getter metodunun ismine gore kolon/column olusacakti.

Varsayilan olarak verilen bu kolon ismini degistirmek istersek bu durumda @JoinColumn annotation kullanabiliriz.
@JoinColumn‘u @ManyToOne annotation ile birlikte kullaniriz. ManyToOne bir iliskide owning side her zaman Many tarafidir.Convetion geregi logical annotation’lar  , physical annotation’lardan once olmalidir. Yani @ManyToOne annotation once tanimlanmalidir.

Employee14.java

package _14.manyToOne.uni.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

@Entity
public class Employee14 {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private int id;
	private String name;
	private String surname;
	private int salary;

	@ManyToOne
        @JoinColumn(name = "DEPT_ID")
	private Department department;

	//constructors
	//getters and setter
	//toString
}

Ornegimizi tekrar calistirdigimizda , department_id yerine dept_id kolonu olustugunu gorebiliriz.

Yazimi burada sonlandiriyorum.
Herkese Bol Javali Gunler dilerim.
Be an oracle man , import java.*;
Levent Erguder
OCP, Java SE 6 Programmer
OCE, Java EE 6 Web Component Developer