Jumat, 14 Agustus 2015

Merancang Penelitian - State Of The Art ...

Kali ini mau sedikit berbagi pengalaman dalam hal membimbing Tugas Akhir (Skripsi) mahasiswa jenjang sarjana S1. Banyak mahasiswa yang kebingungan untuk mencari materi Tugas Akhir nya, bahkan pada tahap ini sampai-sampai tidak sedikit mahasiswa yang 'menghilang' tidak tahu rimbanya sehingga sangat sayang sekali dengan waktu yang terbuang yang membuat predikat mahasiswa yang bersangkutan lulus sarjana S1 melewati (jauh) dari 8 semester yang seharusnya. Sebaliknya tidak sedikit juga yang masih muncul batang hidungnya maka proposal Tugas Akhir nya mendapat perombakan besar dari dosen-dosen pembahas. Tentu hal tersebut semakin membuat jatuh mental dari mahasiswa untuk menuntaskan pekerjaan Tugas Akhir nya.

Berdasarkan seminar dan pengalaman yang penulis ikuti dan melakukan penelitian, maka dalam dunia penelitian terdapat konsep yang disebut dengan "State Of The Art" (SOTA). Menurut wikipedia pengertian bebas dari State Of The Art (SOTA) adalah: The term "state of the art" refers to the highest level of general development, as of a device, technique, or scientific field achieved at a particular time. It also refers to the level of development (as of a device, procedure, process, technique, or science) reached at any particular time as a result of the common methodologies employed [2]. Dari hal tersebut intinya SOTA adalah pencapaian tertinggi dari sebuah pengembangan yang dapat berbentuk perangkat/produk, teknik/cara, atau sains yang dicapai pada waktu tertentu. SOTA juga dapat berarti ukuran tingkat pengembangan (dalam bentuk sebuah perangkat/produk, prosedur, proses, teknik/cara, atau sains) yang dicapai pada waktu tertentu sebagai sebuah hasil dari penerapan metodologi-metodologi yang ada. Menurut saya SOTA merupakan faktor penting untuk memposisikan penelitian yang akan dilakukan.

Dalam dunia penelitian juga terdapat konsep yang disebut dengan "Novelty". Menurut wikipedia Novelty adalah: Novelty (derived from Latin word novus for "new") is the quality of being new, or following from that, of being striking, original or unusual [3]. Terjemahan bebasnya dari Novelty adalah tingkat kualitas dari kebaharuannya, atau mengikuti pengertian tersebut adalah seberapa bedanya (mencoloknya), keasliannya, atau ketidakbiasaannya. Intinya Novelty adalah kebaharuan apa yang akan ditawarkan dari penelitian yang akan dilakukan.

Pada penelitian jenjang S3 maka SOTA dan Novelty adalah wajib hukumnya. Bahkan untuk mendukung SOTA referensi jurnal ataupun publikasi ilmiah lainnya diwajibkan paling lama sampai 5 tahun kebelakang. Nah untuk penelitian pada jenjang dibawahnya, menurut saya Novelty tidak perlu wajib. Namun untuk jenjang S2 ataupun penelitian lepas lainnya referensi SOTA hendaknya memiliki rentang waktu paling lama sampai 5 tahun, adapun maksudnya pada penelitian jenjang ini ditujukan untuk menghasilkan subsitusi/pengganti dari perangkat/produk, prosedur, proses, teknik/cara, atau sains yang penerapannya sudah ada namun publikasi dan intisari hasil penelitian tersebut masih disembunyikan oleh negara peneliti yang bersangkutan, hal ini dimaksudkan untuk penjajahan dibidang teknologi dan sains yang pada ujungnya adalah penjajahan ekonomi satu negara terhadap negara lain. Sedangkan untuk jenjang S1, referensi SOTA dapat sangat "karet" (lebih fleksibel) baik dari segi masa waktu publikasi maupun jenis publikasinya. Pada jenjang S1 ini SOTA dapat saja diperoleh baik dari jurnal, laporan penelitian, buku tugas akhir, buku ilmiah, laporan proyek (rancangan dan atau implementasi), laporan investigasi/interview, bahkan bisa saja SOTA hanya berasal dari internet (online).

Saya sepakat bahwa penelitian pada jenjang S1 cukup bersifat "mempunyai kontribusi" [1]. Kontribusi disini bisa berbentuk penyelesaian masalah pada satu instansi atau perusahaan yang tentunya belum pernah dilakukan oleh orang lain sebagai kontribusi pada instansi/perusahaan tersebut, atau adanya penambahan variabel masalah terhadap kontribusi yang sudah ada sehingga penyelesaian masalah yang ada perlu reengineering. Atau penelitian pada jenjang ini dapat juga sebagai penyempurnaan penelitian sebelumnya berdasarkan referensi SOTA yang diajukan. Penyempurnaan disini bisa berbentuk penggunaan alat dan atau metode yang paling mutakhir dan tepat atau berbentuk melanjutkan penelitian tersebut. Dengan hal tersebut maka cukuplah sebagai SOTA untuk melakukan penelitian (Tugas Akhir) pada jenjang S1.

Berdasarkan pengalaman membaca dan sebagai dosen pembahas proposal penelitian (Tugas Akhir) mahasiswa S1, sebenarnya banyak ide-ide penelitian yang dikemukakan cukup bagus dan original, namun sangat jarang menyertakan referensi SOTA (jurnal, laporan penelitian, buku tugas akhir, buku ilmiah, laporan proyek, laporan investigasi/interview, publikasi internet) sebagai dasar pemikiran atau ide mengapa ingin melakukan penelitian tersebut. Mendapatkan dan membaca referensi SOTA ini penting agar nalar ide (dasar pemikiran) dan arah penelitian yang akan dilakukan benar, disamping teori-teori pendukung yang diperlukan telah dibaca dan dipahami.

Pada umumnya kerangka proposal penelitian adalah berbentuk sebagai berikut:
Abstrak
BAB 1. Pendahuluan
     1.1. Latar Belakang
     1.2. Tujuan Penelitian
     1.3. Manfaat Penelitian
     1.4. Batasan Masalah
BAB 2. Tinjauan Pustaka
BAB 3. Metodologi Penelitian
BAB 4. Biaya dan Jadwal Penelitian
     4.1. Anggaran Biaya Penelitian
     4.2. Jadwal Penelitian

Berikut ini adalah penjelasan mengenai apa saja yang harus dituangkan dalam setiap Bab/SubBab pada kerangka proposal penelitian:

