JPASelama ini, untuk mengakses database dengan java saya ajarkan pada mahasiswa menggunakan jdbc. Sebetulnya itu adalah cara klasik. Manipulasi data dengan jdbc masih menggunakan query, baik dengan statement (direct) atau pun dengan preparedstatement(indirect). Nah ada cara yang lebih mudah untuk hal itu, yaitu menggunakan framework relational data. Dengan cara ini bukan berarti tanpa menggunakan query sama sekali, tapi memang memungkinkan manipulasi data tanpa menggunakan query. Cara ini baru saya berikan pada mahasiswa jika mereka sudah memahami teknik manipulasi data dengan jdbc.

Saat ini banyak framework relational data yang bisa digunakan untuk membuat aplication dengan java. Salah satunya adalah Java Persistence API. JPA adalah sebuah framework dalam pemrograman java menggunakan pendekatan Obejct Relational Maping (ORM) untuk memanage atau mengatur relational data menggunakan platform Java Standard Edition dan Java Enterprise Edition.   JPA saat ini sudah dirilis versi 2.0 yang merupakan penerus dari versi sebelumnya. Pada versi 2.0 sudah dilengkapi dengan berbagai fitur yang semakin memudahkan programer untuk manipulasi data.

Dalam konteks ini,m JPA dibagi dalam tiga bagian:

  • API itu sendiri. API JPA terdapat dalam package javax.persistence
  • Query khusus JPA yaitu Java Persistence Query Language (JPQL)
  • Object/Relational metadata

Mengapa JPA lebih baik dari jdbc?, berikut adalah beberapa kenutungan penggunaan JPA:

  • Tidak perlu membuat query untuk manipulasi data
  • Dapat mudah mengelola transaksi dengan API
  • Tidak perlu membuat Data Access Object yang complex
  • Dapat digunakan untuk mengelola POJO (Plain Old Java Object)

Untuk membuat aplikasi menggunakan JPA, kita harus membuat class entitas yang merupakan permodelan(representas) table pada database. Untuk selanjutnya proses manipulasi data harus mengacu pada class entitas ini. Class ini dapat dibuat sendiri atau bisa juga menggunakan fitur generate pada netbeans. Berikut adalah contoh sederhana penggunaan JPA untuk memanipulasi tabel pada database.

Terlebih dahulu buat database dalam database mysql

1
2
3
4
5
6
7
8
9
10
11
DROP DATABASE IF EXISTS akademik;
CREATE DATABASE akademik;
CREATE TABLE `mahasiswa` (
  `nim` VARCHAR(14) NOT NULL,
  `nama` VARCHAR(40) DEFAULT NULL,
  `jurusan` VARCHAR(30) DEFAULT NULL,
  `alamat` VARCHAR(60) DEFAULT NULL,
  `email` VARCHAR(30) DEFAULT NULL,
  `telepon` VARCHAR(15) DEFAULT NULL,
  PRIMARY KEY (`nim`)
);

Selanjutnya buat class entitas Mahasiswa

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package demojpa.entity;
 
import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
 
/**
 *
 * @author ahza
 */
@Entity
@Table(name = "mahasiswa")
@NamedQueries({
    @NamedQuery(name = "Mahasiswa.findAll", query = "SELECT m FROM Mahasiswa m"),
    @NamedQuery(name = "Mahasiswa.findByNim", query = "SELECT m FROM Mahasiswa m WHERE m.nim = :nim"),
    @NamedQuery(name = "Mahasiswa.findByNama", query = "SELECT m FROM Mahasiswa m WHERE m.nama = :nama"),
    @NamedQuery(name = "Mahasiswa.findByJurusan", query = "SELECT m FROM Mahasiswa m WHERE m.jurusan = :jurusan"),
    @NamedQuery(name = "Mahasiswa.findByAlamat", query = "SELECT m FROM Mahasiswa m WHERE m.alamat = :alamat"),
    @NamedQuery(name = "Mahasiswa.findByEmail", query = "SELECT m FROM Mahasiswa m WHERE m.email = :email"),
    @NamedQuery(name = "Mahasiswa.findByTelepon", query = "SELECT m FROM Mahasiswa m WHERE m.telepon = :telepon")})
