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<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.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.