Bagian Latar Belakang: Pada bagian ini adalah penuangan mengenai dasar pemikiran atau ide mengapa ingin melakukan penelitian ini. Pada bagian ini dapat dituangkan SOTA yang menjadi dasar penelitian sekaligus pencantuman nomor-nomor referensi SOTA baik dalam bentuk jurnal, laporan penelitian, buku ilmiah, laporan proyek, laporan investigasi/interview, atau publikasi internet (online). Bahkan pada paragraf terakhir pada bagian ini dapat ditulis secara eksplisit kalimat "State of the art : ........... " sebagai penegasan mengenai state of the art penelitian.

Bagian Tujuan Penelitian: Pada bagian ini dapat dituangkan penjelasan maksud/tujuan penelitian yang ingin "mempunyai kontribusi" tadi, dan atau reengineering solusi yang ada, dan atau penyempurnaan/melanjutkan penelitian. Ditambah penjelasan bentuk hasil dari penelitian nantinya, dimana dapat memilih kata-kata kunci satu atau beberapa kombinasi berikut: sebagai usulan/rekomendasi....., untuk menentukan....., sebagai pembanding....., membuat simulasi....., membuat rancangan....., membuat produk prototype....., membuat produk jadi (production)....., dan lain sebagainya.

Bagian Manfaat Penelitian: Pada bagian ini dapat dituangkan manfaat hasil dari penelitian. Disini tertuang kontribusi/manfaat apa dari hasil penelitian terhadap instansi atau perusahaan atau kelompok masyarakat bersangkutan. Atau manfaat apa yang dirasakan oleh masyarakat luas atas hasil penelitian. Untuk penelitian jenjang S3 maka manfaat yang berdampak untuk masyarakat luas adalah yang lebih utama.

Bagian Batasan Masalah: Pada bagian dapat dituangkan mengenai batasan penelitian. Hal ini dapat berbentuk batasan yang menyangkut perangkat bantu dan sarana penelitian, batasan variabel-variabel masalah, batasan fungsi-fungsi yang dihasilkan, batasan syarat lingkungan untuk hasil penelitian, dan lain sebagainya.

Bagian Tinjauan Pustaka: Pada bagian ini dapat dituangkan penjelasan semua teori-teori yang ada yang akan mendukung penelitian yang akan dilakukan. Jangan lupa dibagian ini mestinya banyak mencantumkan nomor referensi daftar pustakanya.

Bagian Metodologi Penelitian: Pada bagian ini dapat dituangkan penjelasan pelaksanaan penelitian yang akan dilakukan, berisi tahap-tahap dan urutan aktifitas apa saja yang akan dilakukan dalam penelitian nanti. Secara logika umum metodologi penelitian adalah: menganalisa dan mempelajari..., meneliti..., memilih..., membangun..., melakukan ujicoba... .

Bagian Anggaran Biaya Penelitian: Pada bagian ini dituangkan rinci rencana pos-pos pengeluaran biaya dan perkiraan besar biaya tiap pos yang akan dikeluarkan. Biasanya hal ini ditampilkan dalam bentuk tabel (matriks) pos-pos dan rencana biayanya.

Bagian Jadwal Penelitian: Pada bagian ini dituangkan rinci urutan rencana aktifitas penelitian berikut target tanggal mulai dan tanggal selesai per aktifitas. Lebih baik lagi hal ini disajikan dengan bantuan menggunakan teknik Project Management yang dapat menggambarkan ketergantungan satu aktifitas dengan aktifitas lain berikut titik-titik kritis pada aktifitas yang mana saja.

Harapannya dengan penjelasan diatas tadi maka proposal (rencana) penelitian yang diajukan dapat menunjukkan posisi penelitian nanti pada peta penelitian yang begitu luas, hal ini mirip dengan bagaimana anda mampu menunjukkan peta kota jakarta pada atlas dunia yang luas ini.

Mengambil terjemahan harfiah dari "state of the art" bahwa karya penelitian (Tugas Akhir) didudukkan sebagai sebuah karya seni yang memiliki cita rasa tinggi. Para penghasil karya seni ini selalu berusaha menghasilkan karya yang unik, berbeda dengan sebelumnya, tidak ada yang menyamai. Inilah yang disebut dengan pencapaian tertinggi - STATE OF THE ART. Karya seni ini dihasilkan dari hasil pemikiran dan tangan dengan penuh tanggungjawab sehingga rasanya sulit untuk ditiru, bahkan ketika dua orang pekerja karya melakukan kerjanya pada obyek yang sama maka hasilnya dapat dirasakan berbeda satu dengan yang lainnya.

Untuk para mahasiswa yang akan melakukan penelitian Tugas Akhir, jadilah anda seperti pekerja seni untuk menghasilkan karya yang unik. Bagi mereka yang telah berhasil menuntaskan karya Tugas Akhirnya maka berbanggalah dengan karya anda sebagai sebuah karya state of the art.

Sumber:
  1. Cahyo, Winda Nur. 2012. State Of The Art..... [Online] Tersedia: http://windanc.staff.uii.ac.id/2012/01/05/state-of-the-art/. [14 Agustus 2015].
  2. Wikipedia. 2015. State of the art. [Online] Tersedia: https://en.wikipedia.org/wiki/State_of_the_art. [14 Agustus 2015].
  3. Wikipedia.2014. Novelty. [Online] Tersedia: https://en.wikipedia.org/wiki/Novelty. [14 Agustus 2015].

Rabu, 17 Desember 2014

Aplikasi Web CRUD Menggunakan Hibernate dan JSF+Primefaces

1. Pendahuluan

Posting kali ini akan memberikan langkah-langkah pembuatan aplikasi web CRUD (Create Read Update Delete) menggunakan framework Hibernate dan JSF+Primefaces dengan mengakses ke sebuah database MySQL. Aplikasi web ini sudah termasuk lingkup JEE (Java Enterprise Edition), Bagi para programmer yang sudah menguasai Java core atau JSE (Java Standard Edition) sebaiknya dilanjutkan ke langkah sedikit lagi ke JEE. Dengan menguasai JEE maka anda bisa lebih produktif dalam pengertian anda mampu untuk membuat aplikasi-aplikasi bisnis untuk dunia industri.

