171_Week 08 - Entity Beans Dan Java Persistence API
description
Transcript of 171_Week 08 - Entity Beans Dan Java Persistence API
-
Pemrograman Web Lanjut
2010 Niko Ibrahim, MIT
Fakultas Teknologi Informasi
Universitas Kristen Maranatha
Week 08
Entity Beans dan Java Persistence API
-
Lecture"s Outline
Pengenalan Entity Beans
Annotation & Mapping Entity Beans
Sample Tutorial: ENTITY BEAN +
SESSION BEAN
-
The Java Persistence API
Java Persistence API (JPA) adalah suatu framework untuk menangani permasalahan database di Java.
JPA cukup simpel, flexible dan powerful untukdigunakan apabila Anda membutuhkan pengolahandatabase di Java sebagai alternatif yg lebih baikdibandingkan teknologi JDBC.
The model of the Java Persistence API is simple and elegant, powerful and flexible. It is natural to use, and easy to learn.
Library JPA yang paling populer saat ini: TopLink dari Oracle (Tersedia open source: TopLink
Essentials)
Hibernate (open source) EclipseLink
-
Object-Relational Mapping
The domain model has a class. The database has a table. They look pretty similar. It should be simple to convert from one to the other automatically.
The science of bridging the gap between the object model and the relational model is known as object-relational mapping (ORM)
Contoh: Class diagram Employee & Tabel Emp
Pada Java, Proses Mapping ini dapat dilakukan dengan menggunakanANNOTATIONS
ORM
-
Java class Entity class
Java class biasa dapat dengan mudah diubahmenjadi entity class dengan menambahkanannotation.
Simple diagram:
Employee class
ORM (annotation)
Employee Entity
-
Introduction to Entity Beans
Entity Bean merepresentasikan suatu objekbisnis di dalam tempat penyimpanan data.
Contoh objek bisnis: customers, orders, products, dll.
Pada Java EE, mekanisme penyimpanan data adalah dengan menggunakan basis data relasional (RDBMS). Biasanya, setiap entity bean berkorespondensi dengan sebuah tabeldi database, dan setiap instance dari entity bean berkorespondensi dengan sebuah barispada tabel tersebut.
-
More about Entity Beans
Entity bean tidak memiliki logika bisnis (paling hanya memiliki validasi)
Entity bean bersifat persistent (menetap/konstan/disimpan), dapat
diakses secara shared oleh multiple clients, memiliki primary keys, dan
dapat memiliki relasi dengan entity bean lainnya.
Selain menyimpan instance entity, kita juga dapat melakukan query,
update, dan menghapusnya.
Di dalam Java EE, Entity Bean dipaketkan di dalam spesifikasi
tersendiri yang disebut dengan: Java Persistence API (JPA). Tujuannya:
siapapun dapat memanfaatkan JPA tanpa perlu harus menggunakan
Java EE secara arsitektural keseluruhan aplikasi.
Beberapa vendor telah mengimplentasikan JPA sebagai produk open
source maupun komersil: Hibernate & Oracle TopLink
-
Intro to Annotations
Annotation metadata is a language feature
that allows structured and typed metadata
(nama tabel, nama kolom, constraint) to be
attached to the source code.
Cara lain selain menggunakan Annotations
adalah dengan menggunakan file XML
sebagai file konfigurasi pemetaan.
@
-
Annotations pada Entity Bean
Pada contoh kasus di sini, kita menggunakan dua
buah annotation: @Entity dan @Id
Annotation @Entity memberikan perintah kepada
persistence engine bahwa class tersebut adalah
sebuah entity bean. Penempatan annotation adalah
tepat di atas pendefinisian class.
Annotation @Id menentukan primary key dari
entity tersebut. Kita dapat meletakkan annotation
ini di atas property (int id) atau di atas method
getter suatu property (getId())
-
Employee (Java Bean Class)public class Employee {
private int id;
private String name;
private long salary;
public Employee() {}
public Employee(int id) { this.id = id; }
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public long getSalary() { return salary; }
public void setSalary (long salary) { this.salary = salary; }
}
-
Employee (Entity Bean Class)import javax.persistence.*;
@Entity
public class Employee {
@Id private int id;
private String name;
private long salary;
public Employee() {}
public Employee(int id) { this.id = id; }
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public long getSalary() { return salary; }
public void setSalary (long salary) { this.salary = salary; }
}
-
Contoh 2 Entity Bean: Customer.java
Jadi: pada JPA,
setiap java
class/POJO
(Plain Old Java
Object) dapat
dikonversi
menjadi
entitybean
dengan sedikit
modifikasi.
package mypkg.entity;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Customer implements java.io.Serializable {
@Id
private int id;
private String firstName;
private String lastName;
public Customer() {}
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getFirstname() { return firstName; }
public void setFirstname(String firstName) {
this.firstName = firstName;
}
public String getLastname() { return lastName; }
public void setLastname(String lastName) {
this.lastName = lastName;
}
public String toString() {
return "[Customer Id =" + id + ",first name=" +
firstName + ",last name=" + lastName + "]";
}
}
-
Contoh skema relasi antar Entity Bean Class
-
EntityManager
Entity Manager adalah suatu layanan (service) yang disediakan oleh persistence engine.
Layanan ini menyediakan method-method untukmelakukan proses persisting (insert), pencarian(query), penghapusan (delete), dan update entity.
Sekumpulan intance dari managed entity dikenalsebagai persistence context.
Setiap persistence context ini berasosiasi dengansatu set instance/object dari entity.
Misalnya: apabila ada 10 client mengakses suatuentity bean, maka server akan memiliki 10 persistence context.
-
Tutorial Singkat
Entity Beans & Session Beans Pada tutorial ini, kita akan membuat entity
bean yang diakses melalui session bean.
Kita akan gunakan sebuah local stateless session
bean sebagai proses bisnis dari entitas
Customer. Kita namakan session bean ini
BankService.
Aplikasi ini masih sederhana karena hanya
mengelola:
satu entitas Customer dan
dua proses bisnis: addCustomer() & findCustomer().
-
Session Bean Interface:
BankService.javapackage mypkg.session;
import javax.ejb.Remote;
import mypkg.entity.Customer;
@Local
public interface BankService {
void addCustomer(int custId, String firstName, String lastName);
Customer findCustomer(int custId);
}
-
session bean implementation:
BankServiceBean.javapackage mypkg.session;import javax.ejb.Stateless;import javax.persistence.EntityManager;import mypkg.entity.Customer;import javax.persistence.PersistenceContext;
@Statelesspublic class BankServiceBean implements BankService {
@PersistenceContext(unitName="BankServicePU") private EntityManager em;
public Customer findCustomer(int custId) { return ((Customer) em.find(Customer.class, custId));
}
public void addCustomer(custId, String firstName, String lastName) { Customer cust = new Customer(); cust.setId(custId); cust.setFirstname(firstName); cust.setLastname(lastName); em.persist(cust);
}
-
Tambahan methods:~ remove, findAll, changeCustomerName
public void removeCustomer(int custId) {Customer cust = findCustomer(custId);if (cust != null) {
em.remove(cust);}
}
public Collection findAllCustomer() {Query query = em.createQuery("SELECT c FROM Customer c");return (Collection) query.getResultList();
}
public Customer changeCustomerName (int CustId, String firstName, String lastName) {Customer cust = em.find(Customerclass, custId);if (cust != null) {
cust.setFirstName(firstName);cust.setLastName(lastName);
}return cust;
}
}
-
Configuration file: persistence.xml
File persistence.xml diperlukan pada saat aplikasi menggunakan layananEntityManager
Pada contoh kasus di atas kita menggunakan atribut name untukmendefinisikan persistence unit BankService
NOTE: nama di atas harus sama dengan unitName yang digunakan di anotasi@PersistenceContext sebelumnya
-
Penjelasan Tutorial
Statement:@PersistenceContext(unitName="BankServicePU")
private EntityManager em;
berfungsi mendefinisikan em sebagai sebuah
instance (objek) dari class EntityManager yang
memiliki persistence context dan nama unit-nya
BankService
-
addCustomer() method.
Statement:
Customer cust = new Customer();
berfungsi membuat instance (objek) dari
entitas Customer.
Namun sampai pada tahap ini, objek
entitas tsb tidak di-managed (belum dapat
dikelola oleh entity manager). Objek tsb
belum berasosiasi dengan persistence
context.
-
EntityManager.persist() method.
Statement:
em.persist(cust);
akan memanggil method EntityManager.persist().
Pada tahap ini, instance (objek) dari entitas belum
ditulis secara langsung ke database. Namun,
instance tsb telah di-managed/attached dan
berasosiasi dengan persistence context.
EntityManager lah yang akan memanage
sinkronisasi antara persistence context dan
database.
-
findCustomer() method.
Statement:
return ((Customer) em.find(Customer.class, custId));
akan memanggil method EntityManager.find()
Method ini berfungsi menemukan entitas berdasarkan
privary key.
Parameter dari method find() adalah kelas entitas dan
primary key-nya.
Pada contoh tutorial ini, primary key-nya adalah custId
EntitiyManager juga menyediakan suatu bahasa query
tersendiri yang disebut JPQL (Java Persistence Query
Language)
-
Example of Client Application: BankClient.javapackage mypkg.client;
import javax.naming.Context;
import javax.naming.InitialContext;
import mypkg.session.*;
import mypkg.entity.Customer;
import javax.ejb.EJB;
public class BankClient {
@EJB
private static BankService bank;
public static void main(String[] args) {
try {
int custId = 0;
String firstName = niko;
String lastName = ibrahim
// add customer to database
bank.addCustomer(custId, firstName, lastName);
Customer cust = bank.findCustomer(custId);
System.out.println(cust);
} catch (Throwable ex) {
ex.printStackTrace();
}
}
}
Berikut ini adalah contoh
aplikasi client yang mengakses
session bean BankService,
yaitu methods untuk
melakukan proses create dan
kemudian melakukan proses
find suatu entitas.
-
Next Topic
Entity Bean Class Relationship:
One-to-one
One-to-many
Many-to-many
Java Persistence Query Language (JPQL)
-
Summary
Entities are classes that need to be persisted, usually in a
relational database. The persistence aspects of EJB 3 have
been packaged as a separate specification, the Java
Persistence API (JPA), so that applications that do not need
EJB container services can still persist their entities to a
relational database.
Persistence services are handled by a persistence engine.
Any Java class, or POJO, can be converted to an entity using
metadata annotations.
We introduced the EntityManager service, which provides
methods for persisting and finding entities.