public class Mahasiswa implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @Basic(optional = false)
    @Column(name = "nim")
    private String nim;
    @Column(name = "nama")
    private String nama;
    @Column(name = "jurusan")
    private String jurusan;
    @Column(name = "alamat")
    private String alamat;
    @Column(name = "email")
    private String email;
    @Column(name = "telepon")
    private String telepon;
 
    public Mahasiswa() {
    }
 
    public Mahasiswa(String nim) {
        this.nim = nim;
    }
 
    public String getNim() {
        return nim;
    }
 
    public void setNim(String nim) {
        this.nim = nim;
    }
 
    public String getNama() {
        return nama;
    }
 
    public void setNama(String nama) {
        this.nama = nama;
    }
 
    public String getJurusan() {
        return jurusan;
    }
 
    public void setJurusan(String jurusan) {
        this.jurusan = jurusan;
    }
 
    public String getAlamat() {
        return alamat;
    }
 
    public void setAlamat(String alamat) {
        this.alamat = alamat;
    }
 
    public String getEmail() {
        return email;
    }
 
    public void setEmail(String email) {
        this.email = email;
    }
 
    public String getTelepon() {
        return telepon;
    }
 
    public void setTelepon(String telepon) {
        this.telepon = telepon;
    }
 
    @Override
    public int hashCode() {
        int hash = 0;
        hash += (nim != null ? nim.hashCode() : 0);
        return hash;
    }
 
    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Mahasiswa)) {
            return false;
        }
        Mahasiswa other = (Mahasiswa) object;
        if ((this.nim == null && other.nim != null) || (this.nim != null && !this.nim.equals(other.nim))) {
            return false;
        }
        return true;
    }
 
    @Override
    public String toString() {
        return "demojpa.entity.Mahasiswa[nim=" + nim + "]";
    }
}

Selanjutnya buat class Main dan methode main. Didalamnya buat code untuk insert data ke table mahasiswa.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package demojpa;
 
import demojpa.entity.Mahasiswa;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
 
/**
 *
 * @author ahza
 */
public class Main {
 
    /**
     * @param args the command line arguments
     */
    static EntityManagerFactory emf = Persistence.createEntityManagerFactory("DemoJPAPU");
    static EntityManager em = emf.createEntityManager();
    public static void main(String[] args) {
        em.getTransaction().begin();
        Mahasiswa m = new Mahasiswa("43A87006030124");
        m.setNama("Muhamad Nur");
        m.setJurusan("Manajemen Informatika");
        m.setAlamat("Cikarang, Bekasi");
        m.setEmail("alif.ivan@gmail.com");
        m.setTelepon("021-9099897");
        em.persist(m);
        em.flush();
        em.getTransaction().commit();
    }
}

dan untuk mengupdate data yang perlu dilakukan adalah rubah em.persist(m) menjadi em.merge(m). Object m dengan nim tersebut harus sudah ada dalam database, jika tidak akan dianggap sebagai insert baru.

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
        em.getTransaction().begin();
        Mahasiswa m = new Mahasiswa("43A87006030124");
        m.setNama("Ahza Muhamad Nur");
        m.setJurusan("Teknik Informatika");
        m.setAlamat("Cikarang, Bekasi");
        m.setEmail("alif.ivan@gmail.com");
        m.setTelepon("021-3454677");
        em.merge(m);
        em.flush();
        em.getTransaction().commit();
    }

Dan terakhir untuk menghapus data, gunakan code em.remove(rm) dimana rm adalah object yang didapat dari hasil pencarian dengan nim yang telah ditentukan.

1
2
3
4
5
6
7
8
public static void main(String[] args) {
        em.getTransaction().begin();
        Mahasiswa m = new Mahasiswa("43A87006030124"); 
        Mahasiswa rm = em.find(Mahasiswa.class, m.getNim());
        em.remove(rm);
        em.flush();
        em.getTransaction().commit();
    }

Demikian pengenalan JPA, diartikel yang lain akan saya bahas penggunaan JPA pada aplikasi GUI.