Pada project ini saya menggunakan IDE Netbeans dan build tools Maven. Maven adalah sebuah build tools atau tool menajemen proyek untuk membangun aplikasi Java hingga skala enterprise. Build tools lain di Java antara lain Apache Ant, Gradle, SBT (Scala). Ada beberapa manfaat (keuntungan) membangun project Java menggunakan Maven, yaitu :

  • Portability : Satu project bisa dibuka diberbagai komputer (platform) dan editor/IDE. Project dengan Maven dapat dibuka misalnya dengan IDE Eclipse, Netbeans, IntelliJ, dan sebagainya dengan struktur direktori project yang sama di berbagai IDE tersebut. Disamping itu masalah library JAR yang tidak tersedia atau lokasi JAR yang berbeda ketika project dibuka di environment yang berbeda tidak akan terjadi karena Maven meregister library JAR dan akan mencarinya (meng-include-kan) baik dari repository lokal dan atau dari repository pusat (Maven central).
  • Dependency Management : Ketergantungan suatu project terhadap library lain dikelola dengan baik oleh Maven. Maven akan mencari dan menyimpan semua library di tempat yang sama (repository lokal di [userDirektori].m2 dan atau di repositroy central/internet) untuk semua komputer (environment).
  • Dependency Transitive : Ketergantungan library yang sambung menyambung ditangani oleh Maven. Misal kita mennggunakan hibernate.jar maka hibernate juga butuh cglib.jar, antir.jar, commons-logging.jar, dan lain-lain. Tanpa Maven, menyertakan hibernate.jar belum cukup, kita harus mencari dan menyertakan library-library lain yang berhubungan dengan hibernate.jar tadi. Belum lagi masalah versi library yang cocok untuk project kita.
  • Team work supporting : Manfaat Maven dari ketiga butir diatas maka memudahkan kita untuk mengerjakan project dalam group tim beberapa programmer. Para programmer dipersilahkan menggunakan IDE kesukaannya. Kebutuhan dependency library dapat dikelola bahkan library yang dibutuhkan dapat dibuat di satu server lokal untuk bisa diakses oleh tim programmer tersebut.
Kembali ke fokus pembahasan project kita. Hibernate adalah sebuah framework yang menyediakan tool untuk Object Relational Mapping (ORM). Berfungsi me-mapping-kan class model pada relasi database. Pada arsitektur MVC maka Hibernate menempati bagian model.
Sedangkan JSF (Java Server Faces) adalah UI framework untuk aplikasi java web. JSF didisain untuk meringankan beban penulisan dan memelihara aplikasi yang berjalan diatas Web Server Java dan me-render UIs kembali ke target client. JSF menyediakan kemudahan untuk hal-hal berikut :

  • Memudahkan membangun UI dari sekumpulan komponen yang reusable.
  • Menyederhanakan perpindahan aplikasi data dari dan ke UI.
  • Membantu mengelola state UI sepanjang server requests.
  • Menyediakan sebuah model sederhana untuk menulis events yang dibangkitkan di sisi clients ke kode-kode aplikasi sisi server.
  • Membuat lebih mudah membangun komponen-komponen custom UI dan dipakai ulang.
Primefaces merupakan salah satu implementasi komponen JSF untuk membangun UI yang memiliki tampilan interaktif dan menarik. JSF+Primefaces pada arsitektur MVC menempati bagian view dan JSF Managed Bean digunakan untuk menangani events UI yang merupakan kode-kode aplikasi sisi server. JSF Managed Bean pada arsitektur MVC menempati bagian controller.

Secara garis besar arsitektur aplikasi yang akan kita bangun ini dapat digambarkan pada gambar 1 dibawah.

Gambar 1. Arsitektur project SekolahHibernatePrimefacesCRUD


2. Membuat Database

Sebelum membuat project aplikasinya, maka kita siapkan dahulu tabel databasenya. DBMS yang saya pakai adalah MySQL. Buat database Sekolah dan tabel siswa di console MySQL dengan sintaks berikut :

CREATE DATABASE IF NOT EXISTS Sekolah;
USE Sekolah;

---
--- Membuat tabel siswa
--- 

CREATE TABLE IF NOT EXISTS `siswa` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`nama` varchar(50) NOT NULL,
`sekolah` varchar(50) NOT NULL,
`telp` varchar(30) NOT NULL,
`email` varchar(30) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

---
--- Dumping data untuk tabel siswa
---

INSERT INTO `siswa` (`id`, `nama`, `sekolah`, `telp`, `email`) VALUES
(1, 'Adnan Subianto', 'SMA 1 Jakarta', '08123456789', 'adnan@gmail.com'),
(2, 'Bambang Rudianto', 'SMA 5 Bandung', '08168765432', 'b4mb4ng@gmail.com'),
(3, 'Danang Abimanyu', 'SMA 2 Jakarta', '08114598742', 'danang@gmail.com');


3. Membuat Proyek Aplikasi Web

Dalam bagian ini kita akan membuat proyek aplikasi web melibatkan build tools maven di IDE Netbeans dan memasukkan framework Hibernate dan JSF+Primefaces.

 Gambar 2. Isian properti project


  1. Pilih File --> New Project dari menu utama untuk membuka Project wizard.
  2. Pilih Web Application dari kategori Maven. Klik Next.
  3. Ketik SekolahHibernatePrimefacesCRUD untuk nama project dan tentukan lokasi untuk menyimpan project.
  4. Optional. Modifikasi default Group Id dan Version. Lihat gambar 2.
  5. Klik Next. 
  6. Pilih Server (Web Server) untuk deploy project dan tentukan Java EE version. Klik Finish.

Meregister Database MySQL di IDE Netbeans


Untuk menambahkan dukungan ke Hibernate dan JSF maka kita perlu menambahkan artifacs yang diperlukan di pom.xml file sebagai dependency. Untungnya IDE Netbeans telah ada wizard untuk membantu menyertakan dependency artifact yang dibutuhkan sehingga tidak perlu untuk melakukan penambahan (editing) di pom.xml file, secara otomatis wizard akan menambahkannya ke pom.xml file.

Ketika kita menambahkan dependency Hibernate melalui wizard maka IDE akan membuat hibernate configuration file (hibernate.cfg.xml) yang berisi informasi koneksi database, resource mappings, dan properti koneksi lainnya. Saat itu kita harus menentukan koneksi database yang telah terdaftar di IDE. Oleh karena itu sebelum menambahkan dependency yang dibutuhkan maka kita harus me-register lebih dahulu database yang diperlukan dengan cara sebagai berikut:
  1. Buka tab service di window area bagian samping kiri IDE. Klik kanan MySQL server at ....
  2. Masukkan Administrator User Name (default root) dan Administrator Password yang sesuai. Klik Ok. Lihat gambar 3.
  3. Ekspan pada MySQL server at... maka akan terlihat database sekolah. Klik kanan pada sekolah dan pilih connect (masukkan password yang sesuai jika diminta). Tampilan setelah berhasil me-registrasi database mydb adalah seperti gambar 4.

