Praktikum Rekayasa Software Berbasis Komponen

LAPORAN PRAKTIKUM REKAYASA SOFTWARE BERBASIS KOMPONEN

DISUSUN OLEH: NAMA

: OLIVIA WARDHANI

NIM

: 21120113120032

KELOMPOK

:5

PROGRAM STUDI SISTEM KOMPUTER FAKULTAS TEKNIK UNIVERSITAS DIPONEGORO SEMARANG 2016

i

Lembar Pengesahan

ii ii

Lembar Pengesahan

ii ii

KATA PENGANTAR

Puji syukur ke hadirat Tuhan Yang Maha Esa kar ena atas berkah, rahmat, dan hidayah-Nya sehingga Laporan Praktikum RSBK 2016 ini dapat diselesaikan dan disusun dengan baik. Laporan

ini

berisi

mengenai

pembelajaran

mengenai

bagaimana

mengaplikasikan komponen dalam pembuatan software. Diharapkan laporan ini dapat membantu kita dalam mempelajari dan memahami segala sesuatu yang berkaitan dengan penggunaan penggunaan komponen pada pembuatan pembuatan software. Sehingga kita dapat mengimplementasikan ilmu yang kita peroleh di kemudian hari. Ucapan terima kasih diberikan kepada : 1. Allah SWT, yang telah melimpahkan rahmat-Nya, 2. Kedua orang tua, yang selalu mendukung dan mendoakan saya, 3. Ibu Ike Pertiwi W, ST, MT, selaku dosen pengampu mata kuliah RSBK, 4. Seluruh asisten praktikum, yang telah membimbing saya dalam praktikum, 5. Teman – Teman – teman teman Sistem Komputer 2013 Semoga laporan ini dapat bermanfaat bagi yang membacanya. Kritik dan saran sangat diterima demi lebih baiknya laporan ini.

Semarang, 22 Oktober 2016 Penyusun,

Olivia Wardhani 21120113120032

iii

DAFTAR ISI

Halaman Cover................................................................................................. i Halaman Pengesahan ....................................................................................... ii Kata Pengantar ................................................................................................. iii Daftar Isi........................................................................................................... iv Daftar Gambar .................................................................................................. vi Abstrak ............................................................................................................. x BAB I Pendahuluan 1.1 Latar Belakang ...................................................................................... 1 1.2 Tujuan .................................................................................................... 1 1.3 Sistematika Penulisan ............................................................................ 1 BAB II Java Beans 2.1 Tujuan .................................................................................................... 3 2.2 Dasar Teori ............................................................................................ 4 2.3 Langkah Percobaan Dan Pembahasan ................................................... 6 2.4 Tugas ..................................................................................................... 13 2.5 Kesimpulan ............................................................................................ 17 BAB III EJB Session Beans 3.1 Tujuan .................................................................................................... 18 3.2 Dasar Teori ............................................................................................ 19 3.3 Langkah Percobaan Dan Pembahasan ................................................... 20 3.4 Tugas ..................................................................................................... 27 3.5 Kesimpulan ............................................................................................ 30 BAB IV Aplikasi CRUD Menggunakan JPA,EJB, Dan MySql 4.1 Tujuan .................................................................................................... 31 4.2 Dasar Teori ............................................................................................ 32 4.3 Langkah Percobaan Dan Pembahasan ................................................... 34 4.4 Tugas ..................................................................................................... 52 4.5 Kesimpulan ............................................................................................ 54 BAB V Java Server Faces 5.1 Tujuan .................................................................................................... 55

iv

5.2 Dasar Teori ............................................................................................ 56 5.3 Langkah Percobaan ............................................................................... 58 5.4 Pembahasan ........................................................................................... 71 5.5 Kesimpulan ............................................................................................ 73 BAB VI Penutup 6.1 Kesimpulan ............................................................................................ 74 6.2 Saran ...................................................................................................... 74 Daftar Pustaka .................................................................................................. xi LAMPIRAN I (Lembar Asistensi)

v

DAFTAR GAMBAR

Gambar 2.1 Membuat File Project Baru ......................................................... 6 Gambar 2.2 Memberi Nama Project ............................................................... 6 Gambar 2.3 Membuat Jframe from baru ........................................................ 6 Gambar 2.4 Memberi nama Jframe baru ........................................................ 7 Gambar 2.5 Pallete pada Jframe from ............................................................ 7 Gambar 2.6 Tampilan tahap Pertama program............................................... 7 Gambar 2.7 Setting Connection Mode ........................................................... 8 Gambar 2.8 Setting action performed............................................................. 8 Gambar 2.9 Mengubah set property ............................................................... 8 Gambar 2.10 Mengisi Value ........................................................................... 9 Gambar 2.11 Source Code Value ................................................................... 9 Gambar 2.12 Membuat komponen AWT baru ............................................... 9 Gambar 2.13 Menambah file jar ..................................................................... 10 Gambar 2.14 Memilih file jar ......................................................................... 10 Gambar 2.15 Memilih komponen yang akan ditambahkan............................ 10 Gambar 2.16 Memilih katagori komponen .................................................... 11 Gambar 2.17 Menambahkan bumper sticker ke form .................................... 11 Gambar 2.18 Menambahkan button baru ....................................................... 11 Gambar 2.19 Menambahkan method go() ...................................................... 12 Gambar 2.20 Hasil Program ........................................................................... 12 Gambar 2.21 Membuat project facebean ........................................................ 13 Gambar 2.22 Source Code facebean .............................................................. 14 Gambar 2.23 Build project ............................................................................. 14 Gambar 2.24 Output build project .................................................................. 15 Gambar 2.25 Tampilan form .......................................................................... 15 Gambar 2.26 Method call untuk button 1 ....................................................... 15 Gambar 2.27 Method call untuk button 2 ....................................................... 16 Gambar 2.28 Hasil project ketika kondisi senang .......................................... 16 Gambar 2.29 Hasil project ketika kondisi sedih ............................................. 16 Gambar 3.1 Memberi Nama Project ............................................................... 20

vi

Gambar 3.2 Menentukan Server .................................................................... 20 Gambar 3.3 Membuat Session Bean .............................................................. 20 Gambar 3.4 Memberi nama session bean ....................................................... 21 Gambar 3.5 Membuat method baru ................................................................ 21 Gambar 3.6 Membuat nama method .............................................................. 21 Gambar 3.7 Membuat servlet baru ................................................................. 22 Gambar 3.8 Memberi nama class dan package .............................................. 22 Gambar 3.9 Memilih add information to deployment descriptor ................... 23 Gambar 3.10 Call enterprise bean .................................................................. 23 Gambar 3.11 Memilih session bean ............................................................... 23 Gambar 3.12 Clean and build ......................................................................... 25 Gambar 3.13 Melakukan deploy .................................................................... 25 Gambar 3.14 Mengatur properties servlet ...................................................... 26 Gambar 3.15 Hasil running program .............................................................. 26 Gambar 3.16 Uji program fahrenheit ke celcius............................................. 26 Gambar 3.17 Tampilan tombol back .............................................................. 27 Gambar 3.18 Nilai awal .................................................................................. 27 Gambar 3.19 Hasil Konversi Celcius ke Kelvin............................................. 28 Gambar 3.20 Hasil Konversi Kelvin ke Celcius............................................. 28 Gambar 3.21 Hasil Konversi Reamur ke Kelvin ............................................ 28 Gambar 3.22 Hasil Konversi Kelvin ke Reamur ............................................ 28 Gambar 3.23 Hasil Konversi Fahrenheit ke Kelvin ....................................... 28 Gambar 3.24 Hasil Konversi Kelvin ke Fahrenheit ....................................... 28 Gambar 4.1 Membuat database baru .............................................................. 34 Gambar 4.2 Membuat tabel login ................................................................... 34 Gambar 4.3 Membuat tabel login ................................................................... 34 Gambar 4.4 Tabel Login ................................................................................. 34 Gambar 4.5 Membuat tabel student................................................................ 35 Gambar 4.6 Membuat user ............................................................................. 35 Gambar 4.7 Mengatur privilage untuk user .................................................... 35 Gambar 4.8 Memberi nama projek baru ......................................................... 36 Gambar 4.9 Memilih glassfish server ............................................................. 36

vii

