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 untuk
digunakan apabila Anda membutuhkan pengolahan
database di Java sebagai alternatif yg lebih baik
dibandingkan 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 menggunakan
ANNOTATIONS
ORM
Java class Entity class
Java class biasa dapat dengan mudah diubah
menjadi entity class dengan menambahkan
annotation.
Simple diagram:
Employee class
ORM (annotation)
Employee Entity
Introduction to Entity Beans
Entity Bean merepresentasikan suatu objek
bisnis 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 tabel
di database, dan setiap instance dari entity
bean berkorespondensi dengan sebuah baris
pada 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 untuk
melakukan proses persisting (insert), pencarian
(query), penghapusan (delete), dan update entity.
Sekumpulan intance dari managed entity dikenal
sebagai persistence context.
Setiap persistence context ini berasosiasi dengan
satu set instance/object dari entity.
Misalnya: apabila ada 10 client mengakses suatu
entity 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.java
package 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.java
package mypkg.session;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import mypkg.entity.Customer;
import javax.persistence.PersistenceContext;
@Stateless
public 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<Customer> findAllCustomer() {
Query query = em.createQuery("SELECT c FROM Customer c");
return (Collection<Customer>) 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
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
<persistence-unit name="BankServicePU"/>
</persistence>
File persistence.xml diperlukan pada saat aplikasi menggunakan layanan
EntityManager
Pada contoh kasus di atas kita menggunakan atribut name untuk
mendefinisikan 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.java
package 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.