Gambar 3. MySQL Properties saat meregister database.


Gambar 4. Hasil akhir setelah meregister database sekolah.

Meregister dan mengkonfigurasi database yang diperlukan sudah selesai dan siap digunakan oleh aplikasi.


Membentuk Struktur Proyek Aplikasi Untuk Mengimplementasi Arsitektur MVC

Agar struktur direktori proyek aplikasi kita rapi dan juga mengimplementasikan arsitektur MVC maka kita buat dulu direktori (package) baru di direktori Source Packages dengan langkah-langkah berikut :

  1. Klik kanan pada node Source Packages, kemudian pilih menu New, kemudian pilih menu Java Package. Jika tidak muncul menu 'Java Package' maka pilih menu Other... , kemudian pilih kategori Java, dan pilih file types Java Packages.
  2. Pada wizard yang muncuk ketikkan pada Package Name '[paketProyek].util'. Tampilannya adalah sesuai pada gambar 5.
  3. Ulangi langkah 1 sampai dengan 2 diatas untuk menambah paket-paket entity, dao, dan controller.

Gambar 5. Wizard menambah direktori paket.

Sehingga hasil akhir setelah penambahan paket selengkapnya adalah seperti pada gambar 6 dibawah.

Gambar 6. Tampilan setelah penambahan paket-paket MVC

Adapun kegunaan dari paket-paket yang ditambahkan tersebut adalah sebagai berikut:
  • paket util: untuk menampung file-file program bantuan untuk menangani koneksi ke database. Nantinya di paket ini akan berisi HibernateUtil.java yang di-generate melalui wizard. Ini adalah layer model.
  • paket entity: untuk menampung file-file program ORM (Object Relational Mapping) yang mem-mapping tabel database ke java class. Nantinya di paket ini akan berisi [namaTabel].java dan [namaTabel].hbm.xml yang akan di-generate melalui wizard. Ini adalah layer model.
  • paket dao: untuk menampung file-file program Data Access Object yaitu file program yang menangani fungsi CRUD (Create Read Update Delete) data. Ini adalah layer model.
  • paket controller: untuk menampung file-file program JSF Managed Bean yang berperan sebagai dispatcher atau mengendalikan file-file user interface (web). Ini adalah layer controller.
  • paket Web Pages: sudah di-generate saat pembentukan project dan digunakan untuk menampung file-file user interface sebagai ini adalah layer view.

Menambahkan Dependency Hibernate dan JSF+Primefaces

Untuk menambahkan framework Hibernate dan JSF+Primefaces ke aplikasi web kita maka lakukan langkah-langkah berikut :
  1. Klik kanan pada node proyek (nama proyek atau root direktori) dan pilih menu Properties. Maka akan tampil jendela Project Properties.
  2. Pada bagian Categories, klik Sources. Pastikan pada pilihan Source/Binary Format adalah 1.5 keatas dan Encoding adalah UTF-8.
  3. Pada bagian Categories, klik Frameworks, kemudian pada bagian Use Frameworks klik tombol Add jika belum tertera framework Hibernate dan JSF+Primefaces.
  4. Pada jendela add framework yang muncul pilih Hibernate x.x.x dahulu kemudian klik OK.
  5. Pada bagian Hibernate x.x.x configuration pastikan pilihan Database Connection dipiilih database sekolah seperti tertera pada gambar 7 dibawah.
  6. Kemudian lanjutkan untuk memasukkan framework JSF+Primefaces dengan mengklik tombol Add kembali.
  7. Pada jendela add framework yang muncul pilih JavaServer Face kemudian klik OK.
  8. Pada bagian JavaServer Faces Configuration klik tab Libraries, pastikan radio button Server Library dipilih (untuk di komputer saya versinya adalah JSF 2.2, ini tergantung versi di web servernya).
  9. Masih di JavaServer Faces Configuration klik tab Components, kemudian check pilihan Primefaces agar JSF+Primefaces nya masuk ke proyek kita. Setelah itu klik OK.
  10. Tunggu sesaat agar Maven memasukkan framework Hibernate dan JSF+Primefaces ke proyek kita.

Gambar 7. Memasukkan framework Hibernate ke proyek.

Gambar 8. Memasukkan framework JSF+Primefaces.

Setelah tahap memasukkan framework Hibernate dan JSF+Primefaces sukses maka isi dari node Dependencies proyek kita ini adalah seperti pada gambar 9. Terlihat adanya file-file library jar bernama hibernate dan primefaces.

Gambar 9. Isi direktori Dependencies setelah memasukkan Hibernate dan JSF+Primefaces


4. Membuat Aplikasi Web CRUD Sekolah

Mulai tahap ini kita mulai masuk untuk membuat dan memprogram aplikasi web CRUD Sekolah kita. Adapun tahapannya adalah sebagai berikut.


5. Memodifikasi File Konfigurasi Hibernate

Pada saat memasukkan framework Hibernate pada tahap sebelumnya maka IDE akan membentuk file hibernate.cfg.xml pada direktori Other Sources - src/main/resources - . File konfigurasi tersebut memuat informasi mengenai database connection, resource mappings, dan properti koneksi lainnya. Lakukan modifikasi dengan langkah-langkah berikut :

  1. Buka (klik 2x) file hibernate.cfg.xml, klik tab Design.
  2. Di editor multi-view xml, ekspan node Configuration Properties dibawah node Optional Properties.
  3. Klik tombol Add dan akan terbuka jendela dialog Add Hibernate Property. 
  4. Di kotak dialog, pilih property name hibernate.show_sql, dan set value ke true. Klik OK. Ini akan mengaktifkan debug logging dari statement-statement SQL.
  5. Ekspan node Miscellaneous Properties dan klik Add. Di kotak dialog yang muncul pilih property name hibernate.current_session_context_class dan set value ke thread. Klik OK. Ini akan mengaktifkan Hibernate's automatic session context management.
  6. Masih di Miscellaneous Properties, klik Add dan tambahkan property name hibernate.query.factory_class dan set value ke org.hibernate.hql.classic.ClassicQueryTranslatorFactory. Klik OK.
  7. Simpan (save) hasil modifikasi hibernate.cfg.xml ini.
Setelah modifikasi file hibernate.cfg.xml maka akan terlihat kofigurasi akhirnya seperti gambar 10 dibawah.


Gambar 10. Konfigurasi lengkap file hibernate.cfg.xml.

Jika pada editor multi-view xml dipilih tab Source, maka file konfigurasi hibernate.cfg.xml setelah modifikasi seharusnya terlihat seperti pada Gambar 11.