Gambar 4.10 Membuat connection pool ........................................................ 36 Gambar 4.11 Memberi nama connection pool ............................................... 37 Gambar 4.12 Mengatur connecction pool ...................................................... 37 Gambar 4.13 Membuat JDBC resource .......................................................... 37 Gambar 4.14 Mengisikan JNDI name ............................................................ 38 Gambar 4.15 Membuat persistence unit ......................................................... 38 Gambar 4.16 Membuat jsp page ..................................................................... 38 Gambar 4.17 JSP page yang sudah dibuat ...................................................... 39 Gambar 4.18 Membuat package baru ............................................................. 41 Gambar 4.19 Package yant telah dibuat ......................................................... 41 Gambar 4.20 Membuat entity class ................................................................ 42 Gambar 4.21 Entity class yang sudah dibuat .................................................. 42 Gambar 4.22 Membuat session bean .............................................................. 44 Gambar 4.23 Membuat session bean .............................................................. 44 Gambar 4.24 Membuat servlet ....................................................................... 48 Gambar 4.25 Mengisi welcome files pada configuration files ....................... 50 Gambar 4.26 Mengisi username dan password .............................................. 50 Gambar 4.27 Tampilan program setelah login ............................................... 51 Gambar 4.28 Tampilan kolom address ........................................................... 52 Gambar 4.29 Tampilan akan membuat studentservlet tanpa login ................ 53 Gambar 4.30 Halaman data mahasiswa yang ada logout ............................... 53 Gambar 4.31 Tampilan setelah logout............................................................ 53 Gambar 5.1 Glassfish Server .......................................................................... 56 Gambar 5.2 Membuat database baru .............................................................. 58 Gambar 5.3 Membuat akun user yang baru.................................................... 59 Gambar 5.4 Mengisi data akun user yang baru .............................................. 59 Gambar 5.5 Memberi hak akses user.............................................................. 59 Gambar 5.6 New Connection ......................................................................... 60 Gambar 5.7 Memilih Driver Connection........................................................ 60 Gambar 5.8 Mengubah userbame,password ................................................... 60 Gambar 5.9 Membuat project baru ................................................................. 61

viii

Gambar 5.10 Mengisi nama project baru ...................................................... 61 Gambar 5.11 Mengatur server glassfish ......................................................... 61 Gambar 5.12 Mencari glassfish ...................................................................... 62 Gambar 5.13 Membuat JDBC connection pool.............................................. 62 Gambar 5.14 Memberi nama connection pool ............................................... 62 Gambar 5.15 Membuat JDBC Resource ........................................................ 63 Gambar 5.16 Memberi nama JNDI ................................................................ 63 Gambar 5.17 Membuat package entity ........................................................... 63 Gambar 5.18 Membuatt Package model......................................................... 64 Gambar 5.19 Memberi nama package dengan controller ............................... 64 Gambar 5.20 Memili entity classes from database ......................................... 64 Gambar 5.21 Memilih data source ................................................................. 65 Gambar 5.22 Memilih database type .............................................................. 65 Gambar 5.23 Membuat session bean .............................................................. 65 Gambar 5.24 Menamba entity class ............................................................... 66 Gambar 5.25 Memilih framework .................................................................. 66 Gambar 5.26 Menghapus index.html ............................................................. 66 Gambar 5.27 Memilih JSF manage bean ....................................................... 67 Gambar 5.28 Memberi nama javaserver faces ............................................... 67 Gambar 5.29 Membuat JSF page ................................................................... 68 Gambar 5.30 Memberi nama JSF page .......................................................... 68 Gambar 5.31 Insert code ................................................................................. 68 Gambar 5.32 Insert code pada add xhtml ....................................................... 69 Gambar 5.33 Memilih productController.p .................................................... 69 Gambar 5.34 Memilih Bean property ............................................................. 69 Gambar 5.35 Tampilan program .................................................................... 71 Gambar 5.36 Tambah barang ......................................................................... 71 Gambar 5.37 Tambah barang ......................................................................... 72

ix

ABSTRAK

Di masa yang sudah tidak terpisahkan dengan teknologi seperti sekarang ini, manusia semakin tidak bisa lepas dari komputer. Komputer pun sekarang sudah beralih menjadi semakin kecil, hingga munculah mobile device atau smartphone yang lebih mudah dibawa-bawa dan memiliki fungsi yang hampir sama dengan sebuah komputer. Bidang rekayasa perangkat perangkat lunak-pun semakin berkembang mengikuti perkembangan teknologi komputer. Oleh karena itu muncullah banyak jenis aplikasi untuk pengembangan perangkat lunak berbasis komponen pada kehidupan sehari-hari, seperti pembuatan aplikasi seder hana, yaitu pengubah suhu dengan lingkungan pengembang Netbeans. Pada Laporan Praktikum Rekayasa Software Berbasis Komponen ini berisi pengetahuan mengenai materi pendalaman dari aplikasi pengubah suhu berbasis desktop dan web. Dimulai dari memanfaatan komponen dengan Java Persistence API dan Java Server Faces.

Kata kunci : Komputer, rekayasa perangkat lunak, Netbeans

x

BAB I PENDAHULUAN

1.1. LATAR BELAKANG

Praktikum Rekayasa Software Berbasis Komponen adalah praktikum yang dilaksanakan pada semester 7 oleh mahasiswa di Fakultas Teknik Jurusan Sistem Komputer Universitas Diponegoro. Praktikum ini merupakan praktikum implementasi dari mata kuliah RSBK. Praktikum ini dilaksanakan agar mahasiswa dapat mengetahui tentang Rekayasa Software Berbasis Komponen dengan baik dan jelas.

1.2. TUJUAN PRAKTIKUM

1. Agar mahasiswa mengetahui konsep RSBK dengan baik. 2. Menambah wawasan mahasiswa mengenai sistem RSBK. 3. Mengetahui berbagai macam pengaplikasian komponen pada pemrograman dan pengimplementasiannya. 4. Melatih mahasiswa untuk memahami pembuatan software berbasis komponen di program studi Teknik Sistem Komputer.

1.3. SISTEMATIKA PENULISAN

Laporan ini dibuat dengan sistematika sebagai berikut : Halaman Cover Halaman Pengesahan Kata Pengantar Daftar Isi Daftar Gambar Abstrak BAB I Pendahuluan 1.1 Latar Belakang 1.2 Tujuan 1.3 Sistematika Penulisan BAB II Java Beans

1

2

2.1 Tujuan 2.2 Dasar Teori 2.3 Langkah Percobaan Dan Pembahasan 2.4 Tugas 2.5 Kesinpulan BAB III EJB Session Beans 3.1 Tujuan 3.2 Dasar Teori 3.3 Langkah Percobaan Dan Pembahasan 3.4 Tugas 3.5 Kesinpulan BAB IV Aplikasi CRUD Menggunakan JPA,EJB, Dan MySql 4.1 Tujuan 4.2 Dasar Teori 4.3 Langkah Percobaan Dan Pembahasan 4.4 Tugas 4.5 Kesinpulan BAB V Java Server Faces 5.1 Tujuan 5.2 Dasar Teori 5.3 Langkah Percobaan 5.4 Pembahasan 5.5 Kesinpulan BAB VI Penutup 6.1 Kesimpulan 6.2 Saran Daftar Pustaka LAMPIRAN I (Lembar Asistensi)

BAB II JAVABEAN 2.1

TUJUAN

1. Praktikan mengetahui mengenai Java Bean 2. Praktikan mengetahui fungsi Java Bean 3. Praktikan mengetahui properti pada Java Bean 4. Praktikan mengetahui fungsi connection mode 5. Praktikan dapat membuat contoh aplikasi yang menggunakan Java Bean.

3

4

2.2

DASAR TEORI 2.2.1 Java Bean

