Java Netbeans Swing PDF
Java Netbeans Swing PDF
Java Desktop
Ifnu Bima
ifnu@artivisi.com
http://ifnu.artivisi.com
http://www.artivisi.com
Jakarta, 2008
Daftar Isi
Java Foundation Class.......................................................................................................1
Feature JFC...................................................................................................................1
Swing Package..............................................................................................................2
Swing HelloWorld........................................................................................................3
Install Java Development Kit...................................................................................3
Membuat program HelloWorld ...............................................................................3
Melakukan kompilasi program HelloWorld............................................................4
Menjalankan program HelloWorld..........................................................................4
Membuat Swing HelloWorld dengan Netbeans 6.1......................................................5
Komponen Swing ............................................................................................................7
Struktur Komponen Swing...........................................................................................7
Bekerja dengan JLabel, JTextField dan JButton...........................................................8
Bekerja dengan JCheckBox dan JRadioButton..........................................................11
Bekerja dengan JList dan JComboBox ......................................................................15
Bekerja dengan Menu, Popup Menu dan Toolbar......................................................18
Membuat Menu......................................................................................................19
Membuat Popup Menu .........................................................................................24
Membuat Toolbar...................................................................................................25
Membuat Dialog dan JFileChooser.............................................................................29
Membuat predefined dialog dengan JOptionPane................................................30
Membuat JFileChooser..........................................................................................35
Konsep MVC...................................................................................................................38
Model dalam Komponen Swing ................................................................................39
TableModel.................................................................................................................41
ListModel ...................................................................................................................42
Menangani Event.............................................................................................................44
Event Listener dalam Swing ......................................................................................45
ActionListener.............................................................................................................48
KeyListener.................................................................................................................50
HALAMAN III
MouseListener dan MouseMotionListener.................................................................52
Koneksi Database Dengan JDBC....................................................................................55
Mengenal JDBC..........................................................................................................55
Database Driver...........................................................................................................56
Membuat Koneksi.......................................................................................................56
Mengambil dan Memanipulasi Data dari Database....................................................58
Menggunakan PreparedStatement...............................................................................60
Batch Execution..........................................................................................................62
Menangani Transaction...............................................................................................62
DAO dan Service Pattern............................................................................................63
Java Persistence API (JPA).............................................................................................71
Perbedaan dialek SQL............................................................................................71
Perbedaan konsep relasional dan objectoriented..................................................72
Peningkatan kinerja................................................................................................73
Persiapan.....................................................................................................................74
Instalasi ..................................................................................................................74
Aplikasi Blog..........................................................................................................75
Fungsionalitas Aplikasi..........................................................................................75
Dasardasar ORM.......................................................................................................75
Mapping Sederhana................................................................................................75
Konfigurasi JPA.....................................................................................................76
Menyimpan dan Mengambil Object.......................................................................78
EntityManagerFactory............................................................................................79
Menyimpan object ke database..............................................................................79
Mengambil data dari database................................................................................80
Membuat skema database.......................................................................................81
Membuat CategoryDao..........................................................................................81
Menggunakan EntityManager................................................................................82
Client Code.............................................................................................................82
Pemetaan Relasi..........................................................................................................83
Pertimbangan dalam pemetaan...................................................................................85
Kasta.......................................................................................................................86
HALAMAN IV
Navigasi..................................................................................................................89
Jenis Collection......................................................................................................90
Optionality..............................................................................................................91
Transitive Persistence ............................................................................................92
Enum Type..................................................................................................................93
Value Type..................................................................................................................94
One to One .................................................................................................................95
Many to One................................................................................................................95
One to Many ...............................................................................................................96
List dengan order by...............................................................................................96
Many to Many ............................................................................................................99
ParentChild..............................................................................................................100
Mengambil Objek dari Database...............................................................................101
JPA Query Language (JPAQL).................................................................................101
Query Sederhana..................................................................................................101
Pagination.............................................................................................................102
Parameter Binding................................................................................................102
Named Query.......................................................................................................103
Restriction............................................................................................................104
Query untuk Collection........................................................................................106
Projection ............................................................................................................106
Join ......................................................................................................................106
Report Query........................................................................................................107
Subquery...............................................................................................................107
Native SQL...............................................................................................................108
Jasper Report.................................................................................................................109
Pengenalan................................................................................................................109
Instalasi ....................................................................................................................109
Alur Proses JasperReport..........................................................................................110
Istilah Umum dalam JasperReport............................................................................110
iReport sebagai Visual Designer ..............................................................................111
Konfigurasi Koneksi Database dalam iReport..........................................................112
HALAMAN V
Menampilkan Data dalam Report.............................................................................113
Kompilasi Report dengan Ant...................................................................................114
Integrasi JasperReport dengan Swing.......................................................................116
Menampilkan Report Menggunakan DataSource.....................................................117
Mengirim Parameter.................................................................................................120
Menggunakan Scriptlet.............................................................................................120
Penutup..........................................................................................................................122
Referensi dan Bacaan Lebih Lanjut...............................................................................123
HALAMAN VI
JAVA FOUNDATION CLASS | HALAMAN 1
Feature JFC
Swing Package
Swing API sangat bagus dan lengkap, Java 6.0 menyertakan
setidaknya tujuh belas (17) buah package yang berisi class-class
swing yang siap digunakan.
javax.accessibility javax.swing.plaf javax.swing.text
javax.swing javax.swing.plaf.basic javax.swing.text.html
javax.swing.border javax.swing.plaf.metal javax.swing.text.rtf
javax.swing.colorchooser javax.swing.plaf.multi javax.swing.table
javax.swing.event javax.swing.plaf.synth javax.swing.tree
javax.swing.filechooser javax.swing.undo
Swing HelloWorld
Menggunakan contoh langsung adalah cara yang tepat untuk
memulai proses belajar. Cara ini memberikan gambaran kongkrit
tentang subject yang akan dipelajari, sehingga proses belajar lebih
cepat diserap. Untuk tujuan ini, kita akan membuat sebuah
program kecil yang menampilkan kata “HelloWorld” menggunakan
komponen swing. Berikut ini adalah langkah-langkah yang harus
anda lakukan untuk membuat program “HelloWorld” berbasis
komponen swing:
1. Install Java Development Kit (JDK)
2. Membuat program HelloWorld itu sendiri
3. Melakukan kompilasi program HelloWorld
4. Menjalankan program HelloWorld
Install Java Development Kit
Yang perlu kita lakukan dalam langkah ini hanyalah mendownload
JDK dari website java.sun.com. kemudian jalankan program
instalasinya dan ikuti perintah-perintah dalam langkah-langkah
instalasi tersebut. Setelah proses instalasi selesai, kita siap untuk
membuat program Java.
Membuat program HelloWorld
HALAMAN 4 | JAVA SWING
c:\latihan> java HelloWorld
Membuat Swing HelloWorld dengan
Netbeans 6.1
Netbeans 6.1 dilengkapi dengan GUI builder yang dikenal dengan
Matisse. Dalam modul ini selanjutnya, Matisse akan digunakan
untuk menyebut Netbeans GUI Builder. Tools ini sangat powerful
dan produktif dalam membuat komponen GUI. Langkah-langkah
yang harus anda lakukan untuk membuat Swing HelloWorld
dengan Matisse adalah sebagai berikut:
1. Buat project baru dalam Netbeans, caranya pilih menu :
File > New Project
Komponen Swing
Struktur Komponen Swing
Secara arsitektur, Swing dibangun diatas arsitektur AWT (Abstract
Windows Toolkit). AWT adalah GUI toolkit yang dikembangkan oleh
Sun engineer sebelum swing muncul. Kelemahan utama AWT
adalah fleksibilitas tampilan GUI, seperti painting method yang
masih sangat primitif.
Swing dimaksudkan untuk memperbaiki kekurangan dari AWT
tanpa harus membuang teknologi yang sudah dibuat dan membuat
HALAMAN 8 | JAVA SWING
Bekerja dengan JLabel, JTextField dan
JButton
Bekerja dengan komponen swing menggunakan Matisse sangat
menyenangkan dan mudah. GroupLayout yang sangat fleksibel
memungkinkan kita untuk membuat aplikasi dengan tampilan
seperti yang kita harapkan.
Label, textfield dan tombol adalah komponen-komponen dasar yang
selalu ada dalam setiap aplikasi berbasis desktop. Ketiga komponen
ini mempunyai fungsi yang sangat sederhana, textfield menyimpan
data berbentuk text (string) yang relatif pendek , label banyak
digunakan untuk memberikan keterangan penjelas terhadap
komponen lain dan tombol digunakan user untuk menjalankan satu
instruksi tertentu.
Berikut ini adalah contoh aplikasi sederhana yang melakukan
penjumlahan dua buah bilangan.
penting
Jendela Design
menampilkan visualisasi
komponen GUI.
Jendela Source
menampilkan kode
program dari class yang
sedang dibuka.
Klik kanan > Change Variable Name ...
private void btnHitungActionPerformed(
java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
Bekerja dengan JCheckBox dan
JRadioButton
JCheckBox dan JRadioButton hanya bisa mempunyai dua buah
kemungkinan nilai, benar atau salah. Kedua komponen ini
penting
digunakan untuk merepresentasikan data yang berupa pilihan.
JC heckBox dan
JCheckBox digunakan jika pilihanya berupa multiple selection, JRadioButton sebaiknya
sedangkan JRadioButton digunakan jika pilihanya berupa single digunakan hanya jika
selection. item pilihanya sedikit
JRadioButton digunakan misalnya untuk merepresentasikan pilihan dan tidak bersifat
dinamis
jenis kelamin. JCheckBox digunakan misalnya untuk
merepresentasikan pilihan hobby.
ButtonGroup diperlukan untuk mengumpulkan JRadioButton yang
mempunyai grup pilihan yang sama. Misalnya grup pilihan jenis
kelamin digunakan untuk mengumpulkan JRadioButton yang
HALAMAN 12 | JAVA SWING
dan JComboBox.
Bekerja dengan JList dan JComboBox penting
JC omboBox dan JList
JComboBox memerlukan tempat yang minimalis dibandingkan digunakan jika item
dengan JRadioButton, selain itu JComboBox mempunyai bentuk pilihan bersifat dinamis.
ComboBox yang dapat diedit, sehingga memungkinkan user untuk
memilih pilihan yang tidak ada dalam item JComboBox. JC omboBox dapat
mempunyai bentuk yang
dapat diedit sehingga
user dapat memasukkan
pilihan yang tidak ada
dalam daftar.
Contoh JComboBox
JList memungkinkan multiple selection dengan menekan tombol :
SHIFT + Left Click atau CTRL + Left Click. Kemampuan ini
membantu user jika harus melakukan multiple selection.
JComboBox dan JList sangat fleksibel, kita dapat menambah dan
menghapus item di dalamnya dengan sangat mudah. Sehingga
cocok digunakan untuk merepresentasikan pilihan yang item
pilihannya bersifat dinamis.
Aplikasi di bawah ini adalah contoh penggunaan JComboBox dan
JList.
penting
b) Satu buah JComboBox : cmbPekerjaan
c) Satu buah JList : lstHobby
Jendela Properties tidak
d) Satu buah JtextArea : txtPilihanHobby
hanya berisi properties
dari komponen sw ing 3. Merubah isi JComboBox. Untuk merubah isi dari JComboBox
yang sedang aktif tetapi dan JList kita akan menggunakan Jendela Properties, Jendela
juga berisi Tab Events ini letaknya di sebelah kanan bawah, dibawah Jendela Pallete
dan Tab C ode. dan akan muncul hanya jika jendela Design yang dipilih.
Tab Events digunakan
untuk memasukkan kode
yang akan dieksekusi
ketika event tertentu
dikenakan terhadap
komponen sw ing.
private void lstHobbyValueChanged(
javax.swing.event.ListSelectionEvent evt) {
// TODO add your handling code here:
Object[] selectedItems =
lstHobby.getSelectedValues();
if(selectedItems == null ||
selectedItems.length == 0)
txtPilihanHobby.setText("");
else{
StringBuffer strValues = new
StringBuffer();
for(Object item : selectedItems){
strValues.append(item.toString() + ", ");
}
txtPilihanHobby.setText(
strValues.substring(0, strValues.length()
2));
}
}
Catatan :
● Method getSelectedValues dari JList mengembalikan item-item
yang terpilih.
penting
JMenuBar dan JToolBar Bekerja dengan Menu, Popup Menu dan
hanya bisa ditambahkan
ke dalam JFrame. Toolbar
JMenuItem adalah
struktur terluar dari Menu, Popup menu dan Toolbar digunakan untuk melakukan
Menu yang tidak bisa navigasi dalam aplikasi. dengan ketiga komponen itu navigasi
mempunyai child. dalam aplikasi menjadi lebih fleksibel dan mudah digunakan oleh
user. Menu dan Toolbar pada umumnya diletakkan di bagian atas
JToolBar pada umumnya dari aplikasi agar mudah ditemukan oleh user. Sedangkan Popup
menampung JButton Menu bisa muncul di mana saja sesuai dengan konteks aplikasi.
yang diberi Icon dan
mempunyai background JMenuBar adalah class yang digunakan untuk menampung JMenu.
transparan. JMenu dapat menampung satu atau lebih JMenuItem. JMenuItem
merupakan bagian terluar dari struktur menu yang tidak bisa
mempunyai child. JSeparatordigunakan untuk memisahkan antara
satu menu item dan menu item yang lain. Jika didalam menu
terdapat sub menu, gunakan JMenu untuk menampung sub menu
tersebut. Selain JMenuItem, JMenu juga dapat menerima class
JCheckBoxMenuItem dan JRadioButtonMenuItem.
JPopupMenu mempunyai banyak kesamaan dibandingkan dengan
JMenuBar. Perbedaan utamanya adalah : JMenuBar hanya bisa
KOMPONEN SWING | HALAMAN 19
Proses penambahan,
pengurangan dan
pengaturan posisi menu
semua dilaksanakan dari
Jendela Inspector
Add > JSeparator
\
KOMPONEN SWING | HALAMAN 23
dan menuPaste.
4. Memunculkan JPopupMenu. Ketika tombol kanan mouse di klik
diatas JFrame, JPopupMenu akan tampil. Agar behavior
tersebut berjalan, kita perlu menangani event mouseClick
terhadap JFrame. Caranya :
a) Klik kanan JFrame di Jendela Design, kemudian pilih menu :
Events > Mouse > mouseClicked
Beri nama images untuk java package yang baru saja kita buka.
2. Memasukkan Icon ke dalam package. Untuk memasukkan
image ke dalam package kita perlu tahu dimana project
disimpan, misalkan project disimpan dalam folder :
c:\javaswing
Build Project akan Copy semua icon yang diperlukan ke dalam folder diatas.
berhasil jika tidak ada 3. Build project. Langkah ini diperlukan untuk mengcompile
satupun error dalam semua file .java menjadi file .class. Selain itu proses ini juga
kode program.
akan mengkopi file selain file .java (termasuk file icon) ke
dalam folder build\classes. Jika proses ini tidak dilaksanakan,
Sebelum melakukan
build project pastikan maka ketika program dijalankan, file icon tidak akan ditemukan
terlebih dahulu tidak ada dan program menjadi error .
error dalam kode. Setelah proses persiapan selesai, lakukan langkah-langkah berikut
ini untuk membuat Toolbar :
Lakukan build setiap kali
menambahkan file non- 1. Buka class ToolbarMenu.java yang sudah dibuat di langkah
java ke dalam folder sebelumnya.
source file. Agar file
tersebut ikut tercopy ke 2. Buat sebuah object JToolBar, caranya : klik item JToolBar dari
dalam folder Jendela Pallete, kemudian klik JFrame di Jendela Design.
build\classes Secara otomatis sebuah object JToolBar akan dimasukkan ke
dalam JFrame. Ganti namanya menjadi toolBar.
KOMPONEN SWING | HALAMAN 27
Membuat Dialog dan JFileChooser
Dialog memerankan peran yang penting dalam aplikasi berbasis
desktop. Interaksi antara user dengan aplikasi terkadang tidak
berjalan dengan baik karena user memberikan aksi yang tidak valid
kepada aplikasi. Ketika hal tersebut terjadi, aplikasi harus
memberitahukan kepada user apa yang telah terjadi dan
bagaimana seharusnya user memperbaikinya. Model interaksi
seperti ini tepat dilaksanakan menggunakan dialog.
Skenario lain adalah ketika aplikasi memerlukan input dari user
agar aplikasi bisa terus melaksanakan tugasnya, misalnya meminta
konfirmasi apakah user yakin akan melaksanakan sebuah aksi
penting terhadap aplikasi seperti delete, update atau add data.
Dialog juga memberikan pembatasan kepada user, sebelum dialog
selesai diproses, user tidak akan bisa berinteraksi dengan bagian
aplikasi lainya. Dialog mencegah hal ini terjadi dengan memastikan
bahwa jendela yang bisa diaktifkan hanyalah jendela dialog,
sedangkan jendela aplikasi yang lain tidak dapat diaktifkan selama
jendela dialog masih aktif.
Aplikasi sangat sering menggunakan dialog untuk berinteraksi
dengan user, tetapi jenis interaksinya selalu seragam dan berulang-
HALAMAN 30 | JAVA SWING
JOptionPane.showMessageDialog(null,
"Your action was succeed, “ +
“you can proceed to next assigment",
"Information dialog",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null,
"You neet to be sure to do this action!",
"Dialog Peringatan", JOptionPane.WARNING_MESSAGE);
JOptionPane.showMessageDialog(null,
"Something goes wrong and generate error message",
"Error Dialog", JOptionPane.ERROR_MESSAGE);
JOptionPane.showConfirmDialog(null,
"Choose yes or no","Confirmation Dialog",
JOptionPane.YES_NO_OPTION,
JoptionPane.WARNING_MESSAGE);
HALAMAN 34 | JAVA SWING
JOptionPane.showConfirmDialog(null,
"Choose yes, no or cancel","Confirmation Dialog",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.PLAIN_MESSAGE);
OptionDialog
JOptionPane.showInputDialog(null,
"Input your name here","Input Dialog",
JOptionPane.INFORMATION_MESSAGE);
Membuat JFileChooser
JFileChooser digunakan untuk bernavigasi dalam file system,
kemudian memilih satu atau lebih file atau folder dari list file dan
folder. JFileChooser pada dasarnya adalah pengembangan dari
dialog yang dapat digunakan untuk memilih file. JFileChooser dapat
digunakan sebagai dialog untuk menyimpan file atau untuk
membuka file.
JFileChooser hanya memberikan fasilitas untuk memilih file atau
folder, sedangkan mekanisme untuk menyimpan atau membuka file
dilakukan sendiri menggunakan library I/O.
Aplikasi berikut ini adalah contoh penggunaan JFileChooser untuk
membuka dan menyimpan file.
Tampilan JFileChooser
Untuk membuat aplikasi diatas lakukan langkah-langkah berikut ini
:
1. Buat class JFrame Form baru, beri nama Chooser.java
2. Masukkan dua buah JTextField : txtOpen dan txtSave, dua buah
HALAMAN 36 | JAVA SWING
private void btnSaveActionPerformed(ActionEvent evt) {
// TODO add your handling code here:
int ret = chooser.showSaveDialog(this);
if(ret == JFileChooser.APPROVE_OPTION){
File f = chooser.getSelectedFile();
lblStatus.setText("Status : saving file" +
f.getAbsolutePath());
txtSave.setText(f.getAbsolutePath());
}
}
Konsep MVC
public class Person {
private int id;
private String name;
private String email;
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getName() { return name; }
public void setNama(String name) { this.name = name;}
//getter dan setter method untuk field lainnya di sini
}
Model dalam Komponen Swing
Sebagaian besar komponen swing mempunyai model. JButton
mempunyai model yaitu ButtonModel yang memegang 'state' dari
JButton – apa keyboard mnemonicnya, apakah JButton tersebut
sedang dipilih atau tidak dan seterusnya. Ada pula komponen
swing yang mempunyai lebih dari satu model. JList mempunyai
HALAMAN 40 | JAVA SWING
TableModel
TableModel adalah class model yang paling sering dikustomisasi.
Karakteristik data dari JTable yang berbentuk koleksi data dua
dimensi membutuhkan perhatian khusus agar efisien digunakan
dalam aplikasi. Jika kita tidak hati-hati, maka aplikasi kita bisa
menjadi sangat lambat dan tidak efisien.
TableModel adalah interface yang digunakan oleh JTable untuk
mendefinisikan ciri-ciri dari data tabular yang akan ditampilkan
oleh JTable. Misalnya : jumlah kolom, nama kolom, class dari object
dalam kolom, jumlah baris dan nilai setiap cell. Dengan adanya
data-data ini JTable dapat secara efisien menentukan bagaimana
menampilkan data tersebut.
Berikut ini adalah kode untuk menampilkan koleksi object Person.
Class ArrayList<Person> adalah implementasi dari generics,
konsep dalam Java yang digunakan untuk mendefinisikan isi dari
koleksi. ArrayList<Person> artinya adalah membuat sebuah object
koleksi ArrayList yang harus diisi oleh object Person dan tidak bisa
diisi oleh object lainya, misalnya String.
public class PersonTableModel extends AbstractTableModel{
private List<Person> persons;
public PersonTableModel(List<Person> persons) {
this.persons = persons;
}
public int getRowCount() {
return persons.size();
}
public int getColumnCount() {
return 3;
}
public Object getValueAt(int rowIndex, int
columnIndex) {
Person p = persons.get(rowIndex);
switch(columnIndex){
case 0 : return p.getId();
case 1 : return p.getName();
case 2 : return p.getEmail();
default : return "";
}
}
HALAMAN 42 | JAVA SWING
@Override
public String getColumnName(int column) {
switch(column){
case 0 : return "ID";
case 1 : return "NAME";
case 2 : return "EMAIL";
default : return "";
}
}
}
ListModel
JList adalah komponen swing yang mempunyai dua model
sekaligus, ListModel dan ListSelectionModel. ListModel digunakan
untuk mendefinisikan item/element yang dikandung oleh JList.
Sedangkan ListSelectionModel digunakan untuk mendefinisikan
bagaimana representasi data jika terjadi proses pemilihan di JList.
Seperti halnya TableModel, ListModel mempunyai dua class yang
mengimplement ListModel, AbstractListModel dan
DefaultListModel. Kita bisa menggunakan salah satu dari tiga tipe
KONSEP MVC | HALAMAN 43
Menangani Event
Event Listener dalam Swing
Pattern Observer melibatkan dua object Subject dan Observer,
dalam swing Observer dikenal sebagai Listener. Kemudian, ketika
Subject akan memberitahu (notify) Observer tentang apa yang
sedang terjadi dalam object Subject, ada satu informasi yang akan
di-passing oleh Subject ke Observer, informasi ini disebut sebagai
Event object. Sedangkan kejadian ketika Subject melakukan notify
kepada Observer disebut sebagai Event triggering.
Agar penjelasan diatas mudah dipahami, kita akan membuat
aplikasi sederhana yang mengimplementasikan pattern Observer.
Aplikasi sederhana ini terdiri dari dua class utama yaitu Subject
dan Observer.
Class Subject akan menjalankan sebuah loop tanpa batas, di dalam
loop tersebut Subject akan meminta input dari user berupa sebuah
kata yang diakhiri dengan penekanan enter. Ketika user menekan
enter, Subject akan menotify Observer. Dalam proses notifikasi
tersebut, Subject mengumpulkan informasi tentang event
pemasukan kata oleh user, informasi tersebut berupa : kata apa
yang dimaksukkan dan object subject dimana event pemasukan
kata tersebut terjadi (source). Kemudian Observer akan menerima
informasi dari Subject dan mencetak informasi tersebut ke
standard output. Berikut ini tampilan dari aplikasi sederhana ini :
type a word : ifnu
print from observer : first observer
event from : subject observed
key presed is ifnu
ini nanti yang akan dipanggil oleh Subject ketika event pemasukan
kata oleh user terjadi di Subject.
public interface KeyboardPressedListener {
public void keyPressed(KeyboardPressedEvent e);
}
public class MainClass {
public static void main(String[] str){
Subject subject =
new Subject("subject observed");
Observer observer =
new Observer("first observer");
subject.registerObserver(observer);
subject.runProgram();
}
}
ActionListener
ActionListener digunakan untuk mendengarkan action dari event :
● Klik terhadap JButton
● Pemilihan menu item
● Penekanan tombol enter dalam JTextField
Method dalam ActionListener hanya satu yaitu actionPerformed
yang menerima argumen object ActionEvent. ActionEvent berisi
informasi-informasi penting ketika Action event terjadi, termasuk
tombol modifiers apa yang sedang ditekan. Tombol modifiers
antara lain : CTRL, ALT, META dan SHIFT. Method untuk
menentukan tombol modifiers apa yang sedang aktif adalah
MENANGANI EVENT | HALAMAN 49
Setelah itu anda akan dibawa ke jendela kode dan baris berikut ini
akan dibuat secara otomatis oleh Netbeans :
private void btnHitungActionPerformed(
java.awt.event.ActionEvent evt) {
}
new ActionListener() {
public void actionPerformed(ActionEvent evt){
btnHitungActionPerformed(evt);
}
KeyListener
KeyListener akan mendengarkan penekanan tombol oleh komponen
yang berada dalam keadaan fokus. Semua komponen swing dapat
menerima KeyListener sebagai Observer. KeyListener dapat
mendengarkan tiga event berbeda : penekanan tombol, pelepasan
tombol dan pengetikan tombol. Ketiganya ditangani oleh method
yang berbeda-beda, yaitu :
● keyPressed : dipanggil ketika terjadi penekanan tombol
keyboard.
● keyReleased : dipanggil ketika tombol keyboard dilepaskan.
● keyTyped : dipanggil ketika tombol diketikkan, alias ditekan
kemudian dilepaskan. Method ini dipanggil jika tombol yang
ditekan mempunyai representasi karakter unicode, seperti
tombol angka dan tombol huruf. Sedangkan penekanan tombol
modifiers seperti ALT, CTRL, ARROW, CAPSLOCK, NUMLOCK,
INS dan lainnya tidak akan mengakibatkan method ini
dipanggil.
Ketiga method diatas menerima parameter KeyEvent. Untuk
mengetes tombol apakah yang ditekan oleh user, digunakan
method getKeyCode. Kemudian hasil kembalian method
getKeyCode dibandingkan dengan field static kepunyaan class
KeyEvent yang diawali dengan huruf VK, seperti : VK_ENTER,
VK_A, VK_B, VK_1, VK_LEFT_ARROW dan seterusnya.
MENANGANI EVENT | HALAMAN 51
evt.getKeyChar());
}
Events > Key > keyReleased
MouseListener dan
MouseMotionListener
MouseListener mendengarkan interaksi mouse terhadap komponen
swing. MouseListener dapat didaftarkan pada semua komponen
swing. MouseListener mendengarkan event :
● mousePressed : event ini terjadi ketika user menekan salah
satu tombol mouse diatas komponen swing.
● mouseReleased : setelah tombol ditekan, komponen swing akan
menerima pelepasan tombol mouse. Tetapi jika tombol mouse
dilepaskan pada saat pointer mouse tidak berada diatas
komponen swing, maka event ini tidak akan terjadi.
● mouseClicked : event ini muncul ketika user melakukan click
tombol mouse diatas komponen swing.
● mouseEntered : ketika mouse memasuki area diatas komponen
swing, event ini akan dipicu.
● mouseExited : muncul ketika mouse akan meninggalkan area
diatas komponen swing
Ketika user menekan tombol mouse (click), event mousePressed
dibuat, kemudian mouseReleased dan akhirnya mouseClicked
MENANGANI EVENT | HALAMAN 53
muncul terakhir.
MouseMotionListener juga dapat didaftarkan sebagai listener pada
semua komponen swing. MouseMotionListener dipisahkan dari
MouseListener karena penanganan event mouseMove yang lebih
berat dan intensif. MouseMotionListener mendengarkan dua
envent:
● mouseMoved : terjadi ketika user menggerakkan mouse diatas
komponen swing
● mouseDragged : terjadi ketika user menekan tombol mouse
sekaligus menggerakkanya diatas komponen swing
Semua method diatas menerima argumen berupa class
MouseEvent. Method getClickCount digunakan untuk menentukan
jumlah click yang terjadi dalam waktu yang berdekatan. Method
getClickCount juga digunakan untuk menentukan apakah klik yang
terjadi adalah single klik atau double klik.
Method getButton digunakan untuk menentukan tombol mana yang
ditekan oleh user. Pada umumnya mouse yang tersedia di pasaran
mempunyai tiga timbol yang dapat di klik, tombol kiri, tombol
tengah dan tombol kanan. Method getButton akan mengembalikan
nilai MouseEvent.BUTTON1 jika tombol kiri ditekan,
MouseEvent.BUTTON2 jika tombol tengah ditekan dan
MouseEvent.BUTTON3 jika tombol kanan ditekan.
Method getX dan getY akan mengembalikan koordinat dimana
MouseEvent terjadi. Koordinat yang digunakan adalah koordinat
relatif. Koordinat (0,0) berada di pojok kiri atas dari komponen
swing, semakin kebawah nilai Y semakin besar dan semakin ke
kanan nilai X semakin besar. Nilai koordinatnya dinyatakan dalam
satuan pixel.
Aplikasi di bawah ini adalah sebuah JFrame yang mempunyai
JLabel di dalamnya. Ketika terjadi event mouseClick dan
mouseMove, JLabel akan menampilkan dimana event tersebut
terjadi. Jika event klik yang muncul, maka text dari JLabel akan
berisi “clicked at (x,y)”, sedangkan event move hanya akan
memunculkan koordinat “(x,y)” saja.
Mengenal JDBC
Java Database Connectivity adalah API yang digunakan Java untuk
melakukan koneksi dengan aplikasi lain atau dengan berbagai
macam database. JDBC memungkinkan kita untuk membuat
aplikasi Java yang melakukan tiga hal: konek ke sumber data,
mengirimkan query dan statement ke database, menerima dan
mengolah resultset yang diperoleh dari database.
JDBC mempunyai empat komponen :
1. JDBC API
JDBC API menyediakan metode akses yang sederhana ke
sumber data relational (RDBMS) menggunakan pemrograman
Java. dengan menggunakan JDBC API, kita bisa membuat
program yang dapat mengeksekusi SQL, menerima hasil
ResultSet, dan mengubah data dalam database. JDBC API juga
mempunyai kemampuan untuk berinteraksi dengan lingkungan
terdistribusi dari jenis sumber data yang berbeda-beda.
JDBC API adalah bagian dari Java Platform yang disertakan
dalam library JDK maupun JRE. JDBC API sekarang ini sudah
mencapai versi 4.0 yang disertakan dalan JDK 6.0. JDBC API
4.0 dibagi dalam dua package yaitu : java.sql dan javax.sql.
2. JDBC Driver Manager
Class DriverManager dari JDBC bertugas untuk mendefisikan
object-object yang dapat digunakan untuk melakukan koneksi
ke sebuah sumber data. Secara tradisional DriverManager
telah menjadi tulang punggung arsitektur JDBC.
3. JDBC Test Suite
JDBC Test Suite membantu kita untuk mencara driver mana
yang cocok digunakan untuk melakukan sebuah koneksi ke
sumber data tertentu. Tes yang dilakukan tidak memerlukan
resource besar ataupun tes yang komprehensif, namun cukup
tes-tes sederhana yang memastikan fitur-fitur penting JDBC
dapat berjalan dengan lancar.
4. JDBC-ODBC Bridge
HALAMAN 56 | JAVA SWING
Database Driver
JDBC memerlukan database driver untuk melakukan koneksi ke
suatu sumber data. Database driver ini bersifat spesifik untuk
setiap jenis sumber data. Database driver biasanya dibuat oleh
pihak pembuat sumber datanya, namun tidak jarang juga
komunitas atau pihak ketiga menyediakan database driver untuk
sebuah sumber data tertentu.
Perlu dipahami sekali lagi bahwa database driver bersifat spesifik
untuk setiap jenis sumber data. Misalnya, Database Driver MySql
hanya bisa digunakan untuk melakukan koneksi ke database MySql
dan begitu juga database driver untuk Postgre SQL juga hanya bisa
digunakan untuk melakukan koneksi ke database Postgre SQL.
Database driver untuk setiap DBMS pada umumnya dapat
didownload dari website pembuat DBMS tersebut. Beberapa
vendor DBMS menyebut Database driver ini dengan sebutan Java
Connector (J/Connector). Database driver biasanya dibungkus
dalam file yang berekstensi jar. Setiap database driver harus
mengimplement interface java.sql.Driver.
Membuat Koneksi
Melakukan koneksi ke database melibatkan dua langkah: Meload
driver dan membuat koneksi itu sendiri. Cara meload driver sangat
mudah, pertama letakkan file jar database driver ke dalam
classpath. Kemudian load driver dengan menambahkan kode
berikut ini:
KONEKSI DATABASE DENGAN JDBC | HALAMAN 57
Class.forName(“com.mysql.jdbc.Driver”);
Nama class database driver untuk setiap DBMS berbeda, anda bisa
menemukan nama class tersebut dalam dokumentasi driver
database yang anda gunakan. Dalam contoh ini, nama class
database driver dari MySql adalah com.mysql.jdbc.Driver.
Memanggil method Class.forName secara otomatis membuat
instance dari database driver, class DriverManager secara otomatis
juga dipanggil untuk mengelola class database driver ini. Jadi anda
tidak perlu menggunakan statement new untuk membuat instance
dari class database driver tersebut.
Langkah berikutnya adalah membuat koneksi ke database
menggunakan database driver yang sudah diload tadi. Class
DriverManager bekerja sama dengan interface Driver untuk
mengelola driver-driver yang diload oleh aplikasi, jadi dalam satu
sesi anda bisa meload beberapa database driver yang berbeda.
Ketika kita benar-benar melakukan koneksi, JDBC Test Suite akan
melakukan serangkaian tes untuk menentukan driver mana yang
akan digunakan. Parameter yang digunakan untuk menentukan
driver yang sesuai adalah URL. Aplikasi yang akan melakukan
koneksi ke database menyediakan URL pengenal dari server
databse tersebut. Sebagai contoh adalah URL yang digunakan
untuk melakukan koneksi ke MySql :
jdbc:mysql://[host]:[port]/[schema]
contoh konkritnya :
jdbc:mysql://localhost:3306/latihan
Connection conn =
DriverManager.getConnection(
“jdbc:mysql://localhost:3306/latihan”,
”root”,””);
Jika salah satu dari driver yang diload berhasil digunakan untuk
melakukan koneksi dengan URL tersebut, maka koneksi ke
database berhasil dilaksanakan. Class Connection akan memegang
informasi koneksi ke database yang didefinisikan oleh URL
tersebut.
Setelah sukses melakukan koneksi ke database, kita dapat
mengambil data dari database menggunakan perintah query
ataupun melakukan perubahan terhadap database. bagian berikut
ini akan menerangkan bagaimana cara mengambil dan
memanipulasi data dari database.
Mengambil dan Memanipulasi Data dari
Database
Proses pengambilan data dari database memerlukan suatu class
untuk menampung data yang berhasil diambil, class tersebut harus
mengimplement interface ResultSet.
Object yang bertipe ResultSet dapat mempunyai level
fungsionalitas yang berbeda, hal ini tergantung dari tipe dari
result set. Level fungsionalitas dari setiap tipe result set dibedakan
berdasarkan dua area:
● Dengan cara bagaimana result set itu dapat dimanipulasi
● Bagaimana result set itu menangani perubahan data yang
dilakukan oleh proses lain secara bersamaan (concurrent).
JDBC menyediakan tiga tipe result set untuk tujuan berbeda:
1. TYPE_FORWARD_ONLY : result set tersebut tidak bisa berjalan
mundur, reslut set hanya bisa berjalan maju dari baris pertama
hingga baris terakhir. result set hanya menggambarkan
keadaan data ketika query dijalankan atau ketika data diterima
oleh resul set. Jika setelah itu ada perubahan data dalam
database, result set tidak akan diupdate alias tidak ada
perubahan dalam result set tipe ini.
2. TYPE_SCROLL_INSENSITIVE : result set dapat berjalan maju
mundur. result set dapat berjalan maju dari row pertama
hingga terakhir atau bergerak bebas berdasarkan posisi relatif
atau absolute.
KONEKSI DATABASE DENGAN JDBC | HALAMAN 59
Menggunakan PreparedStatement
Memanggil method executeUpdate berulang-ulang, misalnya
melakukan insert ratusan atau ribuan baris, sangat tidak efisien.
KONEKSI DATABASE DENGAN JDBC | HALAMAN 61
PreparedStatement pInsert = conn.prepareStatement(
"insert into Person(name) values(?)");
pInsert.setString(1,"dian");
pInsert.executeUpdate();
PreparedStatement pUpdate = conn.prepareStatement(
"update Person set name=? where name=?");
pUpdate.setString(1,"andry");
pUpdate.setString(2,"andri");
pUpdate.executeUpdate();
Batch Execution
Misalnya kita ingin meng-insert seratus baris data dalam sebuah
loop, kita bisa menggunakan fasilitas batc execution dari
PreparedStatement. batch execution mengumpulkan semua
eksekusi program yang akan dilaksanakan, setelah semuanya
terkumpul batch execution kemudian mengirimkan kumpulan
eksekusi program secara bersamaan ke DBMS dalam satu
kesatuan. Metode ini sangat efisien karena mengurangi overhead
yang diperlukan program untuk berkomunikasi dengan DBMS.
Dalam contoh di bawah ini kita akan menggunakan batch execution
untuk melakukan insert data sebanyak seratus kali.
PreparedStatement pInsert = conn.prepareStatement(
"insert into Person(nama) values(?)");
for(int i=0;i<100;i++){
pInsert.setString(1,"user ke " + i);
pInsert.addBatch();
}
pInsert.executeBatch();
Menangani Transaction
Dukungan transaction oleh JDBC tergantung dengan Databasenya,
KONEKSI DATABASE DENGAN JDBC | HALAMAN 63
DAO dan Service Pattern
Akses terhadap database merupakan bagian yang sangat penting
dari aplikasi database. Penggunaan pattern yang sesuai dapat
memberikan manfaat sangat besar. Pattern yang sering digunakan
dalam akses database adalah DAO (Data Access Object) dan
Service/Facade pattern.
Kedua pattern ini digunakan untuk menerapkan “separation of
concern” atau pemisahan kode proram berdasarkan fungsi kode
program. Semua kode untuk akses data harus dipisahkan dengan
kode untuk pengaturan user inteface. Hal ini memungkinkan kode
akses data yang dibuat untuk aplikasi desktop, dengan mudah
HALAMAN 64 | JAVA SWING
public class CategoryDaoJdbc {
private Connection connection;
private PreparedStatement insertStatement;
private PreparedStatement updateStatement;
private PreparedStatement deleteStatement;
private PreparedStatement getByIdStatement;
private PreparedStatement getAllStatement;
private final String insertQuery =
"insert into T_CATEGORY(name,description)" +
" values(?,?)";
private final String updateQuery =
"update T_CATEGORY set name=?, description=? " +
" where id=?";
private final String deleteQuery =
"delete from T_CATEGORY where id=?";
private final String getByIdQuery =
"select * from T_CATEGORY where id =?";
private final String getAllQuery =
"select * from T_CATEGORY";
public void setConnection(Connection connection) {
try {
this.connection = connection;
insertStatement =
this.connection.prepareStatement(
insertQuery,Statement.RETURN_GENERATED_KEYS);
HALAMAN 66 | JAVA SWING
updateStatement =
this.connection.prepareStatement(
updateQuery);
deleteStatement =
this.connection.prepareStatement(
deleteQuery);
getByIdStatement =
this.connection.prepareStatement(
getByIdQuery);
getAllStatement =
this.connection.prepareStatement(
getAllQuery);
} catch (SQLException ex) {
}
}
public void save(Category category) {
try {
if (category.getId() == null) {
insertStatement.setString(1,
KONEKSI DATABASE DENGAN JDBC | HALAMAN 67
category.getName());
insertStatement.setString(2,
category.getDescription());
int id = insertStatement.executeUpdate();
category.setId(id);
} else {
updateStatement.setString(1,
category.getName());
updateStatement.setString(2,
category.getDescription());
updateStatement.setInt(3, category.getId());
updateStatement.executeUpdate();
}
} catch (SQLException ex) {
}
}
public void delete(Category category) {
try {
deleteStatement.setInt(1, category.getId());
deleteStatement.executeUpdate();
} catch (SQLException ex) {
}
}
public Category getById(Long id) {
try {
getByIdStatement.setLong(1, id);
ResultSet rs = getByIdStatement.executeQuery();
//proses mapping dari relational ke object
if (rs.next()) {
Category category = new Category();
category.setId(rs.getInt("id"));
category.setName(rs.getString("name"));
category.setDescription(
rs.getString("description"));
return category;
}
} catch (SQLException ex) {
}
return null;
}
public List<Category> getAll() {
try {
List<Category> categories =
new ArrayList<Category>();
HALAMAN 68 | JAVA SWING
ResultSet rs = getAllStatement.executeQuery();
while(rs.next()){
Category category = new Category();
category.setId(rs.getInt("id"));
category.setName(rs.getString("name"));
category.setDescription(
rs.getString("description"));
categories.add(category);
}
return categories;
} catch (SQLException ex) {
}
return null;
}
}
public class ServiceJdbc {
private CategoryDaoJdbc categoryDao;
private Connection connection;
public void setDataSource(DataSource dataSource){
try {
connection = dataSource.getConnection();
categoryDao = new CategoryDaoJdbc();
categoryDao.setConnection(connection);
} catch (SQLException ex) {
}
}
public void save(Category category){
try {
connection.setAutoCommit(false);
categoryDao.save(category);
connection.commit();
connection.setAutoCommit(true);
} catch (SQLException ex) {
try{
connection.rollback();
}catch(SQLException e){
}
}
}
public void delete(Category category){
try {
connection.setAutoCommit(false);
categoryDao.save(category);
connection.commit();
connection.setAutoCommit(true);
} catch (SQLException ex) {
try{
connection.rollback();
}catch(SQLException e){
}
}
}
public Category getGroup(Long id){
return categoryDao.getById(id);
}
public List<Category> getGroups(){
HALAMAN 70 | JAVA SWING
return categoryDao.getAll();
}
}
Setelah class DAO dan service berhasil dibuat, mari kita lihat
bagaimana cara menggunakannya :
public class MainJdbc {
public static void main(String[] args) {
MysqlDataSource dataSource =
new MysqlDataSource();
dataSource.setUser("root");
dataSource.setPassword("admin");
dataSource.setDatabaseName("latihan");
dataSource.setServerName("localhost");
dataSource.setPortNumber(1527);
ServiceJdbc service = new ServiceJdbc();
service.setDataSource(dataSource);
Category category = new Category();
category.setName("administrator");
service.save(category);
System.out.println("id : " + category.getId());
System.out.println("name : " +
category.getName());
try {
dataSource.getConnection().close();
} catch (SQLException ex) {
}
}
}
public class Category {
}
public class Article {
private Category category;
}
• class Category bisa melihat isi Article, tapi Article tidak tahu
Category tempat dia disimpan.
public class Category {
public List<Article> articles;
}
public class Article {
}
Persiapan
Instalasi
Seperti library Java lainnya, JPA tidak membutuhkan instalasi
JAVA PERSISTENCE API (JPA) | HALAMAN 75
Dasardasar ORM
Mapping Sederhana
Untuk contoh awal, kita akan melakukan mapping untuk class
Category. Class ini hanya memiliki tiga properti saja, id, name, dan
description. Berikut adalah kode Javanya.
public class Category {
private Integer id;
private String name;
private String description;
// getter dan setter
}
Konfigurasi JPA
Setelah kita membuat tabel dan class Java, sekarang kita akan
membuat konfigurasi JPA. NetBeans 6.1 mempunyai fasilitas yang
memudahkan konfigurasi JPA.
Langkah pertama adalah membuat koneksi ke dalam database
MySQL dengan menggunakan database tools netbeans. Buka tab
service, kemudian expand bagian database. Kalau kita belum
mempunyai database, kita bisa membuat database terlebih dahulu
dengan melakukan klik kanan di node mysql dan pilih menu create
database, beri nama training. Kalau sudah ada database (schema)
yang dibuat sebelumnya, node mysql dapat diexpand untuk melihat
database tersebut.
Langkah berikutnya adalah membuat koneksi ke dalam database
yang sudah dibuat. Expand node mysql, klik kanan di node
database training, pilih menu connect. Jangan lupa untuk mencek
pilihan “Remember Password”. Koneksi ini nanti akan kita gunakan
untuk membuat Persistence Unit.
Persistence Unit adalah konfigurasi yang digunakan oleh JPA untuk
meletakkan parameter username, password, url dan dialect yang
digunakan untuk melakukan koneksi ke database.
Proses membuat Persistence Unit sangat mudah, pilih menu :
file → new file → persistence → persistence unit
JAVA PERSISTENCE API (JPA) | HALAMAN 77
<?xml version="1.0" encoding="UTF8"?>
<persistence version="1.0"
xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchemainstance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistenc
e
http://java.sun.com/xml/ns/persistence/persistence_1_0.xs
d">
<persistenceunit name="latihanPU" transaction
type="RESOURCE_LOCAL">
<provider>
oracle.toplink.essentials.PersistenceProvider
</provider>
<class>com.artivisi.desktop.model.Group</class>
<class>com.artivisi.desktop.model.Person</class>
<properties>
<property name="toplink.jdbc.user" value="root"/>
<property name="toplink.jdbc.password" value=""/>
<property name="toplink.jdbc.url"
value="jdbc:mysql://localhost:3306/training"/>
<property name="toplink.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="toplink.ddlgeneration"
value="createtables"/>
</properties>
</persistenceunit>
</persistence>
public class DemoJpa {
public static void main(String[] xx){
}
}
Biasanya, session
dibuka di aw al method,
dan segera ditutup di
akhir method.
Persistence.createEntityManagerFactory("JpaPU");
Transaction.
EntityManager entityManager =
entityManagerFactory.createEntityManager();
entityManager.getTransaction().begin();
entityManager.persist(category);
entityManager.getTransaction().commit();
entityManager.close();
System.out.println("ID: "+c.getId());
System.out.println("Name: "+c.getName());
Tidak sulit bukan? Kita tidak perlu menulis SQL lagi. Tapi ini tidak
berarti kita boleh tidak mengerti SQL. Seperti kita akan lihat pada
bagian selanjutnya, pemahaman SQL sangat penting agar kita bisa
menggunakan JPA dengan optimal.
JAVA PERSISTENCE API (JPA) | HALAMAN 81
public class CategoryDao {
public void save(Category cat){}
public Category findById(Integer id){}
}
public class CategoryDao {
private EntityManager entityManager;
public void setEntityManager(
EntityManager em) {
this.entityManager = em;
}
}
Menggunakan EntityManager
Selanjutnya, mari kita isi method save. Di dalam method ini harus
ada logika untuk menentukan apakah operasi save yang akan
dilakukan adalah insert atau update. Konvensi yang digunakan
adalah: jika id dari entity masih null maka entity tersebut belum
ada di dalam database, sehingga operasi insert yang akan
dilaksanakan. Sebaliknya, jika idnya tidak null maka operasi update
yang akan dilaksanakan:
public void save(Category cat) {
if(cat.getId()==null){
entityManager.persist(cat);
} else {
entityManager.merge(cat);
}
}
method findById.
public Category findById(Integer id){
return (Category) entityManager.createQuery(
"select g from Group g where g.id=:id")
.setParameter("id", id)
.getSingleResult();
}
Client Code
Kita dapat membuat kode sederhana untuk mengetes kinerja
CategoryDao. Buat class DemoDao yang memiliki method main.
Isikan kode program berikut dalam method main.
JAVA PERSISTENCE API (JPA) | HALAMAN 83
EntityManagerFactory factory =
Persistence.createEntityManagerFactory(“JpaPU”);
CategoryDao categoryDao = new CategoryDao();
categoryDao.setEntityManager(factory.createEntityManager(
));
Category cat = new Category();
cat.setName("Tutorial JPA");
cat.setDescription("Belajar JPA");
categoryDao.save(cat);
CategoryDao categoryDao = new CategoryDao();
categoryDao.setEntityManager(factory.createEntityManager(
));
Category cat = categoryDao.findById(1);
System.out.println("ID: " + cat.getId());
System.out.println("Name: " + cat.getName());
System.out.println("Description: "+cat.getDescription());
ID: 1
Name: Tutorial JPA
Description: Belajar JPA
Pemetaan Relasi
Selanjutnya, setelah kita dapat mengkonfigurasi dan melakukan
test terhadap kerja JPA, sekarang kita bisa melangkah ke topik
yang lebih bermanfaat, yaitu membuat mapping yang lebih
beragam.
Pada bab ini, kita akan memetakan seluruh struktur database
aplikasi blog kita. Berikut class-class yang akan terlibat:
HALAMAN 84 | JAVA SWING
Pertimbangan dalam pemetaan
Seperti sudah disinggung sekilas dalam bagian sebelumnya, ada
beberapa ketidak sesuaian (mismatch) antara desain objek dan
desain database. Hubungan antar tabel di database jauh lebih
sederhana daripada hubungan antar class di aplikasi berorientasi
objek.
Dalam kaitannya dengan hubungan antar class, ada beberapa hal
yang harus kita perhatikan, yaitu:
• kasta class
• navigasi
• jenis collection
• optionality
• transitive persistence
HALAMAN 86 | JAVA SWING
Navigasi
Kita harus memikirkan urusan arah navigasi (direction) dalam
merancang pemetaan. Dua class dikatakan memiliki navigasi dua
arah (bidirectional) apabila kita dapat mengakses class yang satu
dari class yang lain, dan sebaliknya. Sebagai contoh, User dan
Group mempunyai hubungan bidirectional, jadi kode Javanya kira-
kira seperti ini.
public class User {
private Set<Group> groups = new HashSet<Group>();
}
public class Group {
private Set<User> members = new HashSet<User>();
}
User dan Author unidirectional, artinya dari class User kita dapat
mengakses class Author. Tapi dari class Author kita tidak dapat
mengakses class User. Berikut kode Javanya.
public class User {
private Author author;
}
Urusan navigasi ini hanya ada di kode Java. Apapun desain navigasi
yang kita buat, tidak mempengaruhi struktur tabel kita.
Jenis Collection
Dalam desain kita di atas, ada beberapa hubungan one-to-many dan
many-to-many. Urusan many ini direpresentasikan dalam Java
dengan menggunakan Collections Framework.
Kita mengenal beberapa interface dalam Collections Framework
dengan sifatnya masing-masing:
• Set : Objek yang disimpan dalam Set tidak boleh ada yang sama.
Set tidak bisa mengingat urutan. Jadi kita tidak bisa
mengharapkan objek yang dimasukkan pertama akan muncul
pertama juga. Set biasanya diinisialisasi dengan menggunakan
implementasi HashSet.
• List : Berbeda dengan Set, List mampu mengingat urutan.
Perilakunya mirip dengan array. Kita dapat mengatur urutan
objek yang disimpan di dalamnya. Objek List bisa diurutkan
melalui perintah order by dalam SQL, atau dengan adanya nilai
index, yang menunjukkan urutan objek di dalam List. Biasanya
List diinisialisasi dengan implementasi ArrayList.
• SortedSet : Interface ini digunakan bila kita ingin menyimpan
objek yang tidak boleh sama, tapi menginginkan ada urutan
tertentu. Kita dapat memasang Comparator ke dalam SortedSet
untuk mengatur urutan penyimpanan objek. Biasanya SortedSet
diinisialisasi menggunakan TreeSet.
• Map : Interface ini menyimpan pasangan key dan value. Biasanya
diinisialisasi menggunakan HashMap.
JAVA PERSISTENCE API (JPA) | HALAMAN 91
Optionality
Masalah optionality ini hanya ada di sisi database. Dari sudut
pandang desain object, optionality tidak menjadi pertimbangan.
Mari kita lihat lagi relasi antara User dan Author. Pada kasus kita,
satu User pasti memiliki satu Author, dan sebaliknya. Desain
seperti ini direalisasikan di database dengan DDL berikut:
create table T_AUTHOR (
id INT PRIMARY KEY AUTO_INCREMENT
);
create table T_USER (
id INT PRIMARY KEY AUTO_INCREMENT,
author_id INT NOT NULL
);
create table T_USER (
id INT PRIMARY KEY AUTO_INCREMENT
);
create table T_USER_AUTHOR (
user_id INT,
author_id INT,
PRIMARY KEY(user_id, author_id)
);
Article tutorial = new Article();
tutorial.setTitle(“Belajar JPA”);
tutorial.setAuthor(endy);
endy.getArticles().add(tutorial);
entityManager.persist(endy);
Pada kasus di atas, class Article adalah Entity, jadi JPA tidak
otomatis melakukan insert. Jika dijalankan, kode di atas akan
menghasilkan error, yang menyebutkan bahwa object tutorial
belum ada di database, sehingga tidak bisa dihubungkan dengan
object endy.
JAVA PERSISTENCE API (JPA) | HALAMAN 93
Enum Type
Kita mulai dari yang paling sederhana, yaitu tipe data enum. Dalam
domain model kita, enum digunakan untuk menentukan ijin akses
user. Mari kita lihat class User.
public class User {
private Integer id;
private String username;
private String password;
private UserLevel level;
}
Class User ini menggunakan fitur baru dalam Java 5, yaitu Typesafe
Enum. Adapun enum UserLevel tidak sulit, kodenya seperti ini.
public enum UserLevel {
CONTRIBUTOR, EDITOR, ADMINISTRATOR
}
public class User {
private Integer id;
private String username;
private String password;
@Enumerated(value = EnumType.STRING)
private UserLevel level;
}
Value Type
Kita memiliki satu value type, yaitu List<String> emails pada
class Author. Berikut pemetaannya.
public class Author {
@CollectionOfElements(targetElement = String.class)
@JoinTable(
name = "T_AUTHOR_EMAIL",
joinColumns = {@JoinColumn(name = "author_id")}
)
@Column(name = "email")
private Set<String> emails = new HashSet<String>();
One to One
One to One menghubungkan dua entity. Kita menggunakan
hubungan ini untuk Author dan User. Yang perlu diperhatikan
hanyalah class User, karena navigasinya cuma satu arah. Berikut
class User.
public class User {
@OneToOne
@JoinColumn(name = "author_id", nullable = false)
private Author author;
}
Kita mengatur kolom foreign key author_id agar tidak boleh null.
Ini berkaitan dengan masalah optionality yang sudah dijelaskan di
atas.
Many to One
Pada contoh aplikasi kita, mapping Many to One ada pada
hubungan antara class Article dan Category. Navigasinya satu
arah, dari Article ke Category. Dengan demikian, pada class
Category, tidak ada property Article.
public class Category {
@Id @GeneratedValue
private Integer id;
private String name;
private String description;
}
One to Many
List dengan order by
Kita memiliki beberapa kasus One To Many. Pertama, kita lihat
dulu tipe collection List yang menggunakan sorting di sisi
database melalui perintah order by.
Hubungan ini ada antara Author dan Article. Karena
hubungannya dua arah (bidirectional), maka kita akan melihat
mapping di kedua sisi class. Berikut gambar domain modelnya.
Di sisi Author,
public class Author {
@OneToMany(mappedBy = "author")
@OrderBy("publishDate")
private List<Article> articles
= new ArrayList<Article>();
}
penting
inverse ini juga mengatur eksekusi SQL. Mari kita
bahas internal JPA sedikit.
JPA mampu membuat Asosiasi dua arah antara Author dan Article
pemetaan satu arah dari sebetulnya terdiri dari dua asosiasi satu arah, yaitu
Author ke Article, bahkan dari Author ke Article, dan sebaliknya. Di dalam
tanpa adanya property database, asosiasi ini diimplementasikan dengan
author di sisi Article. foreign key author_id yang ada dalam tabel
T_ARTICLE. Dengan demikian, satu hubungan foreign
Pemetaan satu arah ini
tetap dilakukan dengan key dipetakan dua kali oleh JPA.
adanya foreign key Konsekuensinya, dua mapping ini akan menghasilkan
author_id di T_ARTIC LE dua kali eksekusi SQL. Coba perhatikan skenario
berikut.
Tapi konsekuensinya,
JPA tidak tahu apakah
foreign key author_id
tersebut sudah
dipetakan atau belum.
Author endy = entityManager.createQuery(“select a from
Article a where a.id=:id”)
.setParameter(“id”,100).getSingleResult();
Article tutorial = new Article();
tutorial.setTitle(“Belajar JPA”);
tutorial.setAuthor(endy);
endy.getArticles().add(tutorial);
entityManager.persist(tutorial);
entityManager.persist(endy);
insert into T_ARTICLE (title, author_id)
values ('Belajar JPA', 100);
update T_ARTICLE set author_id=100
where title='Belajar JPA'; penting
Kita lihat di atas, JPA menjalankan SQL update, Inverse tidak
padahal sebelumnya author_id sudah diset menurut berhubungan dengan
cascade.
id authornya. Ini disebabkan karena foreign key
author_id dipetakan dua kali. C ascade hanya
JPA tidak bisa mendeteksi ini secara otomatis, karena menyuruh JPA untuk
tidak memungkinkan secara logika. Jadi, kita harus memeriksa apakah entity
lain yang terhubung
memberi tahu JPA bahwa author_id sudah dipetakan
sudah di-
oleh class Article. save/update/delete atau
Setelah kita menggunakan keyword mappedBy, kode belum
program di atas akan menghasilkan eksekusi SQL
sebagai berikut.
select * from T_AUTHOR where id=100;
insert into T_ARTICLE (title, author_id)
values ('Belajar JPA', 100);
Article tutorial = new Article();
endy.getArticles().add(tutorial);
entityManager.persist(endy);
Many to Many
Bila kita sudah menguasai pemetaan One-to-Many, maka Many-to-
Many tidak sulit. Perbedaannya hanya terletak di anotasinya. Yang
tadinya @OneToMany, diganti menjadi @ManyToMany.
Sama dengan One-to-Many, kita harus menentukan sisi mana yang
HALAMAN 100 | JAVA SWING
inverse. Pada contoh kali ini, sisi inverse terletak pada class User.
Berikut isi class User.
public class User {
@ManyToMany(mappedBy = "members")
private Set<Group> groups = new HashSet<Group>();
}
@ManyToMany
@JoinTable(
name = "T_GROUP_MEMBERS",
joinColumns = {@JoinColumn(name = "group_id")},
inverseJoinColumns = {@JoinColumn(name = "user_id")}
)
private Set<User> members = new HashSet<User>();
}
ParentChild
Terakhir, kita akan membuat pemetaan parent-child. Ini merupakan
pemetaannya yang sering kita gunakan. Pemetaan ini biasanya
berbentuk one-to-many. Sisi one menentukan kondisi sisi many.
Bila terjadi save, update, atau delete pada sisi one, maka sisi many
akan terpengaruh.
Sebagai contoh, kita akan menggunakan relasi parent-child ini
pada hubungan antara Author dan Article. Bila Author dihapus,
maka seluruh Article yang pernah ditulisnya juga akan ikut
terhapus.
JAVA PERSISTENCE API (JPA) | HALAMAN 101
Mengambil Objek dari Database
JPA menyediakan banyak cara untuk mengambil data dari
database. Berbagai pilihan cara ini disesuaikan dengan preferensi
programmer. Ada orang yang lebih menyukai gaya SQL karena
lebih ringkas dan mudah. Ada juga yang lebih menyukai gaya
programmatic berorientasi objek karena type-safe. Beberapa
programmer yang merupakan alumni Microsoft Access juga bisa
ikut menikmati JPA dengan Query By Example.
JPA Query Language (JPAQL)
JPAQL adalah bahasa query JPA yang mirip dengan SQL. Bedanya,
dalam JPAQL kita menggunakan nama object dan property, bukan
nama tabel dan kolom.
Query Sederhana
Untuk contoh pertama, mari kita implementasikan
HALAMAN 102 | JAVA SWING
ArticleDao.findAll().
public class ArticleDao {
public List<Article> findAll() {
return entityManager.createQuery(
“selct a from Article a”).getResultList();
}
}
Parameter Binding
Bagaimana kalau kita mau mengirim parameter ke query? JPA
mendukung parameter binding, mirip dengan PreparedStatement
di JDBC.
Bila kita ingin mengambil artikel yang ditulis pengarang tertentu,
berikut kodenya.
JAVA PERSISTENCE API (JPA) | HALAMAN 103
public List<Article> findByAuthor(Author author) {
String query = "from Article a ";
query += " where a.author.id = :authorId ";
return entityManager
.createQuery(query)
.setParameter("authorId", author.getId())
.getResultList();
}
return entityManager.createQuery(query)
.setParameter("publishDate", publishDate)
.getResultList();
}
Named Query
Kita bisa mengeluarkan JPAQL dari dalam objek DAO dan
memindahkannya ke class Entity. Dari class DAO, kita cukup
memanggil nama query tersebut. Fitur ini disebut Named Query.
Misalnya, kita ingin mengambil artikel berdasarkan kategori.
Berikut JPAQL-nya.
from Article a where a.category.id = :categoryId
JPAQL ini bisa kita letakkan dalam class Article. Berikut deklarasi
class Article.
HALAMAN 104 | JAVA SWING
@Entity @Table(name = "T_ARTICLE")
@NamedQueries({
@NamedQuery(
name = "articleByCategory",
query = "from Article a "+
"where a.category.id = :categoryId"
)
})
public class Article { }
Restriction
Kita menggunakan restriction untuk membatasi jumlah record yang
dihasilkan. Mirip dengan SQL, kita menggunakan keyword where
untuk membatasi hasil query.
Contohnya, kita mengambil artikel yang diterbitkan setelah tanggal
tertentu. JPAQLnya tampak seperti ini:
from Article a where a.publishDate > :publishDate
Operator Penjelasan
. navigasi object
+- untuk membuat menjadi positif/negatif
*/ perkalian dan pembagian
+- penjumlahan dan pengurangan
= <> sama dengan atau tidak sama dengan
<, >, <=, >= perbandingan
[NOT] BETWEEN, [NOT] LIKE, perbandingan, mirip dengan sintaks SQL
[NOT] IN, IS [NOT] NULL
IS [NOT] EMPTY, [NOT] pengecekan collection
MEMBER [OF]
JAVA PERSISTENCE API (JPA) | HALAMAN 105
List<Article> hasil =
entityManager.createQuery(jpaql).getResultList();
Contoh lain, bila kita ingin mencari artikel yang diawali huruf A dan
juga huruf B, JPAQLnya seperti ini.
from Article a where a.title like 'A%'
or a.title like 'B%'
List<Article> hasil =
entityManager.createQuery(jpaql).getResultList();
Projection
Bila tadi kita sudah menentukan sumber data dengan keyword from
dan batasan hasil dengan keyword where, sekarang kita bisa
menentukan format hasil yang dikeluarkan dengan keyword
select.
Mari kita lihat lagi query user yang menjadi anggota grup.
from User u, Group g where g.name=? and u member of
g.members
Pada query di atas, kita bisa memilih untuk hanya mengambil data
user saja dengan menggunakan select. Query di atas bisa ditulis
menjadi seperti ini:
select u
from User u, Group g
where g.name=? and u member of g.members
return entityManager
.createQuery(jpaql)
.setString("groupName", groupName)
.getResultList();
}
Join
JPA memiliki kemampuan untuk menggabungkan beberapa objek
sekaligus. Sebagai contoh, kita ingin menampilkan nama penulis
JAVA PERSISTENCE API (JPA) | HALAMAN 107
Report Query
Report query adalah query yang mengandalkan kemampuan
database untuk melakukan agregasi terhadap data yang jumlahnya
banyak. Biasanya report query banyak memanfaatkan aggregate
function seperti sum, count, group by, dan having.
Sebagai contoh, bila kita ingin menghitung jumlah artikel yang
sudah ditulis seorang author, kita bisa menggunakan query berikut.
select count (a)
from Article a
where a.author.fullname = 'endy'
Subquery
JPA juga mendukung query di dalam query. Sebagai contoh, kita
ingin menampilkan penulis mana yang pernah membuat artikel
dengan nama kategori berakhiran News.
HALAMAN 108 | JAVA SWING
select distinct (au)
from Author au, Article ar
where ar.category.id in (
select c.id from Category c where c.name like '%News'
)
Native SQL
Jika JPAQL di atas masih juga tidak mencukupi, kita bisa langsung
mengeksekusi SQL ke database melalui JPA.
Sejauh ini, JPA sudah mencukupi untuk aplikasi blog kita. Tapi
sekedar untuk menambah pengetahuan, mari kita ambil 10 artikel
terbaru dengan menggunakan native SQL MySQL.
SQLnya sebagai berikut
select * from T_ARTICLE
order by publishDate desc limit 0,10
return entityManager
.createNativeQuery(sql,Article.class)
.getResultList();
}
Jasper Report
Pengenalan
Menampilkan report atau laporan merupakan hal yang penting dan
umum digunakan oleh aplikasi manapun, terutama yang bersifat
sistem informasi. Oleh karena itu kita akan membahas bagaimana
membuat desain report, mengisi report dengan data, lalu
memberikan hasilnya kepada pengguna. Dalam Java, terdapat
berbagai teknologi untuk membuat report diantaranya adalah,
● JasperReport, http://jasperreport.sourceforge.net/
● BIRT, http://www.birt-exchange.com/
● Data Vision, http://datavision.sourceforge.net/
JasperReport merupakan reporting tools yang paling populer di
Java dan bahkan beberapa aplikasi PHP menggunakan
JasperReport sebagai solusi untuk menampilkan report.
Instalasi
Persiapan yang perlu kita lakukan adalah:
1. Menginstall Java SDK, versi yang digunakan adalah JDK 1.6.0.
Anda dapat mendownload JDK tersebut dari website
http://java.sun.com
2. Menginstall NetBeans 6.0
3. Menginstall iReport
4. Menginstall MySQL
Java SDK diperlukan sebagai toolkit untuk mengembangkan
aplikasi Java. Di dalamnya terdapat Java compiler, java virtual
machine dan java library standard. Tanpa SDK kita tidak akan bisa
mengembangkan aplikasi Java.
NetBeans adalah IDE (Integrated Development Environment) yang
dikembangkan oleh Sun Microsystems. NetBeans difokuskan untuk
mengembangkan aplikasi java secara produktif, didalamnya
terdapat banyak wizard yang mengotomatisasi pengembangan
aplikasi, menghindarkan developer dari low level configuration
yang rumit.
iReport adalah visual designer untuk membuat reporting
menggunakan library jasperreport. Tanpa iReport development
HALAMAN 110 | JAVA SWING
Alur Proses JasperReport
Untuk membuat dan menampilkan sebuah report ada beberapa hal
yang harus dilakukan,
1. Merancang report menggunakan visual report designer,
seperti iReport. File dihasilkan ber-ekstensi *.jrxml.
2. Mengkompilasi desain report agar siap diisi data. Hasil
rancangan report yang sudah dikompilasi berekstensi
*.jasper.
Ada berbagai cara untuk mengkompilasi desain report,
● Di dalam kode java atau,
● Menggunakan ANT task.
Cara yang kedua merupakan pendekatan yang paling umum
digunakan karena kita tidak mungkin mengubah desain
report pada saat run-time atau setelah aplikasi di-deploy.
3. Mengisi report dengan data. Data yang diberikan dapat
berbagai jenis sesuai dengan kebutuhan, hal ini akan
dibahas pada bab selanjutnya. Report yang sudah diisi data
berekstensi *.jrprint.
4. Menentukan jenis report yang ingin ditampilkan. Saat ini
JasperReport mendukung berbagai jenis format seperti,
PDF, XLS, RTF, ODT, HTML, CSV, dan plain text.
Istilah Umum dalam JasperReport
Sebelum membahas lebih jauh mengenai JasperReport perlu
diketahui beberapa istilah umum yang biasa digunakan,
● Reporting data
Mengisi data ke dalam report dapat dilakukan dengan
menggunakan,
○ Field, untuk menampilkan data yang berasal dari query
database atau datasource.
○ Paramater, untuk menampilkan parameter report.
Bentuk dari parameter adalah Map dengan tipe key dan
JASPER REPORT | HALAMAN 111
iReport sebagai Visual Designer
Untuk mendesain report kita akan menggunakan iReport,
instalasinya sangat mudah.
● Pengguna Windows bisa mengunduh file installer iReport,
menginstall dan langsung menjalankannya.
● Bagi pengguna sistem operasi *Nix bisa mengunduh file
arsipnya berupa tar.gz dan mengekstraknya. Setelah itu
menjalankannya dengan,
cd /home/user/iReport2.0.4
sh iReport.sh
Konfigurasi Koneksi Database dalam
iReport
Sebelum menulis SQL dalam report, kita perlu mengkonfigurasi
koneksi database. Caranya dengan,
Data > Connection / Data Sources
New > Pilih Database JDBC Connection > Next
CREATE DATABASE ejb3;
CREATE TABLE T_PERSON
GRANT ALL ON belajar.* TO belajar@localhost IDENTIFIED BY
'java';
FLUSH PRIVILEGES;
Menampilkan Data dalam Report
Ada dua pendekatan umum untuk menampilkan atau mengisi data
ke dalam report,
● Inline SQL, menampilkan data melalui SQL yang disimpan
pada file desain report.
● DataSource, menampilkan data melalui interface
DataSource yang disediakan oleh JasperReport. DataSource
ini didefinisikan di dalam kode Java sehingga report hanya
berfungsi untuk menampilkan data saja.
Pendekatan pertama merupakan pendekatan yang paling
sederhana. Oleh karena itu kita akan membahas menampilkan data
melalui inline SQL. Untuk mendefinisikan SQL dalam report dapat
dilakukan dengan,
File > New Document
Beri nama report dengan PersonReport > OK
Edit > Report Query
Kompilasi Report dengan Ant
Setelah desain sudah jadi maka kita perlu membuat ant target
JASPER REPORT | HALAMAN 115
Setelah itu kita definisikan terlebih dahulu dimana lokasi kode java
dan report berada dan mengatur classpath untuk library yang
dibutuhkan dalam kompilasi report.
<! definisi lokasi >
<property name="source.java" value="src/java" />
<property name="compile.report.dir"
value="src/java/report"/>
<! setting classpath >
<path id="compile.classpath">
<pathelement location="${source.java}" />
<pathelement location="${compile.report.dir}" />
<fileset dir="lib" includes="**/*jar" />
</path>
init:
depsmodulejar:
depsearjar:
depsjar:
libraryinclusioninarchive:
libraryinclusioninmanifest:
compile:
compilereport:
Compiling 1 report design files.
File :
/home/ifnu/NetBeansProjects/jasper/jasper/report/PersonRe
port.jrxml ... OK.
BUILD SUCCESSFUL (total time: 4 seconds)
Integrasi JasperReport dengan Swing
Integrasi jasperreport dengan Swing sebelumnya dapat dilakukan
dengan mudah. Ada berbagai skenario untuk menampilkan
halaman atau data dalam Swing yaitu,
● Menampilkan dalam JPanel menggunakan JRViewer
● Menampilkan dalam JFrame menggunakan JasperViewer
● Mengeksport langsung hasil report ke dalam format file
seperti PDF, Excell atau Word
Pendekatan pertama dan kedua sama dari sisi kode, hanya saja
ditampilkan dengan menggunakan komponen yang berbeda. Cara
yang paling lazim adalah dengan menggunakan JRViewer, dimana
kita bisa meletakkan viewer report di manapun kita inginkan,
karena JRViewer adalah JPanel.
ResultSet rs = stmn.executeQuery();
String jasper =
JasperCompileManager.compileReportToFile(
System.getProperty("user.dir") +
"/src/jasper/report/person.jrxml");
JRResultSetDataSource resource = new
JRResultSetDataSource(rs);
String result =
JasperFillManager.fillReportToFile(jasper,
new HashMap(), resource);
JRViewer viewer = new JRViewer(result, false);
JASPER REPORT | HALAMAN 117
Menampilkan Report Menggunakan
DataSource
Sebelumnya kita telah mencoba pendekatan pertama untuk
menampilkan report yaitu dengan menyimpan kode SQL di dalam
report. Kekurangan dari pendekatan ini adalah dari sisi code
maintability, karena kode SQL terpisah dari source code aplikasi.
Akibatnya akan terjadi banyak duplikasi, misalnya kita sudah punya
kode SQL di source code aplikasi untuk menampilkan seluruh
daftar Person dan kemudian kita ingin menampilkan report daftar
Person dalam bentuk PDF. Maka yang selanjutnya dilakukan adalah
copy-paste kode SQL dari source code aplikasi ke dalam report.
Bayangkan jika kita mempunyai 10 report yang menampilkan daftar
Person dengan kode SQL yang sama dengan source code aplikasi
lalu kita mengubah salah satu nama kolom dari tabel T_PERSON,
maka tentu seluruh report harus diubah dan dicompile ulang.
JasperReport menyediakan solusi untuk hal ini dengan
menggunakan DataSource. DataSource berfungsi untuk
menyimpan data yang ingin ditampilkan, misalkan dari database,
kemudian dikirim ke dalam report untuk selanjutnya ditampilkan.
Ada berbagai jenis DataSource yang dapat kita gunakan
berdasarkan tipe data yang ingin disimpan,
● JRMapArrayDataSource untuk menyimpan tipe data array of
map
● JRMapCollectionDataSource untuk menyimpan tipe data
collection of map
● JRBeanArrayDataSource untuk menyimpan tipe data array of
bean
● JRBeanCollectionDataSource untuk menyimpan tipe data
collection of bean
● JRTableModelDataSource untuk menyimpan tipe data
tablemodel di swing
● JRXmlDataSource untuk menyimpan tipe data xml
DataSource yang umum digunakan adalah
JRBeanCollectionDataSource. Kita akan menampilkan daftar
Person, dengan membuat Collection dari Person bean yang
kemudian akan diberikan ke JRBeanCollectionDataSource. Pertama
dibuat terlebih dahulu Person.java,
HALAMAN 118 | JAVA SWING
public class Person {
private int id;
private String name;
private String email;
// Generate getter and setter
}
<queryString>
<![CDATA[select * from T_PERSON]]>
</queryString>
<field name="id" class="java.lang.Integer"/>
<field name="name" class="java.lang.String"/>
<field name="email" class="java.lang.String"/>
<! desain report >
</jasperReport>
<field name="id" class="java.lang.Integer"/>
<field name="name" class="java.lang.String"/>
<field name="email" class="java.lang.String"/>
<! desain report >
</jasperReport>
public class PersonReport {
public static void main(String[] args) throws
JRException {
// Siapkan datasource
JRBeanCollectionDataSource dataSource = new
JRBeanCollectionDataSource(prepareDataSource());
// Compile JRXML menjadi Jasper
JasperReport jasperReport = JasperCompileManager
.compileReport(
"/home/dhiku/jasper/PersonReport.jrxml");
// Fill report dengan datasource
JasperPrint jasperPrint =
JasperFillManager.fillReport(jasperReport,
new HashMap(), dataSource);
// Export report
JasperExportManager.exportReportToPdfFile(
jasperPrint,
"/home/dhiku/jasper/PersonReport.pdf");
}
public static List prepareDataSource() {
List users = new ArrayList();
users.add(new Person("1", "Hadikusuma Wahab",
"dh1ku.ilkom@gmail.com"));
users.add(new Person("2", "Endy Muhardin",
"emuhardin@gmail.com"));
users.add(new Person("3", "Ifnu Bima",
"ifnubima@gmail.com"));
return users;
}
}
Mengirim Parameter
Selain DataSource, adapula parameter yang dapat dikirimkan ke
dalam report. Misalkan kita ingin mencetak judul report secara
dinamis yang dikirim dari kode Java. Berikut langkah-langkah
untuk mengirimkan parameter,
1. Siapkan parameter di report
View > Parameter
Klik New
Isi parameter name, “judul”
Klik OK
HashMap<String, String> param =
new HashMap<String, String>();
// Fill Report
JasperPrint jasperPrint =
JasperFillManager.fillReport(jasperReport,
param, dataSource);
// Export Report
Menggunakan Scriptlet
Scriptlet adalah kode Java yang diselipkan pada saat proses fill
report. Proses fill report terdiri dari beberapa tahap, scriptlet dapat
menjalankan kode Java pada sebelum dan sesudah tahap-tahap
tersebut misalnya,
● Sebelum atau sesudah report diinisialisasi
● Sebelum atau sesudah setiap halaman report diinisialisasi
● Sebelum atau sesudah setiap kolom diinisialisasi
● Sebelum atau sesudah setiap group diinisalisasi
● Sebelum atau sesudah setiap baris atau record diinisialisasi
Untuk membuat scriptlet maka kita harus membuat sebuah class
yang meng-extend kelas JRAbstractScriptlet. Berikut contoh
scriptlet yang akan dijalankan setiap sebelum baris diinisialisasi,
JASPER REPORT | HALAMAN 121
public class PersonScriplet extends JRAbstractScriptlet {
public int number = 0;
public void beforeDetailEval() throws
JRScriptletException
{
String name = (java.lang.String)getFieldValue("name");
System.out.println("number" + ". " + name);
number++
}
Penutup
Dengan ilmu yang sudah diperoleh dalam pelatihan ini, anda sudah
bisa mulai untuk membuat program Java desktop sederhana. Pada
awalnya pasti terasa sulit, sikapi dengan pantang menyerah dan
selalu cari cara yang lebih baik dalam membuat aplikasi.
Langkah selanjutnya anda bisa mulai aktif bertanya atau menjawab
hal-hal yang berhubungan dengan Java. Media yang bisa digunakan
banyak sekali, bisa forum milis atau diskusi dengan teman. Ini cara
terbaik untuk mengetes apakah pemahaman anda mengenai Java
sudah cukup lengkap atau anda masih perlu belajar lebih banyak
lagi.
Setelah yakin dengan kemampuan anda, berfikirlah untuk
mengambil sertifikasi profesional Java. Pelatihan untuk persiapan
sertifikasi Java banyak tersedia di lembaga pelatihan. Kalau anda
merasa terlalu berat mengambil kursus persiapan sertifikasi,
berlatihlah sendiri menggunakan materi yang banyak tersedia di
internet, misalnya javaranch.com.
Cara belajar Java yang paling efektif adalah dengan melibatkan diri
dalam project berbasis Java. Jika di perusahaan anda tidak
memungkinkan, di luar sana banyak sekali project opensource yang
memerlukan bantuan anda. Berkunjunglah ke website-website open
source project hosting seperti sourceforge.net atau dev.java.net
Learn, Try dan Teach adalah formula untuk meningkatkan
pengetahuan anda tentang Java. Jika sudah belajar dan sukses
mencoba, tularkan ilmu anda pada orang disekeliling anda, dijamin
ilmunya bakalan bertambah berlipat-lipat.
REFERENSI DAN BACAAN LEBIH LANJUT | HALAMAN 123