Gambar 11. Konfigurasi lengkap file hibernate.cfg.xml source code.


6. Membuat File Pembantu (Helper) HibernateUtil.java

Untuk menggunakan Hibernate kita perlu untuk membuat class pembantu yang menangani startup dan mengakses SessionFactory hibernate untuk memperoleh sebuah objek Session. Class tersebut memanggil configure() dan memuat file konfigurasi hibernate.cfg.xml dan mem-build SessionFactory untuk memperoleh objek Session yang dibutuhkan.

Untuk membuat class pembantu HibernateUtil.java kita gunakan wizard dengan langkah-langkah sebagai berikut:

  1. Klik kanan pada paket [paketProyek].util dan pilih New > Other untuk membuka New File wizard.
  2. Pilih Hibernate pada listing Categories dan pilih HibernateUtil.java dari list File Types. Klik Next. Seperti pada tampilan gambar 12.
  3. Ketik HibernateUtil di nama class dan pastikan lokasi paket (package) nya di [paketProyek].util. Klik Finish.

Gambar 12. Wizard untuk membuat file HibernateUtil.java.

Ketika kita mengklik Finish maka file HibernateUtil.java akan terbuka pada jendela editor. Kita dapat menutup saja file tersebut karena tidak diperlukan modifikasi apapun.


7. Membangkitkan File-file Hibernate Mapping dan Class-class Java

Kita akan menggunakan POJO (plain old java object) untuk mereprentasikan data dalam setiap tabel di database yang kita gunakan. Class java menspesifikasikan field-field kolom dalam table dan menggunakan setters dan getters untuk mengambil dan menulis data. Untuk memetakan POJO ke tabel-tabel kita dapat menggunakan sebuah Hibernate mapping file atau menggunakan anotasi-anotasi didalam class.

Kita dapat menggunakan Hibernate Mapping Files dan POJOs dari sebuah wizard Database untuk menciptakan multiple POJOs dan memetakan file berdasarkan tabel-tabel database. Ketika kita menggunakan wizard kita memilih semua tabel-tabel dimana kita ingin POJOs dan memetakan file-file tersebut dan IDE akan membangkitkan file-file POJO tersebut berdasarkan tabel-tabel database yang dipilih dan menambahkan isian pemetaan (mapping) ke hibernate.cfg.xml. Ketika kita menggunakan wizard kita dapat memilih file-file yang kita inginkan IDE untuk dibangkitkan (hanya POJOs, misalnya) dan memilih opsi-opsi pembangkitan kode (misalnya, hanya bangkitkan kode menggunakan anotasi EJB3). IDE Netbeans juga memiliki wizard untuk membantu menciptakan POJOs individual dan memetakan file-file dari awal.


Membuat File Hibernate Reverse Engineering

Kita akan melakukan Hibernate Mapping Files dan POJOs dari sebuah wizard Database. Oleh karena itu sebelumnya kita perlu membuat hibernate.reveng.xml yaitu file reverse engineering. File reverse engineering membuat kita memiliki kendali atas strategi memetakan database. Wizard Hibernate Reverse Engineering menciptakan sebuah file reverse engineering dengan sebuah konfigurasi default yang dapat kita edit melalui editor XML.

Untuk membuat file Hibernate reverse engineering, lakukan langkah-langkah berikut :

  1. Klik kanan pada node Source Packages dan pilih New > Other untuk membuka jendela wizard New File.
  2. Pilih Hibernate Reverse Engineering Wizard di Hibernate category. Klik Next.
  3. Ketik hibernate.reveng sebagai nama file dan pastikan lokasi folder (paket) di src/main/resources. Klik Next.
  4. Cari hibernate.cfg.xml dari Configuration File drop down list, jika belum terpilih.
  5. Pilih tabel siswa dari kolom Available Table dan klik Add untuk menambahkan tabel ke kolom Selected Table. Tampilan seperti terlihat pada gambar 13. Jika ada lebih dari satu tabel maka anda dapat memilih tabel-tabel tersebut sekaligus dan klik Add.
  6. Jika ada lebih dari satu tebel maka pada langkah 5 diatas dapat kita pilih beberapa tabel sekaligus.
  7. Klik Finish.
Gambar 13. Wizard untuk membuat Hibernate Reverse Engineering.

Wizard Hibernate Reverse Engineering akan membuatkan file hibernate.reveng.xml yaitu sebuah file reverse engineering dan membukanya di editor. Anda dapat menutup file hibernate.reveng.xml tersebut karena kita tidak perlu untuk meng-edit-nya.

Pastikan bahwa lokasi file hibernate.reveng.xml berada satu lokasi dengan file hibernate.cfg.xml seperti terlihat pada gambar 14 dibawah.

Gambar 14. Lokasi file hibernate.cfg.xml dan hibernate.reveng.xml.


Membuat Hibernate Mapping Files dan POJOs

Kita dapat menggunakan file-file mapping hibernate dan POJOs dari wizard Database untuk membentuk file buat kita. Wizard dapat membangkitkan sebuah POJO dan menghubungkan ke sebuah file mapping untuk setiap tabel yang kita pilih didalam wizard. File mapping adalah sebuah file XML yang berisi data mengenai bagaimana kolom-kolom sebuah tabel yang dipetakan ke field-field dalam POJOs. Kita akan memerlukan file hibernate.reveng.xml dan hibernate.cfg.xml untuk menggunakan wizard.

Untuk membuat POJOs dan mapping files menggunakan wizard, lakukan langkah-langkah berikut :

  1. Klik kanan pada node paket [paketProyek].entity dan pilih New > Other untuk membuka jendela wizard New File.
  2. Pilih Hibernate Mapping Files and POJOs from Database didalam kategori Hibernate. Klik Next.
  3. Pastikan bahwa file hibernate.reveng.xml dan hibernate.cfg.xml terpilih pada drop down list.
  4. Pilih JDK 5 Language Features dibawah opsi General Settings.
  5. Pastikan Domain Code dan Hibernate XML Mappings terpilih.
  6. Pilih org.aryo.sekolahhibernateprimefacescrud.entity untuk nama paket. Klik Finish.
  7. Tampilan wizard seperti pada gambar 15.

Gambar 15. Hibernate Mapping File and POJOs from Database.

Ketika kita mengklik Finish maka IDE akan membangkitkan POJOs dan Hibernate mapping file dan dengan field-field dipetakan ke kolom-kolom yang dispesifikasi dalam hibernate.reveng.xml. IDE juga menambahkan isian pemetaan ke file hibernate.cfg.xml.

