Java Persistence API ile yazılım dünyasında CRUD olarak adlandırılan veritabanı işlemleri yapacağız. Ekleme, silme, güncelleme gibi fonksiyonlar kullanarak MySQL üzerinde çalışacağız. Sizler farklı veritabanları kullanabilirsiniz.(Oracle, MsSQL, Sql Server, MongoDB vb.)
JPA hakkında genel bilgilere bir önceki makalelerimi okuyarak ulaşabilirsiniz. Bu yazıda temel açıklamalardan çok, kodlar olacak haber vereyim dedim 🙂
CRUD : Veri depolama kullanılan 4 temel fonksiyondur. Create, Read, Update, Delete kelimelerinin baş harflerinden oluşmaktadır.
⇒ İlk olarak normal Java SE projesi oluşturup onu Maven projesine çeviriyoruz.
Maven: Kısaca, projemiz için bir standart oluşturup, geliştirme sürecimizi basitleştiren, IDE bağımlılığını ve Kütüphane bağımlılıklarını ortadan kaldırmamızı sağlayan bir araçtır.
⇒ İkinci adım ise kullanacağımız kütüphanelerin dependencies’lerini(bağımlılıkları) pom.xml dosyasına eklememiz gerekmekte. Veritabanı olarak MySQL, JPA aracı olarak EclipsLink kullanacağız. Pom.xml dosyamız şu şekilde olmalı.
Pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>JPAWithCRUD</groupId>
<artifactId>JPAWithCRUD</artifactId>
<version>0.0.1-SNAPSHOT</version>
<build>
<sourceDirectory>src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.eclipse.persistence/eclipselink -->
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>eclipselink</artifactId>
<version>2.6.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>6.0.6</version>
</dependency>
</dependencies>
</project>
Bu Adımı gerçekleştirdikten sonra Maven Dependencies kısmına baktığınızda gerekli dosyaların otomatik olarak eklemiş olduğunu görüyoruz.
=> Üçüncü adımda ise verimizin kalıcılığını sağlamak adına kullanacağımız " persistence.xml " dosyamızı src klasörümüzün altında META-INF klasörünün içerisinde olacak şekilde ayarlıyoruz. Bu dosyayı veritabanı bağlantıları ve Entity sınıfıları tanımlamak için kullanıyoruz.
META-INF / persistence.xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
<!-- Persistence-unit tanımlıyoruz. Birden fazlada tanımlanabilir. -->
<persistence-unit name="JPA" transaction-type="RESOURCE_LOCAL">
<!-- EclipseLink kullanırken @Entity notasyonu ile işaretlenmiş sınıfları buraya ekliyoruz.-->
<class>model.Student</class>
<!-- Gerekli özellikleri <properties> tagı içerisinde tanımlıyoruz. -->
<properties>
<!-- MySQL hangi adreste çalışıyorsa onu giriyoruz.
/jpa kısmı MySQL'de oluşturduğumuz shema kısmı oluyor.
?serverTimezone=UTC kısmı veritabanında bulunan zaman problemini gidermek için kullanıyoruz. -->
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa?serverTimezone=UTC"/>
<!-- Driver bilgisini tanımlıyoruz. -->
<property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
<!-- Kullanıcı adını ve şifre bilgilerini tanımlıyoruz. -->
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password" value="123"/>
<!-- Tablomozun nasıl oluşturulacağını tanımlıyoruz. (Diğer oluşturma şekilleri makalede var.) -->
<property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
</properties>
</persistence-unit>
</persistence>
<property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
kısmında tablomuzun nasıl oluşturulacağını belirliyorduk. Tablomuzun nasıl oluşturulacağını belirlemek için aşağıda bulunan 5 seçenekten birini seçmeliyiz.
Bunlar;
- drop-and-create-tables -> Uygulama başlatıldığında tabloları siler ve yeniden oluştur.
- create-or-extends-tables -> Uygulama başlatıldığında tabloları oluştur. Eğer tablolar var ise günceller.
- drop-tables -> Tabloları siler.
- create-tables -> Tabloları oluştur.
- none -> Default olarak none çalışır.
Unutmayalım : MySQL Workbench aracılığı ile persistence.xml de verilen localhost:3306/jpa adresi için bir schema oluşturmalıyız.
=> Dördüncü adıma geldiğimizde geriye yazılımımızı yazmamız kaldı. Ben bu projede basit olarak bir Öğrenci modelledim.
Bu öğrenciyi veritabanına ekleme, silme, güncelleme işlemleri yapıp, veritabanımızda bulunan tüm öğrencileri listeleyip bize geri dönderen bir program yazacağım.
Projemiz yapısı olarak 3 adet paketten/katmandan oluşacak. Bunlar;
- DAO -> Veritabanı işlemlerini(ekleme, silme, güncelleme vs.) yapacağımız katman.
- MODEL -> Veritabanına ekleyeceğimiz Entitylerimizin olduğu katman.
- TEST -> Yazılımımızı test etmek için oluşturduğumuz katman.
İlk olarak oluşturduğumuz yapıda MODEL katmanındaki sınıfı inceleyelim. Bizim bir entity'e ihtiyacımız var ve bunun için Student.java dosyasını oluşturup Öğrencimizi modelliyoruz.
Student.java
package model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
// Oluşturduğumuz modeli Entity olarak işaretliyoruz.
@Entity
public class Student {
// Sınıfımıza Entity özelliği kazandırabilmek için Primary key bilgisi vermek zorundayız.
// Bunu @Id annotationı ile yapıyoruz.
// @GeneratedValue kısımında GenerationType.AUTO yaptığımız için eklenen her kayıtın otomatik olarak id değerini arttırımını sağlar.
// Auto Increment gibi düşünülebilir bu mantık.
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private int id;
private String isim;
private String soyisim;
private String bolum;
private double ortalama;
// Sınıfımızın Entity özelliği kazanabilmesi için public no-arg constructor'a sahip olması gerekmekte!
public Student() {
super();
}
public Student(String isim, String soyisim, String bolum, double ortalama) {
super();
this.isim = isim;
this.soyisim = soyisim;
this.bolum = bolum;
this.ortalama = ortalama;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getIsim() {
return isim;
}
public void setIsim(String isim) {
this.isim = isim;
}
public String getSoyisim() {
return soyisim;
}
public void setSoyisim(String soyisim) {
this.soyisim = soyisim;
}
public String getBolum() {
return bolum;
}
public void setBolum(String bolum) {
this.bolum = bolum;
}
public double getOrtalama() {
return ortalama;
}
public void setOrtalama(double ortalama) {
this.ortalama = ortalama;
}
@Override
public String toString() {
return "Student [id=" + id + ", isim=" + isim + ", soyisim=" + soyisim + ", bolum=" + bolum + ", ortalama="
+ ortalama + "]";
}
}
Oluşturduğumuz yapıda DAO katmanındaki sınıfları ve kodları inceleyelim.
StudentDAO adında bir interface sınıfı oluşturup ekleme, silme, güncelleme, listeleme gibi metodların sadece isimlerini verip, StudentDAOImp sınıfında ise bu metodların içini dolduruyoruz. Bu yapı bize sonradan proje içerisinde kolay güncellemelere, yeni özelliklerin kolay entegre edilmesine olanak sağlıyor.
StudentDAO.java
package dao;
import java.util.List;
import model.Student;
public interface StudentDAO {
// Veritabanımıza kayıt yapmak için kullandığımız metod
public void insertStudent(Student student);
// Veritabanımızdan kayıt silmek için kullandığımız metod
public void deleteStudent(int id);
// Öğrencinin ortalamasını güncellememizi sağlayan metod
public void updateAverage(int id, double average);
// Öğrencinin id bilgisini dönderen metod
public Student getStudentId(int id);
// // Veritabanımızda bulunan tüm öğrencileri listelemek için kullandığımız metod
public List<Student> allStudent();
}
StudentDAOImp.java
package dao;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import model.Student;
public class StudentDAOImp implements StudentDAO {
private EntityManager entityManager;
// Dışarıdan entityManager nesnesini alıyoruz.
public StudentDAOImp(EntityManager entityManager) {
this.entityManager = entityManager;
}
/**
* Veritabanına kaydetme, silme ve güncelleme işlemlerinde transaction kullanılmalı.
* Kullanılmaz ise yaptığımız işler veritabanına yansımayacak.
* Yapılan iş(ekleme, silme, güncelleme vs.) begin ve commit metodları arasında olmalı.
*/
@Override
public void insertStudent(Student student) {
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
// Persist metodu bize JPA'nın sağladığı Sql sorgusu yazmadan veritabanına ekleme imkanı sunmakta.
entityManager.persist(student);
transaction.commit();
}
@Override
public void deleteStudent(int id) {
// Silmek için ilk önce verilen id'ye göre öğrenci bulunması gerekmekte.
Student student = getStudentId(id);
EntityTransaction transaction = entityManager.getTransaction();
// Daha sonra Remove metodu ile veritabanımızdan kayıtı silme işlemini gerçekleştiriyoruz.
transaction.begin();
entityManager.remove(student);
transaction.commit();
}
@Override
public void updateAverage(int id, double ortalama) {
Student student = getStudentId(id);
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
student.setOrtalama(ortalama);
transaction.commit();
}
@Override
public Student getStudentId(int id) {
// Find metodu verilen id bilgisine göre veritabanında arama yapmamıza olanak sağlamakta.
// bu metodda transaction açmadık çünkü sadece okuma işlemi yaptık.
Student student = entityManager.find(Student.class, id);
return student;
}
@Override
public List<Student> allStudent() {
// En basit şekilde bir sorgu oluşturup veritabanımızdaki tüm Öğrencileri getirip,
// getResultList metodu ile bize sonucu liste şeklinde döndürmesini sağlıyoruz.
return entityManager.createQuery("select e from Student e", Student.class).getResultList();
}
}
StudentDAOImp.java · GitHub Gist
Son olarak kodlarımızı test edeceğimiz sınıfımıza gelelim.
Test.java
package test;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import dao.StudentDAO;
import dao.StudentDAOImp;
import model.Student;
public class Test {
public static void main(String[] args) {
/**
* Persistence-unit bilgilerine yani veritabanı bilgilerimize ulaşmak için
* öncelikle EntityManagerFactoy oluşturuyoruz. persistence.xml dosyamızda
* <persistence-unit name="JPAtest"> olan kısımdaki ismi buraya veriyor,
* sonrasonda bu fabrikadan da bir EntityManager oluşturuyoruz.
*/
EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("JPAtest");
EntityManager entityManager = entityManagerFactory.createEntityManager();
// Sonrasında oluşturduğumuz entityManager'ı metodları çalıştıracak olan sınıfa
// veriyoruz.
StudentDAO studentDAO = new StudentDAOImp(entityManager);
Student student1 = new Student("Yusuf", "Genç", "Bilgisayar", 2.5);
Student student2 = new Student("Ömer", "Genç", "Yazılım", 2.8);
Student student3 = new Student("Faruk", "Genç", "Kamu", 3.0);
System.out.println(" --- Öğrenciler Eklendi ---");
System.out.println();
studentDAO.insertStudent(student1);
studentDAO.insertStudent(student2);
studentDAO.insertStudent(student3);
List<Student> studentList = studentDAO.allStudent();
for (Student student : studentList) {
System.out.println(student);
}
System.out.println();
System.out.println(" --- 1 numaralı öğrenci silindi. ---");
System.out.println();
studentDAO.deleteStudent(1);
List<Student> studentList2 = studentDAO.allStudent();
for (Student student : studentList2) {
System.out.println(student);
}
System.out.println();
System.out.println(" --- 2 numaralı öğrencinin ortalaması 3.5 olarak güncellendi. ---");
System.out.println();
studentDAO.updateAverage(2, 3.5);
List<Student> studentList3 = studentDAO.allStudent();
for (Student student : studentList3) {
System.out.println(student);
}
System.out.println("");
}
}
Java Persistence API'nin Mimarisi
EntityManagerFactory : Persistence tarafından oluşturulur ve birden fazla EntityManager yaratıp, yönetebilir. Persistence Unit ile yapılandırılır.
EntityManager: Nesneler üzerinde kalıcılık sağlamak adına kullanılır. Sorgular için bir fabrika gibi çalışır. (ekleme, silme, güncelleme gibi işlemleri yapmamızı sağlayan metodları içerir.)
Projeye Github üzerinden ulaşabilir, kodları inceleyebilirsiniz.