Java bean adalah komponen dalam java yang bersifat reusable. Java bean digunakan untuk mengelola antara aplikasi client dan komponen yang berjalan pada J2EE server atau antara komponen server dan database. Pada konsep MVC, java bean ini dikenal dengan Model. Pada dasarnya java bean dapat dibuat dengan cara yang sama dengan pembuatan class java standar, tetapi class java bean memiliki beberapa ketentuan khusus. Ciri-ciri class Java Bean: 1. Class harus memilki constructor tanpa parameter. 2. Terdapat method setter dan getter untuk mengakses setiap propertiesnya. 3. Modifier yang digunakan adalah private. (Sumber : http://rizkyfitriarf.blogspot.co.id/2015/06/java-bean.html)

2.2.2 Swing/AWT

Abstract Windowing Toolkit (AWT), atau disebut juga “Another Windowing Toolkit”, adalah pustaka windowing bertujuan umum dan multiplatform serta menyediakan sejumlah kelas untuk membuat GUI di Java. Dengan AWT, dapat membuat window, menggambar, manipulasi gambar, dan komponen seperti Button, Scrollbar, Checkbox, TextField, dan menu pull-down. Semua komponen GUI non-menu memiliki kelas yang diturunkan dari kelas java.awt.Component. Sedangakan komponen menu diturunkan dari java.awt.ComponentMenu. adapun Kelebihan AWT adalah Didukung oleh browser kuno maupun baru, karena paket ini telah diimplementasikan sejak lama. Sedangkan kekurangan AWT yaitu: 1. Bersifat heavyweight. 2. Bersifat Opaque (tidak transparan) Swing merupakan perbaikan kelemahan di AWT. Banyak kelas swing menyediakan komponen alternatif terhadap AWT. Contohnya kelas JButton swing menyediakan fungsionalitas lebih banyak dibanding kelas Button.

5

Selain itu komponen swing umumnya diawali dengan huru f “J”, misalnya JButton, JTextField, JFrame, JLabel, JTextArea, JPanel, dan sebagainya. Teknologi swing menggunakan dan memperluas gagasan-gagasan AWT. Sementara, penggunaan komponen Swing ditandai dengan adanya instruksi : import javax.swing. Komponen-komponen Swing dapat diklasifikasikan ke dalam 3 bagian yaitu: 1) Top-levelcontainer berfungsi untuk menyediakan ruang bagi komponenkomponen lainnya. Container jenis ini terdiri atas JFrame, JWindow, Jdialog, dan Japplet. 2) Intermediatecontainer komponen (nontop-level) yang keberadaannya untuk menampung komponen lainnya, missal panel, tabbed, dan toolbar. 3) Komponen Atomic (tunggal) berfungsi untuk menampilkan dan atau menerima informasi. Contohnya adalah textfield, button, dan label. (Sumber: https://didiindra.wordpress.com/tag/pengertian-java/ https://y0g4ajust.wordpress.com/2009/11/09/tugas-2-komponen java-swing/ )

6

2.3

LANGKAH PERCOBAAN DAN PEMBAHASAN

1. Buat file baru : File

 New

Project  Java  Java application

Gambar 2. 1 Membuat File project baru

2. Memberi nama project, di praktikum ini menggunakan nama Kelompok5

Gambar 2.2 Memberi nama project

3. Setelah itu membuat JFrame Form. Caranya yaitu klik kanan pada Source Packages lalu pilih New lalu pilih JFrame Form.

Gambar 2.3 Membuat Jframe From baru

7

4. Kemudian memberi nama Jframe tersebut dengan nama “SnapFrame”. Untuk package dapat dikosongkan atau diisi dengan nama yang diinginkan.

Gambar 2.4 Memberi nama JFrame baru

5. Kemudian membuat tampilan form seperti berikut. Caranya dengan drag and drop tools dari palette. Tools yang dipakai yang berada di Swing Control. Tools yang digunakan adalah Jbutton dan Jlabel.

Gambar 2.5 Pallete pada Jframe Form

Gambar 2.6 Tampilan tahap pertama program

6. Setelah itu klik Connection Mode, kemudian klik pada tombol, kemudian klik pada label. Connection mode digunakan untuk menghubungkan 6. komponen seperti jButton1 dengan jLabel1. Kondisi yang diinginkan

8

adalah ketika kita klik jButton1 maka jLabel1 akan berganti tulisan yaitu “Praktikum

RSBK”.

Maka

dengan

connection

mode

kita

dapat

memprogram kondisi tersebut secara mudah.

Gambar 2.7 Setting Connection Mode

7. Setelah

itu

akan

muncul

connection

Wizard,

pilih

action



actionPerformed. Pada langkah ini untuk membuat button yang ketika diberi action akan menjalankan events actionPerformed.

Gambar 2.8 Setting actionPerformed

8. Pilih set property , Text. Hal ini bertujuan untuk memilih action yang akan terjadi pada label.

Gambar 2.9 Mengubah setProperty

9

9. Isi Value sesuai keinginan, kemudian finish. Ini akan menghasilkan output “PRAKTIKUM RSBK ” pada label ketika button diberi action

Gambar 2.10 Mengisi Value

10. Isi value akan muncul seperti source code berikut

Gambar 2.11 Source Code Value

11. Selanjutnya menambahkan Java Bean caranya klik Tools kemudian Pallete lalu Swing / AWT Components. Langkah ini untuk menambahkan Java Bean ke dalam netbean sehingga dapat digunakan berkali-kali.

Gambar 2.12 Membuat Komponen AWT baru

12. Klik Add From Jar untuk mulai memilih package component

10

Gambar 2.13 Menambahkan File JAR

13. Kemudian cari lokasi File BumperSticker, pilih filenya BumperSticker.jar

Gambar 2.14 Memilih file JAR

14. Pilih bumperSticker

Gambar 2.15 Memilih komponen yang akan ditambahkan

15. Pilih Beans untuk meletakkan komponen BumperSticker tersebut ke folder Beans

11

Gambar 2.16 Memilih kategori komponen

16. Drag Beans lalu BumperSticker ke Form

Gambar 2.17 Menambahkan BumperSticker ke form

17. Tambahkan satu button lagi untuk menjalankan animasinya,

Gambar 2.18 Menambahkan Button Baru

18. Koneksikan Button 2 dengan Bean BumperSticker, gunakan action performed, pilih MethodCall, pilih method go()

12

Gambar 2.19 Menambahkan method go()

19. Setelah itu run projectnya. Jika jButton1 ditekan maka label akan menampilkan teks “Praktikum RSBK ” dan jika jButton2 ditekan maka gambar love akan berkedip merah

Gambar 2.20 Hasil Program

13

2.4

TUGAS

Tugas

praktikum

yaitu

membuat

dan

memanfaatkan

bean

baru

“FaceBean.jar”. Langkah-langkah untuk membuat bean baru dengan software netbean adalah pertama-tama membuat project baru yang diberi nama “Facebean.

Gambar 2.21 Membuat project Facebean

Kemudian salin source code facebean ke Facebean.java. Source code d apat dilihat seperti berikut : package facebean; import java.awt.*; import javax.swing.*; public class FaceBean extends JComponent { private int mMouthWidth = 90; private boolean mSmile = true; @Override public void paint(Graphics g) { Graphics2D g2 = (Graphics2D)g; g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); // Face int w = getWidth(); int h = getHeight(); int pad = 12; int cw = w - pad * 2; int ch = h - pad * 2; g2.setColor(getBackground()); g2.fillArc(pad, pad, cw, ch, 0, 360); g2.setColor(getForeground()); g2.drawArc(pad, pad, cw, ch, 0, 360); // Mouth int sw = cw / 2; int sh = ch / 2; if (mSmile == true) g2.drawArc(w / 2 - sw / 2, h / 2 - sh / 2, sw, sh, 270 - mMouthWidth / 2, mMouthWidth); else g2.drawArc(w / 2 - sw / 2, h / 2 + sh / 3, sw, sh, 90 - mMouthWidth / 2, mMouthWidth);

14

// Eyes int er = 4; g2.fillArc(w / 2 - cw * 1 / 8 - er / 2, h / 2 - ch / 4 - er, er, er, 0, 360); g2.fillArc(w / 2 + cw * 1 / 8 - er / 2, h / 2 - ch / 4 - er, er, er, 0, 360); } public int getMouthWidth() { return mMouthWidth; } public void setMouthWidth(int mw) { mMouthWidth = mw; repaint(); } public void smile() { mSmile = true; repaint(); } public void frown() { mSmile = false; repaint(); } }

Didalam source code tersebut terdapat 2 perintah yang dapat dipanggil. Yaitu perintah untuk membuat wajah senang (method smile) dan wajah sedih (method frown).

Gambar 2. 22 Source Code Facebean

Setelah itu pilih icon build pada bar seperti gambar dibawah ini. Fungsi build adalah untuk membentuk file Facebean.java menjadi Facebean.jar .

Gambar 2.23 Build Project

Setelah itu file jar sudah terbentuk dan tersimpan di lokasi folder dist pada project tersebut.

15

Gambar 2. 24 Output build project

Kemudian membuat Jframe Form seperti dibawah ini. Komponen yang digunakan 2 button dan 1 bean Facebean.

Gambar 2. 25 Tampilan Form

Untuk menghubungkan button dengan bean Facebean maka menggunakan connection mode. Lalu pilih actionPerformed kemudian method call. Button 1 menggunakan method smile() dan button 2 menggunakan method frown().

Gambar 2. 26 Method Call untuk Button 1

16

Gambar 2. 27 Method Call untuk button 2

Project dapat di run. Hasil yang diberikan adalah ketika menekan button senang maka gambar wajah akan senang, sedangkan ketika menekan button sedih maka gambar wajah akan sedih.

Gambar 2. 28 Hasil project ketika kondisi senang

Gambar 2. 29 Hasil project ketika kondisi sedih

17

2.5

KESIMPULAN

1.

Java bean dikatakan komponen reusable karena dapat dipakai berkalikali baik itu dalam satu project maupun project lain .

2.

Connection mode digunakan untuk mempermudah pengaturan event dibandingkan dengan menulis source code secara manual.

3.

Method smile() dan frown() pada specify target operation dipanggil dari FaceBean.java.

4.

Untuk penambahan beans dapat dilakukan dengan 3 mekanisme yaitu dengan menambahkan dari file .jar, menambahkan dari library dan juga dapat menambahkan dari project.

5.

Project FaceBean memiliki 2 class yaitu FaceBean.java yang berisi mekanisme beans bekerja dan FaceBeanBeanInfo yang berisi identif ikasi properties beans.

6.

Selain mengimport project beans yang sudah dibuild menjadi jar, dapat juga mengimport beans yang masih berupa project.

BAB III EJB SESSION BEAN 3.1. TUJUAN

1. Praktikan dapat mengetahui apa itu session bean 2. Praktikan dapat mengetahui tipe-tipe session bean 3. Praktikan dapat mengetahui kegunaan glassfish server pada netbeans 4. Praktikan dapat mengetahui contoh penggunaan glassfish server pada netbeans 5. Praktikan dapat menggunakan glashfish server untuk membangun aplikasi

18

19

3.2 DASAR TEORI

3.2.1

Session Bean Merupakan pemodelan dari proses bisnis. Enterprise bean jenis ini

mengerjakan sebuah aksi di dalam sistem, seperti mengaskses basis data, menghitung angka-angka, atau memanggil enterprise beans lain. Session bean digunakan untuk membuat bean yang memiliki bisnis proses per session saja. Dalam pengaksesannya tidak membutuhkan data yang tetap ada. Sess ion bean hanya dapat memiliki satu klien pada saat yang bersamaan. Cara kerja dari bean jenis ini adalah per session, dimana hanya dapat memiliki sat u klien per session. Saat klien mengalami terminasi, maka session bean tidak lagi terasosiasi dengan klien.

3.2.2

Stateless Session Bean Stateless session bean merupakan session ban yang tidak mengelola

asosiasi dengan klien sehingga pada saat klien memanggil, bean ini akan memberikan apa yang dibutuhkan oleh klien tetapi tidak memelihara hubungan dengan klien ini. Setelah kebutuhan klien ini dipenuhi oleh bean, maka session bean dapat dipergunakan oleh klien lain. Stateles s session bean mendukung multi klien.

3.2.3

Statefull Session Bean Statefull session bean merupakan session ban yang menjaga asosiasi

dengan klien, sehingga apabila klien mengalami terminasi, bean juga akan mengalami terminasi. Statefull session bean hanya dapat dipergunakan oleh satu klien, karena umur hidupnya adalah selama klien memanggilnya dan sampai klien mengalami terminasi.

3.2.4

Singleton Session Bean Merupakan session ban yang hanya diinisialisasi satu kali oleh aplikasi.

Jadi, hanya terdapat sebuah sindeton session ban dalam sebuah aplikasi. Sekali diinisialisasi, maka session ban tersebut akan berada dalam aplikasi selama aplikasi tidak ditutup.

20

3.3 LANGKAH KERJA DAN PEMBAHASAN 1. Membuka Netbean. Lalu membuat file baru : File -> New Project -> Java

EE -> Enterprise Application 2. Memberi nama file “konversisuhu _kel5”

Gambar 3.1 Memberi nama project

3. Menentukan server: click add  GlassFish Server  OK

Gambar 3.2 Menentukan Server

4. Buat session baru : klik kanan pada Enterprise Beans -> New -> Session

Bean.

Gambar 3.3 Membuat Session Bean

5. Beri nama session dan source pakage, pilih tipe session “stat eless” , gunakan

non_interface (tanpa memilih salah satu interface yang ada)

 finish

21

Gambar 3.4 Memberi nama session bean

6. Buat method baru : klik kanan session bean konversisuhu → Add → Business Method

Gambar 3.5 Membuat method baru

7. Tentukan nama method, return type, dan parameter

Gambar 3.6 Menentukan nama method

8. Tambahkan source code berikut pada class konversisuhu package rsbk; import java.text.DecimalFormat; import javax.ejb.Stateless; @Stateless public class konversisuhu { DecimalFormat a = new DecimalFormat ("0.0"); public String celcius_Fahrenheit(double cf) { String hasil = a.format(((cf*9.0/5.0 + 32)*100)/100.0); return hasil; } //konversi celcius ke fahrenheit public String fahrenheit_Celcius(double fc) { String hasil = a.format(((fc-32)*5.0/9.0*100)/100.0); return hasil; } //konversi fahrenheit ke celcius

22

public String fahrenheit_Reamur(double fr) { String hasil = a.format(((fr-32)*4.0/9.0*100)/100.0); return hasil; } //konversi fahrenheit ke reamur public String Reamur_Fahrenheit(double rf) { String hasil = a.format(((rf+32)*9.0/4.0*100)/100.0); return hasil; } //konversi reamur ke fahrenheit public String Reamur_Celcius(double rc) { String hasil = a.format(((rc)*5.0/4.0*100)/100.0); return hasil; } //konversi reamur ke celcius public String Celcius_Reamur(double cf) { String hasil = a.format(((cf)*4.0/5.0*100)/100.0); return hasil; } //konversi celcius ke reamur

9. Buat Servlet baru: klik kanan pada project  new  Servlet

Gambar 3.7 Membuat servlet baru

10. Beri nama class dan pakage  next

Gambar 3.8 Memberi nama class dan package

11. Centang pada ‘Add information to deployment descriptor (web.xml)’ lalu klik Finish

23

Gambar 3.9 Memilih add information to deployment descriptor

12. Setelah masuk halaman servlet , remove comment processRequest pada

method body, body, dan tekan , dan pilih Call Interprise Interprise Bean

Gambar 3.10 Call enterprise bean

13. Pilih session bean

 ok

Gambar 3.11 Memilih session bean

14. Masukan kode berikut ini: package rsbk;

24

import import import import import import import

java.io.IOException; java.io.IOException; java.io.PrintWriter; java.io.PrintWriter; javax.ejb.EJB; javax.ejb.EJB; javax.servlet.ServletException; javax.servlet.http.HttpServlet; javax.servlet.http.HttpServletRequest; javax.servlet.http.HttpServletResponse;

public class konversiServlet extends HttpServlet { @EJB konversisuhu konversisuhu; protected void processRequest(HttpServletRequest request, HttpServletResponse HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); PrintWriter out = response.getWriter(); //request servlet try { out.println(""); out.println("Tugas RSBK Konversi Suhu"); String suhu = request.getParameter("suhu"); if ((suhu != null) && (suhu.length() > 0)) { double d = Double.parseDouble(suh Double.parseDouble(suhu); u); if (request.getParameter("Celcius Ke Fahrenheit") != null){ String cefa = konversisuhu.celcius_Fahrenheit(d); out.println("
HASIL KONVERSI SUHU: "+cefa+"
"); } //menampilkan hasil konversi suhu if (request.getParameter("Fahrenh (request.getParameter("Fahrenheit eit Ke Celcius") != null) { String face = konversisuhu.fahrenheit_Celcius(d); out.println("
HASIL KONVERSI SUHU: "+face+ " .
"); } //menampilkan hasil konversi suhu if (request.getParameter("Reamur Ke Celcius") != null) { String rece = konversisuhu.Reamur_Celcius(d); out.println("
HASIL KONVERSI SUHU: " +rece+ " .
"); } //menampilkan //menampilkan hasil konversi suhu if (request.getParameter("Reamur Ke Fahrenheit") != null) { String refa = konversisuhu.Reamur_Fahrenheit(d); out.println("
HASIL KONVERSI SUHU: "+refa+ " .
"); } //menampilka n hasil konversi suhu if (request.getParameter("Fahrenheit Ke Reamur") != null) { String fare = konversisuhu.fahrenheit_Reamur(d); out.println("
HASIL KONVERSI SUHU: "+fare+ " .
"); } //menampilkan //menampilkan hasil konversi suhu if (request.getParameter("Celcius Ke Reamur") != null) { String cere = konversisuhu.Celcius_Reamur(d); out.println("
HASIL KONVERSI SUHU: "+cere+ " .
"); } //menampilkan //menampilkan hasil konversi suhu } else { out.println(""); out.println("
Masukan Suhu:
"); out.println("
"); out.println("
"); //input nilai suhu awal out.println("
"); //baris baru out.println("
"); //baris baru

25

out.println(""+ "");//tampilkan tombol konversi out.println("
"); //baris baru out.println(""+ ""); //tampilkan tombol konversi out.println("
"); //baris baru out.println(""+ ""); //tampilkan tombol konversi out.println("
out.println(""); "); //membuat tombol rata tengah out.println(""); } } finally { out.println(""); out.println(""); out.println(""); out.close(); } }

15. Lakukan ‘Clean and Build’ dan ‘Deploy’ pada project

Gambar 3.12 clean and Build

Gambar 3.13 Melakukan Deploy

16. Klik kanan pada project → properties → run → isi is i Relative URL dengan “/konversiServlet” → klik OK

26

Gambar 3.14 Mengatur properties servlet

15. Hasil setelah aplikasi dijalankan adalah sebagai berikut

Gambar 3.15 Hasil running program

Saat aplikasi di run, maka akan tampil tampilan seperti gambar. Terdapat enam button yang masing masing bernama Fahrenheit ke Celcius, Fahrenheit ke Reamur, Celcius ke Fahrenheit, Celcius ke Reamur, Reamur ke Fahrenheit, dan Reamur ke Celcius. Pengujian dengan memasukan angka dan tombol yang diklik adalah Fahrenheit ke Celcius. Hasil konversinya

Gambar 3.16 Uji program Fahrenheit ke Celcius

27

3.4 TUGAS

3.4.1.

Membuat Tombol Back Tugas pertama yaitu membuat tombol Back digunakan untuk kembali dari halaman yang menampilkan hasil konversi ke halaman awal yang digunakan untuk memasukkan nilai yang akan dikonversi. Hasil tampilan halaman hasil menjadi seperti gambar berikut

Gambar 3.17 Tampilan tombol back

Untuk listing kode yang diberikan agar didapatkan tombol back seperti gambar adalah sebagai berikut out.println("
type=\"button\"

value=\"back\"

onclick = \"history.back(-1)\"/>"); // tombol untuk back pada hasil konversi

Dari listing kode tersebut dapat dilihat bahwa tipenya adalah button (tombol) bertuliskan back yang apabila di klik akan menuju ke halaman sebelumnya dari history (-1).

3.4.2.

Menambahkan Konversi Kelvin Tugas kedua adalah menambahkan konversi Kelvin ke berbagai satuan suhu lainnya seperti F → K, K → F, C → K, K → C, R → K, dan K → R.

Gambar 3.18 Nilai awal

Nilai awal yang diberikan untuk dikonversikan dikonversikan adalah 5.

28

Gambar 3.19 Hasil konversi Celcius ke Kelvin

Gambar 3.20 Hasil konversi Kelvin ke Celcius

Gambar 3.21 Hasil konversi Reamur ke Kelvin

Gambar 3.22 Hasil konversi Kelvin ke Reamur

Gambar 3.23 Hasil konversi Fahrenheit ke Kelvin

Gambar 3.24 Hasil konversi Kelvin ke Fahrenheit

29

Dari hasil konversi dari Kelvin ke berbagai suhu lain dan dari berbagai suhu lain ke Kelvin menunjukkan bahwa nilai yang dimasukkan sebagai nilai awal akan di konversikan ke satuan suhu sesuai dengan yang dikehendaki pada saat menekan tombol pilihan konversi pada halaman awal. Jadi pada saat akan mengkonversi nilai 5 dari Fahrenheit ke Kelvin misalnya, cukup menekan tombol Fahrenheit ke Kelvin saja maka selanjutnya nilai tersebut akan dihitung berdasarkan

perhitungan

konversisuhu.java.

konversi

suhu

yang

berada

pada

30

3.5 KESIMPULAN

1. Session Bean pada praktikum digunakan membuat sebuah aplikasi yang dapat dipanggil oleh user melalui web. 2. Penggunaan stateless bean dalam praktikum digunakan agar siapa sa ja dapat mengakses aplikasi tersebut karena stateless bean dapat digunakan multiuser. 3. Klien harus memanggil method session bean, untuk mengakses aplikasi yang di deploy ke server. 4. Glashfish Server digunakan pada praktikum karena merupakan server aplikasi open source yang mendukung untuk platform Java EE sehingga dalam pembuatan aplikasi dapat lebih mudah. 5. Pada praktikum ini membuat pengkonversi suhu yang dijalankan melalui web browser dengan programnya berada pada Netbeans dengan glashfish server untuk mengaksesnya.

BAB IV Aplikasi CRUD Menggunakan JPA, EJB, dan MySQL

4.1 TUJUAN

1. Praktikan mampu menggunakan operasi CRUD dengan Data Base MySQL. 2. Praktikan mampu mengimplementasikan EJB. 3. Praktikan mamp mengimplementasikan JPA. 4. Praktikan mampu membuat program yang dapat ditampilkan ke browser. 5. Praktikan mampu memahami EJB Module yang digunakan pada Netbeans.

31

32

4.2 DASAR TEORI

4.2.1 Java Persistance API Java Persistence API merupakan tool untuk mengolah ataupun pengatur data relational dalam platform Java Standard Edition dan Java Enterprise Edition. JPA sendiri merupakan alat dalam pembuatan aplikasi berbentuk framework dalam pemrograman java dengan pendekatan Object Relational Maping (ORM). ORM sendiri merupakan sebuah konsep yang berdiri sendiri, tidak terkait dengan Java. Namun hubungan ORM dengan JPA sangat dekat karena JPA merupakan standart ORM dalam Java, dan harus diikuti oleh pengguna ORM di Java agar ada standart yang sama antara ORM di Java dengan yang diluar Java.

4.2.2 Session Bean Session bean adalah EJB yang digunakan untuk mengeksekusi proses. Isi dari Session Bean ini biassanya berupa kata kerja (transfer, pay, calculate, updateData, dll). Stateless Session Bean (SLSB) adalah Session Bean yang tidak menyimpan state (keadaan) pada setiap kali eksekusi. Berbeda dengan Statefull Session Bean (SFSB) yang dapat menyimpan state. State ini dapat kita gunakan misalnya untuk menyimpan informasi user atau barang-barang yang sudah dibeli (pada kasus online shop).

4.2.3 Entity Unit Entity Unit adalah EJB yang digunakan untuk mempermudah manipulasi database. Konsepnya adalah Object – Relational Mapping (ORM) yang berarti memetakan object dengan data di dalam database. Entity Unit sebenarnya adalah spesifikasi bawaan dari versi EJB sebelumnya yaitu EJB 2.1. Dalam EJB3, ada API lain yang lebih sederhana yaitu Java Persistence API (JPA).

4.2.4 Java Servlet Servlet adalah komponen web yang berupa java class yang mengextends javax.servlet.http.HttpServlet. Class ini biasanya digunakan

33

untuk menangani http request, melakukan processing, kemudian memberikan hasil processing tersebut ke halaman JSP untuk ditampilkan di browser. Konsep ini disebut Model-View-Controller (MVC).

4.2.5 MySQL MySQL adalah sebuah perangkat lunak sistem manajemen basis data SQL (database management system) atau DBMS yang multithread, multi-user, dengan sekitar 6 juta instalasi di seluruh dunia.

34

4.3 LANGKAH PERCOBAAN DAN PEMBAHASAN

1. Buat database di MySQL. Beri nama “modul3”

Gambar 4.1 Membuat database baru

2. Buat 2 tabel : “login” dan “student”.

Gambar 4.2

Membuat tabel login

Gambar 4.3 Membuat tabel student

3. Buat userId pada tabel login menjadi unik

Gambar 4.4 Tabel Login

4. Isi database dengan nama & nim kelompok

35

Gambar 4.5 Membuat tabel student

5. Buat user MySQL baru sesuai nomor kelompok

Gambar 4.6 Membuat user

Gambar 4.7 Mengatur privilages untuk user

6. Buat project baru pada Netbeans, pilih Java Web → Web Application 7. Beri nama project “Modul3_kelompok5” dan pilih glassfish server

36

Gambar 4.8 Memberi nama projek baru

Gambar 4.9 Memilih Glashfifh server

8. Buat JDBC Connection Pool

Gambar 4.10

Membuat connection pool

37

9. Beri nama connection pool dan pilih ‘New Configuration using Database’ → ‘MySQL (MM MySQL driver)

Gambar 4.11

Memberi nama connection pool

10. Isikan URL, User, dan Password MySQL yang sudah dibuat

Gambar 4.12

Mengatur connection pool

11. Buat JDBC Resource

Gambar 4.13

Membuat JDBC resource

12. Pilih ‘Use Existing JDBC Connection Pool’, isikan JNDI Name

38

Gambar 4.14

Mengisikan JNDI name

13. Buat Persistence Unit, beri nama, dan pilih data source yang tadi sudah dibuat

Gambar 4.15

Membuat Persistence unit

14. Buat 3 JSP page pada folder “Web Pages”, beri nama : home.jsp, login.jsp, dan error.jsp. Masukkan source code yang tersedia.

Gambar 4.16

Membuat jsp page

39

Gambar 4.17

JSP page yang sudah dibuat

15. Cek “login.jsp”, pada tag
, sesuaikan URL action dengan nama project. 16. Copy Source code berikut mulai dari tag sampai ke class home.jsp <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> JSP Page
Welcome <%=session.getAttribute("loginName")%>
//menampilkan tulisan Welcome nama yang dipakai untuk login pada halaman depan
Student Information //menampilkan tulisan Student Information //menampilkan apa yang ada di StudentServlet //menampilkan tabel dengan kolom studentId, FirstName, dan LastName //menampilkan data dari tabel student kolom studentId //menampilkan data dari tabel student kolom firstName //menampilkan data dari tabel student kolom lastName
Student ID

First Name

Last Name

//memberi action pada tombol Add

40

//mengambil data dari database untuk ditampilkan tabel

/> /> />

ke

ID First Name Last Name
${stud.studentId} ${stud.firstName} ${stud.lastName}

17. Copy Source code berikut mulai dari tag sampai ke class login.jsp
//memasukkan username pada halaman login //memasukkan password pada halaman login //memberi action pada tombol Login

Username

Password

18. Copy Source code berikut mulai dari tag sampai ke class error.jsp

41

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> JSP Page
Error - <%=request.getAttribute("error")%>
//memberikan keterangan error ketika yang dimasukkan tidak terdapat di database

19. Buat 3 package pada folder “Source Packages”, beri nama : “com.controller”, “com.dao”, dan “com.model”.

Gambar 4.18

Gambar 4.19

Membuat package baru

Package yang telah dibuat

20. Buat 2 Entity Class pada package “com.model”, beri nama : “Login” dan “Student”. Masukkan source code yang tersedia.

42

Gambar 4.20

Gambar 4.21

Membuat entity class

Entity class yang sudah dibuat

21. Masukkan source code yang tersedia. Login.java package com.model; //login.java berada di dalam com.model import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.NamedQueries; import javax.persistence.NamedQuery; import javax.persistence.Table; @Entity @Table @NamedQueries({@NamedQuery(name="Login.getAll",query="SE LECT e FROM Login e")}) //mengambil data yang ada di tabel Login public class Login implements Serializable{ @Id @GeneratedValue(strategy=GenerationType.AUTO) @Column private int userId; @Column private String userName; @Column private String password; public int getUserId() { return userId; } public void setUserId(int userId) { this.userId = userId; } public String getUserName() { //mengambil username return userName; } public void setUserName(String userName) {

43

this.userName = userName; } public String getPassword() { //mengambil password return password; } public void setPassword(String password) { this.password = password; } }

Student.java package com.model; import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.NamedQueries; import javax.persistence.NamedQuery; import javax.persistence.Table; @Entity @Table @NamedQueries({@NamedQuery(name="Student.getAll",query=" SELECT e FROM Student e order by e.studentId")}) //mengambil nilai dari tabel student public class Student implements Serializable{ @Id @GeneratedValue(strategy=GenerationType.AUTO) @Column private int studentId; @Column private String firstName; @Column private String lastName; public Student(int studentId, String firstName, String lastName) { this.studentId = studentId; this.firstName = firstName; this.lastName = lastName; } public Student() { } public int getStudentId() { //mengambil studentId yang telah di set return studentId; } public void setStudentId(int studentId) { //mengeset nilai student Id this.studentId = studentId; } public String getFirstName() { //mengambil First name yang telah di set return firstName; } public void setFirstName(String firstName) { this.firstName = firstName;

44

} public String getLastName() { //mengambil last name yang telah di set return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } }

22. Buat 2 Session Beans pada package “com.dao”, beri nama : “LoginDAO” dan “StudentDAO”. Ketika membuat session bean, pilih Session Type ‘Stateless’ dan Create Interface ‘Local’.

Gambar 4.22

Membuat session bean

Gambar 4.23

Membuat session bean

23. Masukkan source code yang tersedia. LoginDAO package com.dao; import com.model.Login; import java.util.List; import javax.ejb.Stateless; import javax.persistence.EntityManager;

45

import javax.persistence.PersistenceContext; /** * * @author USER */ @Stateless public class LoginDAO implements LoginDAOLocal { @PersistenceContext private EntityManager em; @Override public boolean checkUser(String userName, String password) { List s = (List)em.createQuery("select e from Login e where e.userName='"+userName+"' and e.password='"+password+"'").getResultList(); // mengambil data password dan username dari tabel login System.out.println("is list empty ?"+s.isEmpty()+" for the"+userName+" and "+password); if(!s.isEmpty()) return true; else return false; } // Add business logic below. (Right-click in editor and choose // "Insert Code > Add Business Method") }

LoginDAOLocal.java package com.dao; import com.model.Login; import javax.ejb.Local; /** * * @author USER */ @Local public interface LoginDAOLocal { public boolean checkUser(String password); }

username,

String

StudentDAO.java package com.dao; import com.model.Student; import java.util.List; import javax.ejb.Stateless; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; /** * * @author Joseph */ @Stateless public class StudentDAO implements StudentDAOLocal { @PersistenceContext private EntityManager em; @Override

46

public void addStudent(Student student) { //menambah daftar student em.merge(student); em.flush(); } @Override public void editStudent(Student student) { //mengedit data student em.merge(student); em.flush(); } @Override public void deleteStudent(int studentId) { //menghapus data student em.remove(getStudent(studentId)); em.flush(); } @Override public Student getStudent(int studentId) { em.flush(); return em.find(Student.class, studentId); } @Override public List getAllStudents() { em.flush(); return em.createNamedQuery("Student.getAll").getResultList(); } }

StudentDAOLocal.java package com.dao; import com.model.Student; import java.util.List; import javax.ejb.Local; /** * * @author Joseph */ @Local public interface StudentDAOLocal { void addStudent(Student student); void editStudent(Student student); void deleteStudent(int studentId); Student getStudent(int studentId); List getAllStudents(); }

LoginServlet.java package com.controller; import com.dao.LoginDAOLocal; import java.io.IOException; import javax.ejb.EJB; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; /**

47

* * @author USER */ public class LoginServlet extends HttpServlet { @EJB private LoginDAOLocal loginDao; Boolean check=false; protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); String userName = request.getParameter("userName"); String password = request.getParameter("password"); HttpSession session = request.getSession(); check = loginDao.checkUser(userName,password); System.out.println("check is"+check+" "+userName); if(check) { session.setAttribute("loginName", userName); request.getRequestDispatcher("home.jsp").forward(reques t, response); } else { request.setAttribute("error", "Wrong Username or Password"); request.getRequestDispatcher("error.jsp").forward(reque st, response); //terjadi error apabila username atau password salah } } @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); } @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); } @Override public String getServletInfo() { return "Short description"; }// }

24. Buat 2 Servlet pada package “com.controller”, beri nama : “ LoginServlet” dan “StudentServlet”. Ketika membuat servlet, centang pada ‘Add information to deployment descriptor (web.xml)’.

48

Gambar 4.24

Membuat servlet

25. Kemudian masukkan source code yang tersedia. LoginServlet.java package com.controller; import com.dao.LoginDAOLocal; import java.io.IOException; import javax.ejb.EJB; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; public class LoginServlet extends HttpServlet { @EJB private LoginDAOLocal loginDao; Boolean check=false; protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); String userName = request.getParameter("userName"); String password = request.getParameter("password"); HttpSession session = request.getSession(); check = loginDao.checkUser(userName,password); System.out.println("check is"+check+" "+userName); if(check) { session.setAttribute("loginName", userName); request.getRequestDispatcher("home.jsp").forward(request, response); } else { request.setAttribute("error", "Wrong Username or Password"); request.getRequestDispatcher("error.jsp").forward(request , response); //terjadi error apabila username atau password salah } } @Override

49

protected void doGet(HttpServletRequest HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); } @Override protected void doPost(HttpServletRequest HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); } @Override public String getServletInfo() { return "Short description"; }// }

request,

request,

StudentServlet.java package com.controller; //studentservlet berada dalam com.controller import com.dao.StudentDAOLocal; import com.model.Student; import java.io.IOException; import javax.ejb.EJB; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse;

di

@WebServlet(name = "StudentServlet") public class StudentServlet extends HttpServlet { @EJB private StudentDAOLocal studentDao; protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String action = request.getParameter("action"); String studentIdStr = request.getParameter("studentId"); int studentId=0; if(studentIdStr!=null && !studentIdStr.equals("")){ studentId=Integer.parseInt(studentIdStr); } //mengambil data dari tabel mahasiswa String firstname = request.getParameter("firstname"); String lastname = request.getParameter("lastname"); Student student = new Student(studentId, firstname, lastname); //menghubungkan tabel data mahasiswa ke database if("Add".equalsIgnoreCase(action)){ studentDao.addStudent(student); }else if("Edit".equalsIgnoreCase(action)){ studentDao.editStudent(student); }else if("Delete".equalsIgnoreCase(action)){ studentDao.deleteStudent(studentId);

50

}else if("Search".equalsIgnoreCase(action)){ student = studentDao.getStudent(studentId); } //memilih aksi yang akan dilakukan request.setAttribute("student", student); request.setAttribute("allStudents", studentDao.getAllStudents()); request.getRequestDispatcher("home.jsp").forward(request, response); } @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); } @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); } @Override public String getServletInfo() { return "Short description"; }// }

26. Buka “web.xml” di folder ‘Configuration Files’. Pada tab ‘Pages’, isikan Welcome Files dengan “login.jsp”.

Gambar 4.25

Mengisi welcome files pada configuration files

27. Lakukan ‘Clean and Build’, kemudian jalankan program.

Gambar 4.26

Mengisi username dan password

51

Gambar 4.27

Tampilan program setelah login

Aplikasi ini adalah aplikasi sistem informasi siswa yang berisi studentId, FirstName, dan LastName. Ketika aplikasi dijalankan, muncul halaman utama berupa halaman login. Setelah login mengunakan Username dan Password akan tampil data siswa yang ada di database. Kemudian admin bisa menambah, mengedit, ataupun menghapus data siswa yang diinginkan.

52

4.4 TUGAS

Tugas pada praktikum kali ini ada beberapa tugas yaitu : 1. Menambahkan kolom Address Untuk menampilkan kolom address pada aplikasi maka pada database diperlukan kolom baru yang berisi address dari setiap student . Setelah pada database ditambahkan kolom address selanjutnya tinggal menambahkan listing kode pada home.jsp, StudentServlet.java, dan Student.java. Sehingga untuk tampilan pada aplikasinya menjadi seperti gambar berikut.

Gambar 4.28

Tampilan kolom address

2. Menambahkan session pada login Session pada login digunakan apabila membuka tab baru pada saat keadaan sudah login maka akan langsung ditampilkan halaman yang berisi data mahasiswa setelah login tersebut. Sedangkan apabila belum melakukan login maka akan diteruskan untuk login terlebih dahulu. Berikut kode yang ditambahkan pada login.jsp <% if (session.getAttribute("loginName") == null) { %>

<%} else { request.getRequestDispatcher("./StudentServlet").forward(requ est, response); } %>

53

Sementara itu, di StudentServlet.java ditambahkan listi ng kode berikut untuk mencegah user yang belum login sehingga tidak akan bisa membuka data mahasiswa. HttpSession session = request.getSession(); if (session.getAttribute("loginName") != null) {

else request.getRequestDispatcher("login.jsp").forward(request, response); } }

{

Untuk hasil pada aplikasinya ditunjukkan seperti pada gambar berikut.

Gambar 4.29

Tampilan akan membuka studentservlet tanpa login

3. Menambahkan Logout Logout digunakan untuk user keluar dari halaman yang menampilkan data mahasiswa menuju ke halaman login. Untuk tampilan pada aplikasi ditunjukkan seperti gambar berikut.

Gambar 4.30

Halaman data mahasiswa yang ada logout

Gambar 4.31

Tampilan setelah logout

54

4.5 KESIMPULAN

1. Untuk mengolah ataupun pengatur data relational dalam platform Java Standard Edition dan Java Enterprise Edition digunakan Java Persistence API. 2. Untuk mempermudah memanipulasi database digunakan EJB Entity Unit. 3. Untuk menangani http request, melakukan processing, kemudian memberikan hasil processing ke halaman JSP untuk ditampilkan di browser menggunakan Servlet. 4. Session bean pada praktikum ini digunakan untuk melakukan proses manajemen data seperti add, search, edit, delete. 5. Entity class pada praktikum ini digunakan untuk menghubungkan tabel dengan database sehingga dapat mengambil data dari database.

BAB V JAVA SERVER FACES

5.1 TUJUAN

1. Praktikan dapat mengetahui framework JSF. 2. Praktikan dapat mengetahui penggunaan Java Server Faces. 3. Praktikan dapat mengetahui contoh penggunaan glassfish server pada netbeans. 4. Praktikan dapat mengetahui fungsi dari session beans dan entit y class. 5. Praktikan dapat membuat aplikasi CRUD sederhana dengan JSF. 6. Praktikan

dapat

mengatasi

masalah

menggunakan JSF.

55

saat

menjalankan

program

56

5.2 DASAR TEORI 5.2.1

Java Server Faces

Java

Server

Faces

(JSF) adalah

spesifikasi Java untuk

membangun antarmuka pengguna untuk aplikasi web. JSF merupakan bagian

dari Java

Platform,

Enterprise

Edition.

JSF

2

menggunakan Facelets sebagai sistem templat defaultnya. Teknologi tampilan lainnya, seperti XUL, juga dapat digunakan. Sementara itu, J SF 1.x

menggunakan

Java

Server

Pages

(JSP) sebagai

sistem

template defaultnya. Java server Faces berdasarkan model perancangan antarmuka pengguna berbasis komponen, menggunakan berkas XML yang disebut template view atau view Facelets.

Permintaan (request)

diproses oleh FacesServlet, yang memuat template view yang sesuai, membangun tree komponen,

memproses

berbagai event,

dan

me-

render respons (umumnya HTML) kepada klien. State dari komponen UI (dan

beberapa

objek

lain)

disimpan

pada

setiap

akhir request (dinamakan state Saving), dan dikembalikan pada saat pembuatan

selanjutnya

dari view tersebut.

Ada

beberapa

jenis

penyimpanan state, termasuk penyimpanan state client-side dan serverside. 5.2.2 Glassfish Server

GlassFish adalah sebuah proyek server aplikasi open source yang dikeluarkan dan dikelola oleh Sun Microsystems untuk plat form Java EE dan sekarang disponsori oleh Oracle Corporation. Versi didukung disebut Oracle GlassFish Server. GlassFish adalah perangkat lunak bebas, dual berlisensi di bawah dua lisensi pengembang perangkat lunak bebas: Common Development and Distribution License (CDDL) dan GNU

Gambar 5.1 GlassFish Server

57

General Public License (GPL) dengan pengecualian classpath. Saat ini Glassfish terbaru dalam versi 4.1.1 yang resmi diri lis pada bulan Oktober 2015.

5.2.3 Session Bean

Session Bean adalah salah satu EJB yang digunakan untuk merepresentasikan proses, kendali dan alur kerja. Contohnya, session bean

digunakan

untuk

melakukan

validasi

credit

card,

mencariketersediaan jadwal penerbangan, dan menyimpan shopping cart. Session Bean bisa Stateless atau Stateful. SessionBean tidak disimpan di dalam database, dan tidak akan survive jika server mengalami crash. Session bean hanya diakses oleh satu client, dan transactional. Tipenya ada dua, stateless ( tidak menyimpan record apa yang dilakukan pada previous call) dan statefull (menyimpan record apa yang dilakukan client pada previous call).

5.2.4 Entity Unit

Entity unit merupakan kumpulan kelas entity yang disimpan dalam EJB-Jar, WAR, atau arsip JAR bersama dengan file persistence.xml. Bagian Mendeploy Kelas Entity akan menjelaskan aturan-aturan dan penempatan kelas entity secara rinci. Kunci untuk memahami konsep ini adalah bahwa sebuah entity unit mendefinisikan kelas entity yang dikendalikan oleh sebuah manajer entity. Entity unit terbatas hanya untuk satu DataSource atau satu tabel tunggal sebagai contoh employee dan department.

58

5.3 LANGKAH PERCOBAAN

1. Buka xampp

 aktifkan

apache dan mysql

 buka

browser  ketikkan

localhost/phpmyadmin/  buat database baru dengan nama kelompok5

Gambar 5.2 Membuat database baru

2. Tambahkan tabel product dengan ketikkan query berikut: create table product ( // membuat tabel product id varchar(10) not null, // membuat id product name varchar(30) not null,// membuat nama product price integer,// membuat harga product description varchar(500),// membuat deskripsi product quantity integer(11),// membuat jumlah product primary key (id)// menjadikan id product sebagai primary key );

3. Masukkan data ke dalam tabel dengan mengetikkan query berikut: INSERT INTO `product`(ìd`, `name`, `price`, `description`, `quantity`) VALUES (1,'Nokia',1000000,'good',5); // memasukan data product hp Nokia INSERT INTO `product`(ìd`, `name`, `price`, `description`, `quantity`) VALUES (2,'Samsung',4000000,'good',4); // memasukan data product hp Samsung INSERT INTO `product`(ìd`, `name`, `price`, `description`, `quantity`) VALUES (3,'Apple',6000000,'good',10); // memasukan data product hp Apple

4. Pilih menu home pada phpMyAdmin add user account

 pilih

menu user accounts

 pilih

59

Gambar 5.3 Membuat akun user yang baru

5. Keterangan user sebagai berikut: Username : kel5 Hostname : localhost Kata Sandi : kel5

Gambar 5.4 Mengisi data akun user yang baru

6. Checklist bagian seperti dibawah ini

Gambar 5.5 Memberi hak akses user

60

7. Buka netbeans IDE, masuk bagian Services  klik kanan Database  pilih New Connection

Gambar 5.6 New Connection

8.

Pada bagian driver pilih MySQL (Connector/J driver)

 next

Gambar 5.7 Memilih Driver Connection

9. Ubah username dan password dengan user yang sudah dibuat

 tekan

Connection  jika sukses, tekan Finish

Gambar 5.8 Mengubah username, password

10. Buat project baru  Java EE  pilih Enterprise Application

 Next

Test

61

Gambar 5.9 Membuat project baru

11. Masukkan nama project  JSFApp_kel5  Next

Gambar 5.10 Mengisi nama project baru

12. Pilih glassfish server  Finish

Gambar 5.11 Mengatur server glassfish

13. Klik kanan pada JSFApp_Kel5-ejb

New

→

Other

→

62

Gambar 5.12 Mencari GlassFish

14. Pilih GlassFish

JDBC Connection Pool

→

→

Next

Gambar 5.13 Membuat JDBC Connection Pool

15. Beri nama Kelompok5Pool

→

pilih Extract From Existing Connection

pilih connection yang sudah dibuat

→

Next

Gambar 5.14 Memberi Nama Connection Pool

16. Klik Finish 17. Klik kanan pada JSFApp_Kel5-ejb 18. Pilih GlassFish

JDBC Resource

→

New

→

Next

→

Other

→

→

63

Gambar 5.15 Membuat JDB Resource

19. Pilih Use Existing JDBC Connection Pool →

beri nama JNDI kelompok5

Pilih Pool yang sudah dibuat

→

Finish

→

Gambar 5.16 Memberi Nama JNDI

20. Klik kanan pada JSFApp_Kel5-ejb

New

→

Java Package

→

21. Buat dua buah package, entity dan model.

Gambar 5.17 Membuat Package Entity

64

Gambar 5.18 Membuat Package model

22. Klik kanan JSFApp_Kel5-war

New

→

→

Java Package

23. Beri nama controller

Gambar 5.19 Memberi Nama Package dengan Controller

24. Klik kanan pada package entity 25. Pilih Persistence

New

→

→

Other

Entity Classes from Database

→

→

Next

Gambar 5.20 Memilih Entity Classes from Database

26. Pilih Data Souce yang telah dibuat

add all

→

next

→

65

Gambar 5.21 Memilih Data Source

27. Pada bagian entity classes langsung tekan next. 28. Pada bagian collection type pilih java.util.List

 Finish

Gambar 5.22 Memilih Database Type

29. Klik kanan pada bagian package model

 New  Other

30. Pilih Persistence  Session Beans for Entity Classes

Gambar 5.23 Membuat Session Bean

31. Tekan add all  klik next

 Next

66

Gambar 5.24 Menambahkan Entity Class

32. Pada bagian generated session beans pastikan packages berisi model Finish 33. Klik kanan pada JSFApp-war

 Properties

34. Pilih frameworks  tekan tombol Add

 pilih

JavaServer Faces  OK

Gambar 5.25 Memilih Framework

35. JSFApp-war  Web Pages  hapus index.html

Gambar 5.26 Menghapus Index.html



67

36. JSFApp-war  Source Packages

 klik

kanan pada package controller



New  Other 37. Pilih JavaServer Faces

→

JSF Managed Bean

Gambar 5.27 Memilih JSF Manage Bean

38. Beri nama ProductController  pada bagian scope pilih session

 Finish

Gambar 5.28 Memberi Nama JavaServer Faces

39. Buka ProductController.java masukkan kode seperti yang ada pada ProductController.txt 40. Buka index.xhtml masukkan kode seperti yang ada pada index.txt 41. Klik pada JSFApp-war

 New  Other

42. Pilih Web  JSF Page

 Next

68

Gambar 5.29 Membuat JSF Page

43. Beri nama add  Finish

Gambar 5.30 Memberi Nama JSF Page

44. Buka add.xhtml

 hapus

tulisan Hello from Facelets

bagian yang dihapus tadi  Insert Code

Gambar 5.31 Insert Code

45. Pilih JSF Form From Entity

 klik

kanan pada

69

Gambar 5.32 Insert Code pada add.xhtml

46. Pilih entity : entity.Product

 managed bean property: productController.p

 OK

Gambar 5.33 Memilih productController.p

47. Tambahkan kode berikut diatas yang digenerate untuk menampilkan button add:

48. Klik JSFApp-war  New  JSF Page 49. Beri nama edit  Finish 50. Buka edit.xhtml

 hapus

tulisan Hello from Facelets

 klik

kanan pada

bagian yang dihapus tadi  Insert Code 51. Pilih JSF Form From Entity 52. Pilih entity : entity.Product

 managed bean property: productController.p

 OK

Gambar 5.34 Memilih Bean Property

70

53. Tambahkan kode berikut diatas yang digenerate untuk menampilkan button edit

54. Clean and Build kesayangan anda



Run. Lalu akan muncul Programnya di browser

71

5.4 PEMBAHASAN

Dibuat database dengan 4 kolom, yaitu id, name, price, description, dan quantity pada localhost. Lalu data diisi menggunakan query. Data inilah yang nantinya akan ditampilkan pada halaman index. Ketika aplikasi di-run akan browser default akan otomatis terbuka dan menampilakan halaman index.xhtml.

Gambar 5.35 Tampilan program

Productjava berisi getter, setter dan query dari kolom2 yang sudah dibuat didatabase yang nantinya akan diimpor oleh ProductFacade.java. ProductFacade.java memiliki persistence yang dapat mengkases ke database. Class ProductController mengimport database ini untuk ditampilkan di halaman index. “Tambah Barang” akan membawa kita ke halaman add.xhtml. Data yang kita inputkan di halaman ini, akan disimpan oleh ProductController.java di variable-variabel pada classnya dan disimpan ke database. Lalu dimuculkan pada halaman program.

Gambar 5.36 Tambah Barang

72

Gambar 5.37 Tambah Barang

Ketika praktikum masalah yang dialami adalah apabila glassfishresource.xml harus

dipindahkan ke server resource agar database dapat

ditambahkan ke Data Source dan projek dapat diteruskan pembuatannya. Selain itu, projek ini tidak selalu dapat berjalan disemua laptop.

73

5.5 KESIMPULAN

1. JSF mendukung event UI dan penanganannya sangat mudah untuk dipahami. 2. Dalam membuat aplikasi web, JSF menyimpan beberapa state termasuk state client-side dan server-side sehingga pengembangannya lebih cepat dari framework lain. 3. JSF mengambil manfaat dari komponen pihak ketiga tentunya dapat meminimalkan biaya menulis ulang kode program sehingga efisien waktu. 4. Kelas Entity menjelaskan aturan-aturan dan penempatan kelas entity secara rinci sehingga dapat memodelkan informasi yang berumur relative panjang. 5. Session bean mempresentasikan proses hanya berdasarkan permintaan client dan dapat berinteraksi dengan resource yang lain seperti entity bean, dan session bean yang lain.

BAB VI PENUTUP 6.1. KESIMPULAN

Dari praktikum kali ini dapat disimpulkan bahwa : 1. Java Bean adalah komponen dalam java yang bersifat reusable dan memiliki kelebihan JavaBean, dapat dimanipulasi secara visual menggunakan builder tool dan memungkinkan pengguna untuk membangun aplikasi secara mudah.

2. Enterprise Java Beans ( EJB ) adalah komponen server-side yang menyimpan business logic dan dapat diakses secara remote. 3. Untuk mengolah ataupun pengatur data relational dalam platform Java Standard Edition dan Java Enterprise Edition digunakan Java Persistence API. 4. JSF terbagi menjadi komponen model, view, dan controller dimana komponen controller bekerja di front end sedangkan komponen lain bekerja di back end.

6.2. SARAN

1. Kerjasama kelompok yang baik dan ketelitian dalam mengamati percobaan sangat diperlukan dalam praktikum. 2. Asisten sebaiknya terus memantau praktikan agar praktikum berjalan dengan lancar sesuai dengan prosedur yang semestinya.

74

DAFTAR PUSTAKA

1. Modul praktikum RSBK 2014 2. http://id.wikipedia.org 3. https://netbeans.org/features/java-on-server/

xi

LAMPIRAN I (LEMBAR ASISTENSI)

Student ID
First Name
Last Name
//memberi action pada tombol Add 40

Praktikum Rekayasa Software Berbasis Komponen

Recommend Documents

Welcome <%=session.getAttribute("loginName")%>

Error - <%=request.getAttribute("error")%>