Gambar 16. Tambahan isian ke hibernate.cfg.xml

Kita dapat melihat tambahan file yang dibuat oleh IDE yaitu Siswa.java pada paket [paketProyek].entity dan Siswa.hbm.xml pada folder src/main/resources seperti terlihat pada gambar 17.

Gambar 17. File tambahan Siswa.java dan Siswa.hbm.xml.

Lengkapi kode program yang bertulis tebal pada file Siswa.java sehingga kode program secara lengkapnya adalah seperti berikut :

package org.aryo.sekolahhibernateprimefacescrud.entity;
// Generated Dec 16, 2014 6:36:18 PM by Hibernate Tools 4.3.1

import java.util.Objects;


/**

 * Siswa generated by hbm2java
 */
public class Siswa implements java.io.Serializable {

    private Integer id;
    private String nama;
    private String sekolah;
    private String telp;
    private String email;

    public Siswa() {
    }

    public Siswa(String nama, String sekolah, String telp, String email) {
        this.nama = nama;
        this.sekolah = sekolah;
        this.telp = telp;
        this.email = email;
    }

    public Integer getId() {
        return this.id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getNama() {
        return this.nama;
    }

    public void setNama(String nama) {
        this.nama = nama;
    }

    public String getSekolah() {
        return this.sekolah;
    }

    public void setSekolah(String sekolah) {
        this.sekolah = sekolah;
    }

    public String getTelp() {
        return this.telp;
    }

    public void setTelp(String telp) {
        this.telp = telp;
    }

    public String getEmail() {
        return this.email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    /**
     * tambahan oleh aryo. Sesuai class Siswa
     */
    @Override
    public int hashCode() {
        int hash = 3;
        hash = 23 * hash + this.id;
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Siswa other = (Siswa) obj;
        if (!Objects.equals(this.id, other.id)) {
            return false;
        }
        return true;
    }

}

Lengkapi import class dan atau library yang diperlukan (Atl+Enter).

8. Membuat File Data Access Object (DAO)

Pada tahap ini kita akan membuat file-file DAO yang digunakan untuk melakukan query-query Hibernate ke database. Kita akan menggunakan sintaks-sintaks Hibernate Query Language (HQL) yang mirip dengan sintaks SQL. Kita juga akan menggunakan HQL editor untuk menguji terlebih dahulu apakah sintaks query HQL telah sesuai keinginan sebelum ditulis pada file program DAO.

Method-methode file-file program DAO ini nantinya juga digunakan oleh program-program JSF Managed Bean yang menangani layer view (User Interface).


Membuat Class DAO

Pada bagian ini kita akan membuat class DAO menggunakan wizard New File untuk membuat class SiswaDAO.java didalam paket [paketProyek].dao. Karena class dao ini yang digunakan mengakses langsung ke database maka harus dibuat sebuah Hibernate session dengan memanggil getSessionFactory dalam file HibernateUtil.java yang telah kita buat tadi.

Di class dao ini juga akan ditambahkan method-method lainnya untuk melakukan query dan mengambil data dari database. Method-method query dan retrieve data ini juga akan dipanggil/digunakan oleh class-class di JSF Managed Bean.

Untuk membuat lebih baku (standard) terhadap class-class DAO yang akan dibuat, ada baiknya kita buat terlebih dahulu sebuah class interface yang berisi tandatangan method-method pengakses database dimana nantinya class-class DAO akan mengimplementasi dari class interface ini.

Berikut ini langkah-langkah membuat class interface IDataAccess.java :

  1. Klik kanan pada paket [paketProyek].dao dibawah node Source Packages dan pilih New > Other untuk membuka wizard New File. Pilih Java pada kategori dan Java Interface pada File Types. Klik Next.
  2. Isi IDataAccess pada class name. Dan pastikan package adalah [paketProyek].dao.
  3. Klik Finish.
Ketik/edit kode program dan lengkapi IDataAccess.java seperti berikut:

package org.aryo.sekolahhibernateprimefacescrud.dao;

import java.io.Serializable;
import java.util.List;

/**
 *
 * @author Aryo
 */
public interface IDataAccess extends Serializable {
    public void insert(T obj);
    
    public void update(T obj);
    
    public void delete(int id);
    
    public List getAll();
    
    public T getById(int id);
    
    public T getById(String id);
    
    public List getByProperty(String name, Object value);
    
    public List search(String name, Object value);
}

Lengkapi import library yang diperlukan (Alt+Enter).

Berikut ini adalah langkah-langkah membuat class SiswaDAO.java.
  1. Klik kanan pada paket [paketProyek].dao dibawah node Source Packages dan pilih New > Other untuk membuka wizard New File. Pilih Java pada kategori dan Java Class pada File Types. Klik Next.
  2. Isi SiswaDAO untuk nama class. Dan pastikan package adalah [paketProyek].dao.
  3. Klik Finish
Ketik/edit kode program dan lengkapi SiswaDAO.java seperti berikut:

----------------------------------------------------------------------------------------------------------------------
package org.aryo.sekolahhibernateprimefacescrud.dao;

import java.util.List;
import org.aryo.sekolahhibernateprimefacescrud.entity.Siswa;
import org.aryo.sekolahhibernateprimefacescrud.util.HibernateUtil;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

/**
 *
 * @author Aryo
 */
public class SiswaDAO implements IDataAccess {

    Session session = null;

    public SiswaDAO() {
        this.session = HibernateUtil.getSessionFactory().getCurrentSession();
    }

    @Override
    public void insert(Siswa obj) {
        Transaction tx = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            tx = session.beginTransaction();
            session.save(obj);
            session.getTransaction().commit();
        } catch (RuntimeException e) {
            if (tx != null) {
                tx.rollback();
            }
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
    }

    @Override
    public void update(Siswa obj) {
        Transaction tx = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            tx = session.beginTransaction();
            session.update(obj);
            session.getTransaction().commit();
        } catch (RuntimeException e) {
            if (tx != null) {
                tx.rollback();
            }
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
    }

    @Override
    public void delete(int siswaId) {
        Transaction tx = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            tx = session.beginTransaction();
            Siswa siswa = (Siswa) session.load(Siswa.class, new Integer(siswaId));
            session.delete(siswa);
            session.getTransaction().commit();
        } catch (RuntimeException e) {
            if (tx != null) {
                tx.rollback();
            }
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
    }

    @Override
    public List getAll() {
        Transaction tx = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            tx = session.beginTransaction();
            Query query = session.createQuery("from Siswa");
            List siswaList = (List) query.list();
            if (siswaList != null && siswaList.size() > 0) {
                return siswaList;
            }
        } catch (RuntimeException e) {
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
        return null;
    }

    @Override
    public Siswa getById(String id) {
        List siswaList = getByProperty("id", id);
        return siswaList.get(0);
    }

    @Override
    public List getByProperty(String field, Object value) {
        Transaction tx = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            tx = session.beginTransaction();
            Query query = session.createQuery("from Siswa where " + field + " =:value");
            query.setParameter("value", value);
            List siswaList = (List) query.list();
            if (siswaList != null && siswaList.size() > 0) {
                return siswaList;
            }
        } catch (RuntimeException e) {
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
        return null;
    }

    @Override
    public Siswa getById(int id) {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public List search(String field, Object value) {
        Transaction tx = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            tx = session.beginTransaction();
            Query query = session.createQuery("from Siswa where " + field + " like '%" + value + "%'");
            List siswaList = query.list();
            if (siswaList != null && siswaList.size() > 0) {
                return siswaList;
            }
        } catch (RuntimeException e) {
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
        return null;
    }
}
------------------------------------------------------------------------------------------------------------------------

Lengkapi import class dan atau library yang diperlukan (Alt+Enter).

Tips:

Perhatikan sintaks berikut pada class dao diatas,
Query query = session.createQuery("from Siswa where " + field + " =:value");
query.setParameter("value", value);

Memasukkan value menggunakan method query.setParamaeter("value", value) akan menghindarkan aplikasi kita dari SQL Injection.
HINDARI hanya penggunaan sintaks sebagai berikut,
Query query = session.createQuery("from Siswa where " + field + " =:" + nilai);


Menguji Sintaks Hbernate Query Language (HQL) Menggunakan HQL Editor

Di program dao tersebut terdapat sintaks HQL. Untuk mengujinya kita dapat menggunakan HQL query editor. Langkah-langkahnya adalah sebagai berikut :

  1. Klik kanan pada file hibernate.cfg.xml di window Project dan pilih Run HQL Query untuk membuka HQL query editor.
  2. Pilih hibernate.cfg dari drop down list pada toolbar.
  3. Test koneksi dan hasil query dengan menulis sintak HQL "from siswa" dalam editor dan klik tombol Run HQL Query (disebelah kanan drop dwon list)
  4. Hasil query dapat terlihat pada gambar 18. Kita dapat mencoba sintaks query yang lain.

Gambar 18. Menguji sintaks HQL menggunakan HQL query editor..

Sampai tahap ini semua class dasar sudah selesai, berikutnya adalah tahap membuat class controller dan view menggunakan framework JSF+Primefaces.


9. Membuat JSF Managed Bean Sebagai Implementasi dari Layer Controller

Method-method didalam managed bean digunakan untuk menampilkan data dalam halaman-halaman (web) JSF dan juga untuk menangkap data yang dimasukkan pada halaman (web) JSF. Managed bean berperan sebagai aplikasi server side pada arsitektur web application.

Method-method JSF managed bean juga akan mengakses method-method di class dao untuk mengambil rekord-rekord data dari database. Spesifikasi JSF 2.0 membolehkan menggunakan anotasi-anotasi dalam sebuah class bean untuk menandakan bahwa sebuah class sebagai sebuah JSF managed bean, menentukan scope nya dan menentukan nama bean yang akan dikenal oleh halaman web JSF. File-file managed bean yang kita buat akan dimasukkan ke paket [paketProyek]

Untuk membuat managed bean, langkukan langkah-langkah berikut :

  1. Klik kanan pada node source packages dan pilih New > Other.
  2. Pilih JSF Managed Bean dari kategori JavaServer Faces. Klik Next.
  3. Ketik SiswaController untuk nama Class. Berarti kita akan menggunakan siswaController sebagai value untuk inputText, commandButton pada halaman JSF *.xhtml ketika memanggil method-method didalam bean.
  4. Pilih [paketProyek].controller untuk lokasi paket nya.
  5. Ketik siswaController untuk Name yang akan digunakan untuk managed bean.
  6. Set Scope ke session. Klik Finish.
  7. Tampilan seperti pada gambar 19.

Gambar 19. Membuat managed bean SiswaController.java.

Ketika kita mengklik Finish, IDE akan membuatkan class bean dan membukanya dalam editor. IDE menambahkan anotasi @ManagedBean dan @SessionScoped.

Edit dan lengkapi class SiswaController.java seperti pada kode berikut,

---------------------------------------------------------------------------------------------------------------------
package org.aryo.sekolahhibernateprimefacescrud.controller;

import javax.inject.Named;
import javax.enterprise.context.SessionScoped;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import org.aryo.sekolahhibernateprimefacescrud.dao.SiswaDAO;
import org.aryo.sekolahhibernateprimefacescrud.entity.Siswa;

/**
 *
 * @author Aryo
 */
@Named(value = "siswaController")
@SessionScoped
public class SiswaController implements Serializable {
    
    Siswa siswa;
    List siswaList;
    private String searchBy;
    private String searchValue;
    private SiswaDAO dataAccess;

    /**
     * Creates a new instance of SiswaController
     */
    public SiswaController() {
        siswaList = new ArrayList<>();
        siswa = new Siswa();
        dataAccess = new SiswaDAO();
        siswaList = dataAccess.getAll();
    }
    
    public String displayAll() {
        siswaList = dataAccess.getAll();
        return "siswa.xhtml";
    }
    
    public String searchSiswa() {
        siswaList = dataAccess.search(this.searchBy, this.searchValue);
        return "siswa.xhtml";
    }
    
    public String addSiswa() {
        dataAccess.insert(siswa);
        //FacesMessage message = new FacesMessage("Data berhasil ditambahkan");
        //message.setSeverity((FacesMessage.SEVERITY_INFO));
        FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_INFO, "Data berhasil ditambahkan", null);
        FacesContext.getCurrentInstance().addMessage(null, message);
        siswaList = dataAccess.getAll();
        return "siswa.xhtml";
    }
    
    public String updateSiswa() {
        dataAccess.update(siswa);
        FacesMessage message = new FacesMessage("Data berhasil diubah");
        message.setSeverity((FacesMessage.SEVERITY_INFO));
        FacesContext.getCurrentInstance().addMessage(null, message);
        siswaList = dataAccess.getAll();
        return "siswa.xhtml";
    }
    
    public String deleteSiswa() {
        dataAccess.delete(siswa.getId());
        FacesMessage message = new FacesMessage("Data berhasil dihapus");
        message.setSeverity((FacesMessage.SEVERITY_INFO));
        FacesContext.getCurrentInstance().addMessage(null, message);
        siswaList = dataAccess.getAll();
        return "siswa.xhtml";
    }
    
    public Siswa getSiswa() {
        return siswa;
    }
    
    public void setSiswa(Siswa siswa) {
        this.siswa = siswa;
    }
    
    public List getSiswaList() {
        return siswaList;
    }
    
    public void setSiswaList(List siswaList) {
        this.siswaList = siswaList;
    }
    
    public SiswaDAO getDataAccess() {
        return dataAccess;
    }
    
    public void setDataAccess(SiswaDAO dataAccess) {
        this.dataAccess = dataAccess;
    }
    
    public String getSearchBy() {
        return searchBy;
    }
    
    public void setSearchBy(String searchBy) {
        this.searchBy = searchBy;
    }
    
    public String getSearchValue() {
        return searchValue;
    }
    
    public void setSearchValue(String searchValue) {
        this.searchValue = searchValue;
    }
    
    // method untuk handling navigasi ke halaman index.xhtml
    public String moveToHome() {
        return "index.xhtml";
    }   
}
-----------------------------------------------------------------------------------------------------------------

Lengkapi import class dan atau library yang diperlukan (alt+Enter).


10. Membuat Halaman Web sebagai Implementasi Layer View

Saat awal membuat proyek web application kita ini sudah ada halaman web bernama index.xhtml, biarkan saja halaman index.xhtml nanti kita akan memodifikasinya.

Sebelum itu kita buat dahulu file template.xhtml yang akan dijadikan template oleh file halaman-halaman web .xhtml lain. Lakukan langkah-langkah sebagai berikut,

  1. Klik kanan pada node proyek SekolahHibernatePrimefacesCRUD di jendela Projects dan pilih New > Other
  2. Pilih kategori JavaServer Faces dan pilih File types Facelets Template. Klik Next.
  3. Ketik template sebagai File Name, dan pilih Layout Style adalah CSS dan layout halaman seperti pada gambar 20. Klik Finish

Gambar 20. Membuat template.xhtml

Tutup saja template.xhtml yang terbuka pada editor karena kita tidak perlu mengeditnya.

Sekarang kita akan membuat halaman web siswa.xhtml yang akan menampilkan data-data siswa sebagai user interface ke pengguna. Untuk membuat halaman web siswa.xhtml lakukan langkah-langkah sebagai berikut,

  1. Klik kanan pada node proyek SekolahHibernatePrimefacesCRUD di jendela Projects dan pilih New > Other.
  2. Pilih kategori JavaServer Faces dan pilih File types Facelets Template Client. Klik Next.
  3. Ketik siswa sebagai File Name dan isi Template dengan fiel template.xhtml yang telah dibuat. Pastikan terpih pada bagian Generated Root Tag. Klik Finish.
  4. Tampilan membuat halaman web siswa.xhtml adalah seperti pada gambar 21.
Gambar 21. Membuat halaman web siswa.xhtml untuk layer view.

Ketika tombol Finish diklik maka file siswa.xhtml akan terbuka di editor, edit dan lengkapi seperti pada kode dibawah ini.


---------------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------------
     
Lengkapi dan perbaiki import yang diperlukan.

Kemudian dengan cara yang sama saat membuat SiswaController.java maka buat class managed bean untuk IndexController.java. Lengkapi kode IndexController.java seperti berikut. Masukkan ke paket controller.

-----------------------------------------------------------------------------------------------------------------------
package org.aryo.sekolahhibernateprimefacescrud.controller;

import javax.inject.Named;
import javax.enterprise.context.SessionScoped;
import java.io.Serializable;

/**
 *
 * @author Aryo
 */
@Named(value = "indexController")
@SessionScoped
public class IndexController implements Serializable {

    /**
     * Creates a new instance of IndexController
     */
    public IndexController() {
    }
    
    // method untuk navigasi ke halaman web siswa.xhtml
    public String moveToPageSiswa() {
        return "siswa.xhtml";
    }

}
----------------------------------------------------------------------------------------------------------------------

Berikutnya edit dan lengkapi index.xhtml seperti pada kode berikut,

---------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------

Didalam method controller yang kita buat (SiswaController.java dan IndexController.java) terdapat method yang menangani navigasi ke halaman .xhtml yang dituju. JSF 2.0 membolehkan kita untuk navigasi ke halaman .xhtml yang ditulis didalam class managed bean, sehingga tidak perlu untuk menambahkan pada file faces-config.xml.


11. Running Proyek SekolahHibernatePrimefacesCRUD

Secara keseluruhan proyek kita telah selesai. Secara lengkap struktur aplikasi kita adalah seperti gambar 22, sebagai berikut,


Gambar 22. Struktur akhir aplikasi.

Kita dapat mencoba untuk mendeploy ke web server glassfish sesuai pilihan dan dilanjutkan untuk menjalankannya yang akan muncul pada browser kita.

  1. Klik kanan pada node proyek SekolahHibernatePrimefacesCRUD. Pilih 'clean and build'. Jika tidak terdapat permasalahan lanjutkan.
  2. Klik kanan pada node proyek. Pilih 'run' untuk men-deploy aplikasi web kita ke web server sekaligus menjalankannya.
Tampilan hasil dari proyek SekolahHibernatePrimefacesCRUD adalah seperti pada gambar 23, 24, 25, dan 26.

Gambar 23. Halaman index.xhtml atau home

Gambar 24. Halaman siswa.xhtml

Gambar 25. Form Add Siswa Info.

Gambar 26. Form Update/Delete Siswa Info.


Demikian artikel singkat membuat aplikasi web JEE CRUD menggunakan framework Hibernate, JSF+Primefaces.
Semoga bermanfaat.
Belajar java..... mudah... keren..!!! :)


Daftar Pustaka:

  • Fadlika Dita Nurjanto, Membangun CRUD di Platform J2EE, IlmuKomputer.com.
  • http://javaknowledge.info/simple-crud-ujing-jsf2hibernate-integration-and-mysql, Javaknowledge.info, diakses tanggal 19-Nop-2014.
  • https://netbeans.org/kb/docs/web/hibernate-webapp.html, Netbeans.org, diakses tanggal 19-Nop-2014.
  • https://netbeans.org/kb/docs/web/hibernate-webapp.html, Netbeans.org, diakses tanggal 19-Nop-2014.
  • https://netbeans.org/kb/docs/web/jsf20-support.html, Netbeans.org, diakses tanggal 19-Nop-2014.
  • http://www.primefaces.org/, diakses tanggal 19-Nop-2014.