TUGAS MATA KULIAH IF5131 ALGORITMA DAN PEMROGRAMAN

DOKUMEN ANALISA DAN KOMPARASI FRAMEWORKS STRUTS DAN SPRING

Oleh : 13508012 13508020 23510037 23510061 23510081 23511009 23511013 23511034 23511041 23511112 Anselimus Krisma Adi Kurniawan Muhammad Ghufron Ridho Reinanda Monterico Adrian Eko Adi Wicaksono Claudio Franciscus Rizfi Syarif Alif Finandhita Beny Setioko Yadhi Aditya Permana

SEKOLAH TEKNIK ELEKTRO DAN INFORMATIKA INSTITUT TEKNOLOGI BANDUNG 2012

DAFTAR ISI PENDAHULUAN ................................................................................................................................... 3 Framework ...................................................................................................................................... 3 Struts ............................................................................................................................................... 3 Spring .............................................................................................................................................. 9 DESAIN DALAM STUDI KASUS ........................................................................................................... 14 INISIALISASI DESAIN DALAM STUDI KASUS ....................................................................................... 15 Authenticate (log in) ..................................................................................................................... 16 Enter Assets ................................................................................................................................... 16 Edit Assets ..................................................................................................................................... 16 Delete Assets ................................................................................................................................. 16 Enter Assets Transactions ............................................................................................................. 17 Edit Assets Transactions ................................................................................................................ 17 Delete Assets Transactions............................................................................................................ 17 Calculate Current Values ............................................................................................................... 17 Navigate The Application .............................................................................................................. 17 Tabel Asset .................................................................................................................................... 17 Tabel Asset Transaction ................................................................................................................ 18 Class Diagram ............................................................................................................................... 18 STUDI KASUS : STRUTS ...................................................................................................................... 19 Instalasi ......................................................................................................................................... 19 Proses Desain ................................................................................................................................ 22 Proses Pengembangan .................................................................................................................. 23 Implementasi Aplikasi ................................................................................................................... 23 STUDI KASUS : SPRING ...................................................................................................................... 32 Instalasi ......................................................................................................................................... 32 Proses Desain ................................................................................................................................ 35 Proses Pengembangan .................................................................................................................. 36 Implementasi Aplikasi ................................................................................................................... 36 ANALISA DAN PERBANDINGAN STRUTS - SPRING ............................................................................ 45 Instalasi ......................................................................................................................................... 45 Desain............................................................................................................................................ 46 Pengembangan ............................................................................................................................. 46 Perbedaan Struts dan Spring Secara Umum ................................................................................. 48 KESIMPULAN ..................................................................................................................................... 49

PENDAHULUANFramework

Framework merupakan sekumpulan fungsi, class, dan aturan aturan yang mengatur secara menyeluruh bagaimana developer dalam membangun aplikasinya. Berbeda dengan library yang sifatnya hanya untuk tujuan tertentu saja. Framework memungkinkan aplikasi dapat dibangun dengan lebih cepat karena developer akan lebih fokus pada pokok permasalahan, sedangkan hal hal penunjang lain seperti mislkan GUI, security, koneksi database, validasi, dll umumnya telah disediakan oleh framework. Selain dari itu, dengan aturan aturan yang lebih jelas dan harus benar benar dipatuhi maka aplikasi yang dibuat pun akan menjadi lebih solid, terstruktur, dan kolaborasi dalam tim dapat lebih mudah dilaksanakan. Secara umum framework menggunakan struktur MVC (Model, View, Controller), terutama untuk framework dalam aplikasi web. MVC adalah sebuah metode untuk membuat aplikasi berbasis web dengan memisahkan data (model) dari tampilan (view) dan cara bagaimana memprosesnya (controller). MVC memisahkan pengembangan aplikasi berdasarkan komponen utama yang membangun sebuah aplikasi seperti manipulasi data, antarmuka pengguna, dan bagian yang menjadi kontrol dalam sebuah aplikasi. Bagian dari MVC : Model, mewakili struktur data. Biasanya model berisi fungsi fungsi yang membantu seseorang dalam pengelolaan basis data seperti input data, update data, dll. View, bagian yang mengatur tampilan ke pengguna (halaman web). Controller, bagian yang menjembatani model dan view. Controller berisi fungsi fungsi yang berguna untuk memproses suatu data.

Dengan menggunakan metode MVC maka aplikasi akan menjadi lebih mudah untuk dikembangkan dan dikelola. Untuk memahami metode pengembangan aplikasi menggunakan MVC diperlukan pengetahuan tentang Object Oriented Programming (OOP). Struts dan Spring merupakan aplikasi frameworks open source yang dapat dipakai untuk membangun aplikasi berbasis web dan sudah terintegrasi dengan standar teknologi servlet, java beans dan java server pages (JSP). Banyak sekali keuntungan yang didapat dengan menggunakan kedua frameworks tersebut dan sangat cocok untuk menerapkan konsep MVC di dalam pengembangan aplikasi berbasis web.Struts

Struts merupakan aplikasi framework open source yang didesain untuk membantu para developer dalam membangun arsitektur aplikasi berbasis pada Model-View-Controller (MVC) , dimana desain MVC sudah merupakan standar umum dalam membangun aplikasi Web dengan penggunaaan servlet Java dan Java Server Pages (JSP) sebagai teknologinya.

Framework struts dapat dipecahkan menjadi 3 area utama sesuai dengan konsep MVC : 1. Model Implementasi model pada struts berupa Action class, menyediakan business logic yang harus ditulis oleh developer. Interaksi antara controller dan class Action yang diprogram oleh developer akan berbasis pada sebuah file konfigurasi yang dapat dimodifikasi dengan mudah melalui file : struts-config.xml. 2. View View pada struts merupakan sekumpulan tag library dari JSP untuk memudahkan developer dalam membuat form secara cepat (form yang dibuat hampir sama dengan form yang biasa dibuat dengan menggunakan HTML). 3. Controller Controller pada struts merupakan sebuah servlet engine yang akan mentransfer semua request yang datang dari HTTP ke Action yang telah diset melalui file konfigurasi di atas (.xml). Sebelum bisa menggunakan struts, kontainer JSP yang ada harus di-setup terlebih dahulu, agar mengetahui bagaimana harus memforward semua request yang datang melalui HTTP ke ekstensi file yang sesuai ke controller pada struts. Ini bisa dilakukan lewat file web.xml yang dibaca pada saat sebuah kontainer JSP dijalankan. Controller merupakan bagian penting dalam framework ini, dimana semua traffic obyek model akan dimonitor oleh Controller. Controller juga bertugas melakukan packaging dan routing HTTP request ke obyek business logic yang benar (bisa berupa halaman JSP atau class Action). Controller merupakan representasi dari file web.xml yang merupakan file dalam bentuk instance dari org.apache.struts.action.ActionServlet. Ketika controller diinisialisasi maka controller ini akan membaca file konfigurasi (struts-config.xml) yang mendefinisikan mapping action untuk aplikasi yang dibuat. Controller menggunakan mapping action ini untuk menentukan langkah selanjutnya, dimana HTTP request akan dikirimkan (ditujukan ke class Action yang diimplementasikan). Kemudian class Action tersebut akan mengambil alih dan melakukan proses business logic sebagaimana yang diinginkan. Hal utama yang cukup penting untuk diketahui adalah bahwa obyek Action mempunyai akses ke method yang terdapat di dalam servlet engine. Model pada struts merupakan obyek yang akan menyimpan request dari pengguna selama proses berlangsung, biasanya implementasi berupa JavaBean. Obyek model biasanya bersifat spesifik terhadap aplikasi, karena implementasi dari business logic akan sangat tergantung kepada kepentingan tujuan dari aplikasi yang kita bangun. Struts menyediakan class ActionForm dan Action. Melalui kedua model ini lah, dimana sebuah validasi form berlangsung. struts-config.xml bisa dianggap sebagai tempat dimana developer menempelkan semua implementasi class Action, model menjadi satu. Semua aturan main, dan flow dari aplikasi yang dibangun berbasis struts ada di dalam file konfigurasi ini. Jika web.xml memberitahukan kontainer dimana sebuah request harus ditransfer setelah sampai ke kontainer, maka struts-

config.xml memberitahukan kepada kontainer apa yang harus dilakukan setelah mencapai layar ini. Dengan kata lain, controller mengatur request yang datang dan harus dikirim ke siapa request tersebut untuk diproses dan mapping Action diatur sedemikian rupa di dalam file struts-config.xml supaya controller tahu harus mengirimkan request ini kepada Action yang mana. Fleksibilitas dari framework ini akan mencegah developer melakukan hard coding. Berikut adalah gambar yang mendeskripsikan bagaimana framework struts bekerja di dalam aplikasi web :

Pada saat kontainer web mendeploy aplikasi, ActionServlet akan membaca file strutsconfig.xml yang berisi semua konfigurasi yang diperlukan untuk menjalankan sistem ini. Ketika ada request dari browser, langkah langkah berikut akan dijalankan : 1. Request data akan secara otomatis dibungkus ke dalam sebuah objek ActionForm. 2. ActionServlet akan mencari controller (Action class) yang sesuai dengan path yang di-request oleh browser. 3. Class Action memiliki satu method utama dengan nama execute, yang akan dijalankan untuk melayani request. Semua pemrosesan yang dibutuhkan seperti akses database, perhitungan, dan lain lain dijalankan di dalam method ini. Di sini objek model dimasukkan ke dalam variabel HTTP request atau HTTP session, yang selanjutnya akan dipanggil dari halaman JSP. 4. Setelah pemrosesan selesai, method execute tersebut akan mengembalikan return value yang akan menunjukkan status dari pemrosesan. 5. Selanjutnya, status dari class Action tersebut akan digunakan untuk menentukan halaman JSP mana yang akan ditampilkan. 6. JSP dievaluasi, objek model di-render kedalam halaman HTML, dan responnya dikirimkan ke browser. Bagaimana dengan struts2 yang saat ini populer digunakan? Struts2 bisa dikatan merupakan penggabungan dari framework struts dengan webwork yang terkenal sebagai solusi MVC yang paling mudah di dunia Java. Tim Apache Struts telah setuju untuk membuat webwork 2.3 menjadi Struts 2.0. Hal ini dilakukan karena Struts 1.x dianggap setelah ditinggal sang

pembuatnya ke JSF, teknologinya mandek, sedangkan webwork telah masuk ke teknologi berikutnya yang lebih modern. Gabungan kekuatan nama struts yang telah mendunia dan teknologi yang mengacu pada webwork yang sangat stabil dan mature, diharapkan dapat mencounter gerakan JSF. Tetapi saat ini yang terjadi, bukan JSF melawan webwork/struts yang terjadi, tetapi Don Brown, salah satu commiter webwork/struts2 telah berhasil membuat component development didalam webwork, sehingga struts2 sebenarnya adalah proyek integrasi webwork dengan JSF. Dengan kata lain struts2 memiliki struktur yang sama sekali berbeda dengan struts, lebih dekat dengan struktur yang dimiliki oleh webwork karena dibangun di atasnya dan sama sama berbasis Action. Berikut ini adalah fitur fitur yang dimiliki oleh struts2 yang membawa fitur fitur yang dimiliki oleh struts sebelumnya dan juga webwork : 1. 2. 3. 4. 5. Arsitektur sederhana Interceptors, Actions, Results dari pluggable ObjectFactory Berbasis Controller atau page-based navigation Mendukung POJO (Plain Old Java Object), Annotation, dan JSF (Java Server Face) Tag-tag yang dapat di-customize sendiri dengan dukungan dari OGNL (Object Graph Notation Language) 6. Value stack 7. Spring sebagai default inversion dari control container 8. Dapat dengan cepat digunakan (QuickStart) 9. Mendukung implementasi AJAX 10. Convention-over-configuration 11. Mudah dites (diluar container) 12. Memiliki seluruh keunggulan dari struts dan webwork2. Konsep MVC di dalam struts2 dapat digambarkan sebagai berikut :

1. Model Action Model adalah komponen utama di dalam domain logic karena sesungguhnya model adalah aplikasi itu sendiri. Di dalam pola MVC, model diimplementasikan dalam wujud Javabean (atau lebih sering cukup disebut bean). Implementasi model pada

struts2 pada prinsipnya sama dengan sruts, yaitu sama sama menggunakan Action class, hanya saja file konfigurasi disimpan dengan nama : struts.xml. 2. View Result View pada struts2 juga pada prinsipnya sama dengan struts, merupakan sekumpulan tag library dari JSP yang merupakan presentasi atau hasil dari action sesuatu yang ingin disajikan kepada presentation layer sebagai respon dari request yang diajukannya. 3. Controller Filter Dispatcher Pada struts2, controller diperankan oleh FilterDispatcher. FilterDispatcher adalah sebuah object penting yang berwujud servlet filter yang menginspeksi setiap request yang datang untuk menentukan action mana yang harus dilakukan. FilterDispatcher mempunyai fungsi yang sama dengan servlet engine pada struts. Berdasarkan konsep MVC yang diimplementasikan di struts2, arsitektur pada struts2 mengimplementasikan antara action (model), result (view), dan FilterDispatcher (controller) sesuai dengan fungsinya masing masing. Berikut ini adalah diagram dari arsitektur struts2 :

Komponen komponen yang terdapat di dalam struts2 yang menjadi backend hero dari framework ini adalah sebagai berikut : 1. FilterDispatcher FilterDispatcher adalah controller dari framework struts2 dan komponen pertama yang berperan dalam siklus pemrosesan request. Pada dasarnya komponen ini merupakan servlet filter yang memiliki tugas utama dan penting untuk memeriksa setiap request yang datang untuk menentukan action struts2 yang mana yang akan menangani request tersebut. 2. ActionMapper Komponen ini digunakan oleh FilterDispatcher untuk menentukan request yang mana yang membutuhkan action dan yang mana yang tidak. Ketika diberikan sebuah HttpServletRequest, ActionMapper akan mengembalikan nilai null jika tidak ada pemanggilan action request yang cocok, atau akan mengembalikan sebuah ActionMapping yang menjelaskan sebuah pemanggilan action untuk dicoba oleh framework. ActionMapping merupakan class yang menimpan informasi action mapping yang digunakan untuk memanggil struts action. 3. ActionProxy Jika ActionMapper menentukan sebuah action harus dipanggil untuk request tertentu, maka FilterDispatcher mendelegasikan control kepada ActionProxy. ActionProxy berkonsultasi dengan ConfigurationManager dan kemudian membuat sebuah ActionInvocation. 4. ConfigurationManager ConfigurationManager merupakan representasi dari obyek java untuk file struts.xml yang diisi pada saat awal aplikasi dan terdiri dari semua informasi mengenai konfigurasi framework. Antar muka dari ConfigurationProvider menjelaskan konfigurasi framework tersebut. Secara default, framework mengisi konfigurasinya melalui dokumen XML dengan menggunakan StrutsXmlConfigurationProvider. 5. Struts.xml Struts.xml merupakan file konfigurasi inti dari struts2, terdiri dari mapping yang didefinisikan oleh user untuk masing masing action, interceptor, result, dll. 6. ActionInvocation ActionInvocation bertanggungjawab untuk implementasi command pattern. Tanggung jawab tersebut meliputi pemanggilan setiap interceptor dalam memanggil action itu sendiri. Ketika action dikembalikan, ActionInvocation bertanggungjawab untuk mencari hasil yang seusai yang terasosiasi dengan kode Action result yang dimapping di struts.xml. Selanjutnya result tersebut dieksekusi dengan melibatkan template yang ditulis di dalam JSP atau FreeMaker untuk kemudian di-render.

7. Interceptor Interceptor dipanggil setelah atau sebelum action dieksekusi. Interceptor tidak harus selalu melakukan sesuatu ketika kedua hal tersebut terjadi, tapi interceptor memiliki kesempatan untuk melakukannya. Beberapa interceptor hanya akan bekerja sebelum action dieksekusi, dan beberapa interceptor lainnya akan bekerja setelah action dieksekusi. Hal yang terpenting adalah interceptor memperbolehkan task yang umum, cross-cutting untuk didefinisikan di dalam komponen yang clean dan reusable yang dapat disimpan terpisah dari kode action-nya (contoh kasus untuk validasi, file upload, logging, dll). Interceptor dapat digunakan secara bertumpuk (stacked) untuk melakukan action tunggal. 8. Action Merupakan model MVC yang diimplementasikan oleh komponen action pada struts2. Di dalam aplikasi untuk task yang spesifik, harus ada action tersendiri yang masing masing menangani task tersebut. Sebagai contoh misalkan pada skenario login untuk user. Skenario tersebut harus memiliki sebuah action yang bertanggungjawab untuk melakukan validasi keabsahan user dengan nilai yang terdapat di dalam database. Secara sederhana, action merupakan enkapsulasi dari pemanggilan business logic ke dalam unit kerja tunggal. 9. Result Result menerjemahkan state dari aplikasi ke dalam presentasi visual sebagai media bagi user untuk melakukan interaksi. Action-nya bertanggungjawab untuk memilih result yang mana yang akan menampilkan respon untuk request tersebut. Beberapa jenis result yang sering digunakan diantaranya adalah JSP, FreeMaker, Velocity, dll. 10. Template Template merupakan halaman view yang menampilkan respon terhadap user. 11. ObjectFactory Walaupun ObjectFactory tidak terlihat di dalam diagram di atas, namun merupakan salah satu class inti di dalam struts2. Semua obyek yang dibuat oleh framework diinstansiasikan oleh ObjectFactory. ObjectFctory menyediakan sarana untuk mengintegrasikan struts2 dengan kontainer IOC (Inversion of Control) seperti spring.Spring

Spring merupakan sebuah framework yang digunakan untuk membangun sebuah aplikasi Enterprise. Spring termasuk framework yang lightweight (ringan) untuk mendukung secara penuh dalam pengembangan aplikasi Enterprise siap pakai. Spring bersifat modular, sehingga kita dapat menggunakan bagian-bagian yang di butuhkan tanpa harus membawa sisanya. Developer dapat menggunakan wadah IOC (Inversion of Control) dalam mengembangkan aplikasi dengan Spring, dan dapat juga hanya menggunakan kode yang terintegrasi dengan Hibernate atau lapisan abstraksi JDBC.

Spring dapat digunakan untuk melakukan pengaturan deklarasi manajemen transaksi, remote access dengan menggunakan RMI (Remote Method Invocation) atau layanan web lainnya, fasilitas mailing, dan beragam opsi untuk pengaturan data ke database. Menawarkan fitur yang lengkap dari Framework MVC dan memungkinkan developer untuk mengintegrasikan Aspect Orriented Programming (AOP) secara transparan ke dalam aplikasi yang dibangun. Berikut ini adalah fitur fitur yang dimiliki oleh spring : 1. Transaction Management Spring menyediakan sebuah layer abstrak yang generik untuk manajemen transaksi, sehingga memudahkan para developer dalam melakukan manajemen transaksi. 2. JDBC Exception Handling Layer abstrak JDBC menawarkan exception yang bersifat hierarki sehingga memudahkan penanganan kesalahan. 3. Integration with Hibernate, JDO, and iBatis Spring menawarkan layanan integrasi terbaik dengan Hibernate, JDO (Java Data Objects) dan iBatas 4. AOP Framework Spring merupakan framework untuk Aspect Orriented Programming terbaik yang pernah ada. 5. MVC Framework Spring hadir dengan framework aplikasi web MVC, yang dibangun di atas inti Spring. Spring merupakan framework yang sangat fleksibel dalam pengaturan strategi antarmuka, dan mengakomodasi beberapa teknologi view seperti JSP, Velocity, Tiles, iText, dan POI. Spring merupakan framework dengan arsitektur berlapis yang terdiri dari tujuh modul yang sudah terdefinisi dengan baik. Sekumpulan modul pada spring dibangun di atas kontainer inti yang mendefinisikan bagaimana beans diciptakan, dikonfigurasikan dan dikelola. Gambaran tujuh modul yang merupakan arsitektur dari spring adalah sebagai berikut :

Masing masing modul (komponen) pada gambar di atas yang merupakan bagian dari framework spring dapat berdiri sendiri sesuai dengan fungsinya masing masing atau diimplementasikan secara bersama sama antara satu modul dengan modul yang lainnya. Fungsi dari masing masing komponen tersebut adalah sebagai berikut : 1. Spring AOP (Aspect Orriented Programming) Modul spring AOP mengintegrasikan fungsionalitas aspect-orriented programming secara langsung ke dalam framework spring melalui fitur manajemen konfigurasi yang dimilikinya. Developer dapat secara dengan mudah menggunakan AOP terhadap objek yang dikelola oleh spring. Modul ini menyediakan layanan manajemen transaksi untuk objek yang terdapat di aplikasi apapun yang berbasis springs. Dengan spring AOP developer dapat mengabungkan atau mendeklaratifkan manajemen transaksi kedalam aplikasi yang dibangun tanpa tergantung pada komponen EJB (Enterprise Java Bean). Dengan demikian, spring AOP memiliki fungsi sebagai berikut : Untuk menyediakan layanan Enterprise, terutama sebagai pengganti EJB. Layanan terpenting dalam layanan ini adalah untuk mendekralitf manajemen transaksi, yang telah disediakan dalam abstraksi transaksi spring. Untuk memungkinkan pengguna menerapkan AOP dalam penggunaan OOP di spring.

2. Spring ORM (Object Relational Mapping) Framework spring diisikan ke dalam beberapa framework ORM untuk menyediakan Object Relational tool yang meliputi JDO (Java Data Objects), Hibernate, dan iBatis SQL Maps. Semua tools ini sesuai dengan transaksi generik spring dan hierarki DAO exception. Spring ORM berhubungan dengan akses database dan menyediakan lapisan layer terintegrasi dengan tools ORM.

3. Spring Web Modul konteks web spring ini dibangun di atas modul konteks aplikasi (spring context), menyediakan konteks untuk aplikasi berbasis web. Sebagai hasilnya, framework spring menyediakan dukungan untuk integrasi dengan struts. Modul web ini juga memudahkan tugas tugas penanganan multi-part requests dan binding request parameters terhadap objek domain. 4. Spring DAO (Data Acess Object) Layer abstraksi JDBC DAO pada spring menawarkan hierarki eksepsi yang berarti untuk mengelola penanganan eksepsi dan pesan kesalahan yang dilemparkan oleh vendor database yang berbeda. Hierarki eksepsi ini menyederhanakan penanganan kesalahan dan sangat mengurangi jumlah kode eksepsi yang harus ditulis oleh developer, seperti misal dalam membuka dan menutup koneksi data. Eksepsi spring DAOs JDBC-oriented memenuhi hierarki eksepsi generik yang dimiliki oleh DAO. DAO mendukung standarisasi akses data yang menggunakan teknologi seperti JDBC, Hibernate dan JDO. 5. Spring Context Spring context merupakan file konfigurasi yang menyediakan informasi konteks ke framework spring. Modul ini menyertakan layanan enterprise seperti JNDI (Java Naming and Directory Interface), EJB (Enterprise Java Bean), e-mail, internalisasi, validasi, dan penjadwalan fungsionalitas. 6. Spring Web MVC Framework Framework MVC (Model-View-Controller) merupakan implementasi dari metode MVC yang memiliki fitur lengkap untuk membangun aplikasi web. Model framework ini sangat mudah untuk dikonfigurasi melalui strategi antarmuka dan mengakomodasi sejumlah teknologi view seperti JSP, Velocity, Tiles, iText, dan POI 7. Spring Core Container Kontainer inti spring ini menyediakan fungsionalitas esensial dari framework spring, merupakan komponen yang paling penting dalam framewrok ini. Komponen utama dari core container adalah BeanFactory, sebuah implementasi dari Factory pattern. BeanFactory menambahkan Inversion of Control (IOC) pattern untuk memisahkan antara konfigurasi aplikasi dan spesifikasi yang terkait di dalamnya dengana kode aplikasi yang sebenarnya. Seperti yang sudah dijelaskan di atas, Spring Web MVC merupakan bagian dari spring framework, sehingga masih memiliki sifat sifat yang sama dengan spring framework. Spring Web MVC memiliki cara kerja sebagai berikut : 1. DispatcherServlet Kerangka Spring Web Model-View-Controller (MVC) dirancang di sebuah DispatcherServlet. DispatcherServlet adalah suatu class di dalam Spring yang berfungsi untuk menangani permintaan yang didasarkan pada pengaturan di file

XML. Jadi, DispatcherServlet adalah class yang mengatur jalannya request dan output. Diagram di bawah ini menunjukkan bagaimana alur kerja dari DispatcherServlet, yang merupakan sebuah ekspresi dari pola FrontController.

DispatcherServlet di dalam file web.xml, yang di dalamnya juga ditambahkan URL Mapping yang akan ditangani oleh DispatcherServlet. 2. Mapping Request Merupakan konfigurasi dari Mapping Web App yang tersimpan di dalam file web.xml. 3. Spring IoC Container Selain DispatcherServlet dan Mapping request, di dalam web.xml juga terdapat letak Spring IoC Container. Spring IoC Container adalah jantung dari aplikasi spring, yaitu sebuah file konfigurasi untuk mengelola obyek obyek yang ada di dalam aplikasi. Spring IoC Container bisa menggunakan 2 cara, yaitu beans dan context. Untuk Spring Web MVC, setiap DispatcherServlet sebenarnya sudah memiliki WebApplicationContext sesuai dengan servlet-name yang di inisialisasi, yaitu -context.xml. Namun, dapat juga menggunakan nama lain, akan tetapi harus dituliskan pada file web.xml. Implementasi IOC pada Spring Web MVC adalah dengan menggunakan metode Annotation, merupakan kumpulan class dari org.springframework.web.bind.annotation yang diantaranya adalah : @CookieValue, @ExceptionHandler, @InitBinder, @Mapping, @ModelAttribute, @PathVariable, @RequestBody, @RequestHeader, @RequestMapping, @RequestParam, @ResponseBody, @ResponseStatus, @SessionAttributes, dll.

DESAIN DALAM STUDI KASUSCara terbaik untuk mengetahui perbedaan yang terdapat di dalam beberapa frameworks yang berbeda adalah dengan menggunakan setiap framework tersebut ketika akan mengimplementasikan suatu aplikasi nyata. Dalam praktiknya, tidak ada seorang pun yang memiliki waktu yang cukup untuk membuat suatu aplikasi dalam beberapa frameworks yang berbeda sekaligus. Ketika seorang developer mulai menggunakan satu framework tertentu dan mendedikasikan waktunya untuk mempelajari framework tersebut sampai dengan memiliki cukup kemampuan untuk membuat suatu contoh aplikasi, maka itu akan membuatnya lebih mudah untuk selanjutnya mengembangkan aplikasi dan dia akan mendapatkan banyak keuntungan dari apa yang sudah dia pelajari. Relatif sulit bagi developer untuk berpindah ke frameworks lain ketika dia sudah belajar dan menguasai frameworks tertentu. Namun demikian, untuk kepentingan ilmiah, dalam contoh kasus ini akan dilakukan analisa dan perbandingan terhadap beberapa frameworks, khususnya Strust dan Springs dengan mengimplementasikan aplikasi sederhana yang sama. Dengan membuat aplikasi yang sama dalam beberapa frameworks yang berbeda, bahkan untuk aplikasi yang sangat sederhana sekalipun sebagaimana yang terdapat di dalam contoh kasus ini, maka dapat diketahui perbedaan perbedaan dan bahkan mungkin kesamaan dari beberapa frameworks dalam mengimplementasikan aplikasi tersebut. Untuk melakukan analisis dan perbandingan terhadap beberapa frameworks yang berbeda (dalam hal ini Struts dan Springs), bisa dengan cara membuat aplikasi sederhana dengan bantuan frameworks tersebut. Dalam hal ini akan dilihat bagaimana contoh nyata dari permasalahan yang sama namun akan ditangani oleh kedua frameworks yang berbeda. Kedua frameworks tersebut akan dieksplorasi beberapa perbedaan detail dan juga kesamaan di dalam desain, pengembangan, dan proses deployment-nya. Dari proses analisa dan perbandingan ini akan diketahui bagaimana design pattern menjalankan perannya dan bagaimana frameworks memberikan struktur dan layanan terhadap aplikasi yang dibangun. Aplikasi yang dibuat memiliki fungsionalitas yang sama. Dari analisa dan perbandingan ini akan diketahui bagaimana kedua frameworks yang berbeda tersebut membantu proses implementasi aplikasi. Berikut ini adalah goal design dari studi kasus aplikasi ini : Aplikasi yang dibangun adalah aplikasi manajemen inventori aset (Asset Inventory Management) sederhana, yang didesain untuk menyimpan informasi mengenai berbagai macam perlengkapan dan aset yang dimiliki oleh perusahaan. Aplikasi ini memungkinkan input data, melihat informasi asset, dan transaksi terkait yang disimpan di dalam database relasional, serta mendukung login authentication dan basic internationalization. Aplikasi merupakan web-based (sesuai dengan frameworks yang digunakan), dapat diakses penuh melalui web browser standar tanpa adanya special client requirements. Menyediakan kemampuan untuk menyimpan dan merekam data aset di dalam database relasional. Aset dapat di-list dan dicari setidaknya dengan menggunakan nomor id atau deskripsinya. Aset juga dapat di-retrieve dan juga di-edit. Hanya memperbolehkan user yang sudah terotorisasi yang dapat menambahkan dan merubah semua data, mengimplementasikan skema otentifikasi dan otorisasi terhadap user untuk melakukan login ke aplikasi. Memperbolehkan proses entry untuk transaksi yang akan mempengaruhi status dan nilai dari masing masing aset.

Mempersiapkan nilai assets on demand yang berlaku saat itu. Menyediakan antarmuka standar untuk navigasi aplikasi dan mengakses setiap fitur yang ada di dalamnya.

Berikut ini adalah fitur fitur dari aplikasi manajemen inventori aset yang dinyatakan dalam bentuk diagram Use Case sederhana :

INISIALISASI DESAIN DALAM STUDI KASUSDalam prosesnya, spesifikasi dari sistem akan dibagi ke dalam tiga bagian, mulai dari service, komponen komponen dan subclassed objects yang spesifik akan diberikan oleh masing masing framework. Proses dekomposisi tersebut dilakukan terhadap contoh aplikasi dalam kasus ini Berikut ini adalah spesifikasi dari aplikasi manajemen inventori aset : Spesifikasi yang pertama, terdapat asset items di dalam aplikasi yang mengindikasikan sebuah objek atau data, dan entry dari items tersebut yang mengindikasikan sebuah action atau proses. Dengan demikian terdapat satu service yang dibutuhkan, yaitu service yang menyediakan proses entry terhadap informasi aset. Spesifikasi yang kedua, terdapat transaksi yang dilakukan terhadap aset, memiliki kapabilitas yang sama untuk melakukan entry. Dengan demikian proses ini juga

membutuhkan service untuk entry. Dari sini dapat terlihat bahwa service yang dibutuhkan memiliki kesamaan dengan service yang terdapat pada spesifikasi pertama hanya saja dilakukan pada sekumpulan data yang berbeda. Spesifikasi yang ketiga, terdapat detail tracking untuk entry dan update pada aset dan transaksinya, serta melibatkan keberadaan service otorisasi dan otentifikasi. Pengguna harus dapat mengidentifikasikan dirinya melalu mekanisme login dan memperoleh hak akses terhadap berbagai macam fitur yang terdapat di dalam aplikasi tersebut, fitur mana yang dapat diakses dan mana yang tidak dapat diakses oleh user.

Dari spesifikasi di atas dan juga ada kebutuhan dari aplikasi tersebut untuk dapat melakukan perhitungan terhadap nilai assets on demand yang berlaku pada saat itu, maka service yang dibutuhkan adalah sebagai berikut :Authenticate (log in)

Service ini menyiratkan penyimpanan persisten dari informasi user, untuk melakukan otentifikasi terhadap user : o User Component (Persistent) o Login Component (Action), untuk aksi loginEnter Assets

Service ini menyiratkan komponen aset sebagai sebuah objek persisten, dan aksi untuk entry aset : o Asset (Persistent) o Enter Asset (Action)Edit Assets

edit merupakan aksi tambahan tunggal yang harus dapat menentukan atau memilih aset yang akan diubah : o Asset (Persistent) o Edit Asset (Action)Delete Assets

Delete Assets merupakan aksi tambahan tunggal yang harus dapat menentukan atau memilih aset yang akan dihapus : o Asset (Persistent) o Delete Asset (Action)

Enter Assets Transactions

Service ini membutuhkan objek transaksi aset persisten, dan aksi untuk entry terhadap transaksi : o Asset Transaction (Persistent) o Enter Asset Transaction (Action)Edit Assets Transactions

Menambah komponen aksi baru yang memungkinkan proses perubahan terhadap Asset Transaction persisten yang sudah ada : o Edit Asset Transaction (Action)Delete Assets Transactions

Menambah komponen aksi baru yang memungkinkan proses penghapusan terhadap Asset Transaction persisten yang sudah ada : o Delete Asset Transaction (Action)Calculate Current Values

Mengasumsikan total dari nilai aset yang disimpan di dalam komponen persisten yang sama sebagai aset itu sendiri, service ini menyiratkan bahwa tidak ada elemen tambahan : o Calculate Current Values (Action)Navigate The Application

o Navigate (Action) Berikutnya adalah desain dari database yang digunakan untuk aplikasi manajemen inventori aset :Tabel Asset

Field AssetId Descrip

Type int(11)

Null Key PRI YES NULL

Default Extra NULL auto-increment

varchar(80) YES NULL

TotalValue Float

Tabel Asset Transaction

Field AssetId

Type int(11)

Null Key Default Extra PRI NULL PRI NULL NULL NULL

TrxDate datetime TrxType char(1) TrxValue FloatClass Diagram

Desain di atas kemudian diimplementasikan ke masing masing dari dua framework yang digunakan (Struts dan Springs), dan bisa dilihat bagaimana services dan komponen komponen yang ada di atas di-mapping ke masing masing framework sesuai dengan kapabilitas yang disediakannya.

STUDI KASUS : STRUTSInstalasi

Aplikasi Manajemen Inventori Aset dibuat dengan menggunakan framework struts di lingkungan NETBEANS IDE terbaru versi 7.0.1. Pada IDE tersebut struts menjadi satu paket default yang sudah terinstalasi seiring dengan instalasi IDE-nya (untuk struts 1.3.8), sehingga untuk menggunakannya cukup mudah dengan membuat project baru pada NETBEANS, memilih jenis aplikasi yang akan dikembangkan (Java Web) , mengatur konfigurasinya, dan memilih jenis framework yang akan digunakan dimana struts sudah ada di dalamnya. Berikut adalah langkah langkah untuk membuat aplikasi manajemen inventori aset dengan mengunakan framework struts di lingkungan NETBEANS IDE 7.0.1 : 1. Pilih menu File New Project (Ctrl + Shift + N)

2. Pilih kategori Java Web dengan proyeknya adalah Web Application

3. Konfigurasi nama proyek dan lokasi penyimpanannya

4. Pemilihan servlet engine dan versi Java EE (misalkan servlet yang digunakan adalah Tomcat 7.0 dan Java EE-nya adalah versi 6)

5. Pemilihan jenis framework yang digunakan

6. Struktur direktori proyek yang dibuat dengan menggunakan framework struts

Setelah proses konfigurasi di atas maka aplikasi struts sudah dapat digunakan. Namun demikian, jika di dalam IDE Java paket struts belum ada, maka paket framework tersebut harus diunduh terlebih dahulu kemudian diinstalasikan secara terpisah melalui IDE yang digunakan. Dalam contoh kasus ini, framework yang digunakan adalah struts2 dimana framework tersebut masih belum terintegrasi secara default dengan IDE NetBeans 7.0.1 yang digunakan untuk mengembangkan aplikasi. Cara mengintegrasikan plugin struts2 pada IDE NetBeans 7.0.1 adalah dengan membuka menu Tools Plugin, kemudian memilih tab Downloaded dan tekan tombol Add Plugins, dengan catatan bahwa plugin struts2 tersebut sudah di-download terlebih dahulu.Proses Desain

Unit dasar dari business logic di dalam struts adalah Action, oleh karenanya untuk menyertakan business logic tersebut ke dalam kasus ini maka sejumlah action dibutuhkan : Add Assets List Assets Update Asset Delete Asset Add Asset Transactions List Asset Transactions Update Asset Transactions

Delete Asset Transactions Calculate Asset Values

Untuk tampilan antarmuka user di dalam aplikasi struts ini menggunakan halaman JSP, oleh karenanya dibutuhkan setiap halaman untuk masing masing fungsi utama yang dihasilkan dari objek action. Halaman halaman ini terasosiasi dengan objek action yang sesuai sebagai bagian dari proses mapping, yang terdefinisi di dalam file konfigurasi struts.xml.Proses Pengembangan

Dalam proses pengembangan aplikasi akan disusun prioritas modul yang terkait. Dalan setiap modul terdapat dependensi dengan modul lain. Untuk mempermudahnya maka urutan pengembangannya adalah login, asset, transaksi dan kalkulasi asset. 1. Login Bagian ini didahulukan pembangunannya, karena setiap action yang lain meminta hak akses. Hanya pengguna yang telah terauthentifikasi yang bisa menggunakan fasilitas aplikasi. Tentunya data fisik sudah dibuat di database. Data yang dimasukkan oleh penguna akan dicocokkan dengan username dan password pada database. 2. Asset Data nama asset, penjelasan, dan jumlah dimasukkan pada fasilitas ini. Begitu pula jika ingin mengubah data-data asset yang sudah dimasukkan untuk diperbarui. 3. Transaksi Untuk menggunakan fasilitas transaksi, minimal data asset sudah dimasukkan terlebih dahulu. Ketika memasukkan data transaksi, action akan mengambil data asset yang telah dimasukkan terlebih dahulu. Hal tersebut sama juga untuk update, tetapi tidak pada fasilitas delete. Fasilitas delete akan menghapus transaksi saja, dan tidak tergantung pada data asset. 4. Kalkulasi Total Untuk bisa mendapatkan hasil dari kalkulasi total asset, maka harus ada data asset dan transaksi yang telah dimasukkan. Dari semua fasilitas yang ada, dibutuhkan satu halaman yang berisi menu (link) untuk setiap fasilitas.Implementasi Aplikasi

Hasil akhir dari aplikasi yang dibuat dengan menggunakan struts ini terdiri dari objek actions dan halaman JSP yang semuanya terhubung antara satu dengan yang lain oleh file konfigurasi struts.xml.

Data model untuk asset modelpublic class AssetModel { private private private private private private private private } Integer id; String date; String name; Integer num; Integer status; String descr; String username; String password;

Data model untuk transaction modelpublic class TrxModel { private private private private private private private private private private } Integer trxId; String date; Integer assetId; String assetName; Integer amount; Integer status; String descr; Integer userId; String username; String password;

Berikut adalah implementasi untuk masing-masing use case : Use case login :public String login(){ try { Connection con = ConnectionManager.getConnection(); PreparedStatement ps = con.prepareStatement("select * from user where Name=? and Password=?"); ps.setString(1, model.getUsername()); ps.setString(2, model.getPassword()); ResultSet result = ps.executeQuery(); if(result.next()){ Map session = ActionContext.getContext().getSession(); session.put("name", model.getUsername()); session.put("userid", result.getInt(1)); System.out.println("berhasil"); return "success_login"; } } catch (Exception e) { e.printStackTrace(); } return "failed_login"; }

Use case Add asset :public String addAsset(){ try { Connection con = ConnectionManager.getConnection(); PreparedStatement ps = con.prepareStatement("insert Descr=?, Num=?, Status=?"); ps.setString(1, model.getName()); into asset set Name=?,

ps.setString(2, model.getDescr()); ps.setInt(3, model.getNum()); ps.setInt(4, model.getStatus()); int result = ps.executeUpdate(); if(result > 0){ System.out.println("berhasil"); return "success_add"; } } catch (Exception e) { } return "failed_add"; }

Use case Update asset :public String updateAsset() { try { Connection con = ConnectionManager.getConnection(); PreparedStatement ps = con.prepareStatement("update where AssetId=?"); ps.setString(1, model.getName()); ps.setString(2, model.getDescr()); ps.setInt(3, model.getId()); int result = ps.executeUpdate(); if(result > 0){ System.out.println("berhasil"); return "success_update"; } } catch (Exception e) { } return "failed_update"; } asset set Name=?, Descr=?

Use case Delete asset :public String deleteAsset (String asset_id) { try { Connection con = ConnectionManager.getConnection(); PreparedStatement ps = con.prepareStatement("delete AssetId="+asset_id); int result = ps.executeUpdate(); if(result > 0){ System.out.println("delete asset berhasil"); return "success_delete"; } } catch (Exception e) { } return "failed_delete"; } from asset where

Use case Add asset transaction :public String addTrx() { try { Connection con = ConnectionManager.getConnection(); Map session = ActionContext.getContext().getSession(); PreparedStatement ps = con.prepareStatement("insert AssetId=?, date=?, Amount=?, Descr=?, UserId=?, Status=?"); ps.setInt(1, model.getAssetId()); ps.setString(2, model.getDate()); into transaction set

ps.setInt(3, model.getAmount()); ps.setString(4, model.getDescr()); ps.setString(5, session.get("userid").toString()); ps.setInt(6, model.getStatus()); int result = ps.executeUpdate(); if(result == 0){ System.out.println("gagal"); return "failed_trx_add"; } ps = con.prepareStatement("select Num from asset where AssetId=?"); ps.setInt(1, model.getAssetId()); int tNum = 0; ResultSet result2 = ps.executeQuery(); if(result2.next()){ tNum = result2.getInt(1); } else { System.out.println("gagal"); return "failed_trx_add"; } ps = con.prepareStatement("update asset set Num=? where AssetId=?"); ps.setInt(1, tNum + model.getAmount()); ps.setInt(2, model.getAssetId()); result = ps.executeUpdate(); if(result == 0){ System.out.println("gagal"); return "failed_trx_add"; } return "success_trx_add"; } catch (Exception e) { } return "failed_trx_add"; }

Use case Update asset transaction :public String updateTrx() { try { Connection con = ConnectionManager.getConnection(); Map session = ActionContext.getContext().getSession(); PreparedStatement ps = con.prepareStatement("select Amount from transaction where TransactionId=?"); ps.setInt(1, model.getTrxId()); int tAmount = 0; ResultSet result2 = ps.executeQuery(); if(result2.next()){ tAmount = result2.getInt(1); } else { System.out.println("gagal"); return "failed_trx_update"; } ps = con.prepareStatement("update transaction set AssetId=?, Amount=?, Descr=?, UserId=?, Status=?, date=? where TransactionId=?"); ps.setInt(1, model.getAssetid()); ps.setInt(2, model.getAmount()); ps.setString(3, model.getDescr()); ps.setString(4, session.get("userid").toString()); ps.setInt(5, model.getStatus()); ps.setString(6, model.getDate()); ps.setInt(7, model.getTrxId()); int result = ps.executeUpdate(); String s = ps.toString(); if(result == 0){ System.out.println("gagal"); return "failed_trx_update";

} ps = con.prepareStatement("select Num from asset where AssetId=?"); ps.setInt(1, model.getAssetId()); int tNum = 0; result2 = ps.executeQuery(); if(result2.next()){ tNum = result2.getInt(1); } else { System.out.println("gagal"); return "failed_trx_update"; } ps = con.prepareStatement("update asset set Num=? where AssetId=?"); ps.setInt(1, tNum - tAmount + model.getAmount()); ps.setInt(2, model.getAssetId()); result = ps.executeUpdate(); if(result == 0){ System.out.println("gagal"); return "failed_trx_update"; } return "success_trx_update"; } catch (Exception e) { } return "failed_trx_update"; }

Use case Delete asset transaction :public String deleteTrx (String trx_id) { try { Connection con = ConnectionManager.getConnection(); PreparedStatement ps = con.prepareStatement("select transaction where TransactionId=?"); ps.setInt(1, Integer.parseInt(trx_id)); int tAmount = 0; int tAssetId = 0; ResultSet result2 = ps.executeQuery(); if(result2.next()){ tAmount = result2.getInt(1); tAssetId = result2.getInt(2); } else { System.out.println("gagal"); return "failed_trx_delete"; } ps = con.prepareStatement("delete from transaction where TransactionId="+trx_id); int result = ps.executeUpdate(); if(result == 0){ System.out.println("gagal"); return "failed_trx_delete"; } ps = con.prepareStatement("select Num from asset where AssetId=?"); ps.setInt(1, tAssetId); int tNum = 0; result2 = ps.executeQuery(); if(result2.next()){ tNum = result2.getInt(1); } else { System.out.println("gagal"); return "failed_trx_delete"; } ps = con.prepareStatement("update asset set Num=? where AssetId=?"); ps.setInt(1, tNum - tAmount); ps.setInt(2, tAssetId); Amount,AssetId from

result = ps.executeUpdate(); if(result == 0){ System.out.println("gagal"); return "failed_trx_delete"; } return "success_trx_delete"; } catch (Exception e) { } return "failed_trx_delete"; }

Terdapat beberapa tampilan untuk view yaitu : Login, AssetList, AssetUpdate, TransactionList, TransactionUpdate. Berikut implementasi untuk masing-masing asset : Login Asset - Login Login

AssetList Tugas Alpro kel. 1 & 2 Goto List Transaction
Asset List ()

ID Name Amount Desc Action ${id} ${id} EditDelete

View Asset Update Update Asset Update Asset Goto List Asset

View Transaction List Tugas Alpro kel. 1 & 2 Goto List Asset
Transaction List () Transaction ID Asset Name (ID) Date Amount Description By Status Action () ${trxId} ${trxId} EditDelete

Transaction Update%-Document : UpdateTrxForm Created on : Nov 12, 2011, 7:51:57 PM Author : Clotaire --%> Update Transaction Update Transaction Goto List Transaction

STUDI KASUS : SPRINGInstalasi

Aplikasi Manajemen Inventori Aset dibuat dengan menggunakan framework spring di lingkungan NETBEANS IDE terbaru versi 7.0.1. Sama halnya dengan struts, pada IDE tersebut spring telah menjadi satu paket default yang sudah terinstalasi seiring dengan instalasi IDE-nya (spring 3.0), sehingga untuk menggunakannya cukup mudah dengan membuat project baru pada NETBEANS, memilih jenis aplikasi yang akan dikembangkan (Java Web) , mengatur konfigurasinya, dan memilih jenis framework yang akan digunakan dimana spring sudah ada di dalamnya. Berikut adalah langkah langkah untuk membuat aplikasi manajemen inventori aset dengan mengunakan framework spring di lingkungan NETBEANS IDE 7.0.1 : 1. Pilih menu File New Project (Ctrl + Shift + N)

2. Pilih kategori Java Web dengan proyeknya adalah Web Application

3. Konfigurasi nama proyek dan lokasi penyimpanannya

4. Pemilihan servlet engine dan versi Java EE (dalam contoh kasus spring ini servlet engine yang digunakan adalah Glassfissh Server 3.1 dan Java EE 6)

5. Pemilihan jenis framework yang digunakan (spring web MVC 3.0)

6. Struktur direktori proyek yang dibuat dengan menggunakan framework spring

Setelah proses konfigurasi di atas maka aplikasi spring sudah dapat digunakan. Namun demikian, jika di dalam IDE Java paket spring belum ada, maka paket framework tersebut harus diunduh terlebih dahulu kemudian diinstalasikan secara terpisah melalui IDE yang digunakan. Cara mengintegrasikan plugin spring pada IDE NetBeans 7.0.1 adalah dengan membuka menu Tools Plugin, kemudian memilih tab Downloaded dan tekan tombol Add Plugins, tapi dengan catatan bahwa plugin spring tersebut sudah di-download terlebih dahulu.Proses Desain

Unit dasar untuk business logic dan pemrosesan ada pada controller, jadi untuk memenuhi kebutuhan business logic untuk contoh aplikasi Asset, sejumlah objek controller diperlukan yaitu: Manajemen (CRUD) Asset Manajemen (CRUD) Asset Transaction User Login

Untuk antarmuka pengguna, Spring memakai halaman JSP. Tiap controller minimal harus diwakili oleh satu halaman JSP, dan satu controller dapat dipakai oleh lebih dari satu halaman JSP atau untuk beberapa aksi. Halaman ini berasosiasi dengan objek aksi yang sesuai dengan proses mapping-nya, yang dikonfigurasi di file dispatcher-servlet.xml.

Proses Pengembangan

Aplikasi Spring dimulai dengan halaman JSP, yang nanti berlanjut menjadi viewer untuk aksi yang akan dilakukan. Pertama adalah halaman login, lalu halaman utama, kemudian halaman daftar Asset, dan terakhir halaman daftar Asset Transaction. Untuk update dan entry baru Asset atau Asset Transaction digunakan halaman form yang sama, dan untuk list dan delete digunakan halaman yang sama. Dibuat juga halaman untuk konfirmasi aksi yang telah dilakukan. Setelah kerangka halaman JSP selesai dibuat, selanjutnya adalah membuat controller untuk empat fungsionalitas yang didefinisikan pada Proses Desain, dan mengasosiasikannya dengan viewer (halaman JSP bersangkutan untuk controller tersebut). Semua aksi CRUD yang dilakukan memanggil kueri SQL secara langsung, dengan memakai koneksi JDBC memakai JDBCTemplate yang dikonfigurasi di jdbc.properties dan applicationContext.xml. Terakhir adalah menyempurnakan kode pengasosiasian pada halaman JSP dengan controller yang menggunakannya (tagging), dan aplikasi siap dijalankan.Implementasi Aplikasi

Aplikasi yang dikembangkan terdiri dari kelas-kelas controller, model, dan view berupa halaman JSP. Kelas-kelas ini dibagi ke dalam tiga package (controller, model, dan service), serta satu direktori khusus untuk menyimpan view JSP. Konfigurasi aplikasi, terutama controller, memanfaatkan fitur annotation @MVC yang ada semenjak Spring 2.5. Pemanfaatan annotation ini memungkinkan pengembangan aplikasi Spring Web MVC dengan sesedikit mungkin konfigurasi XML. Konfigurasi Awal Dalam mengembangkan aplikasi studi kasus, pertama-tama dilakukan beberapa konfigurasi yang diperlukan. Dalam Spring framework, konfigurasi ini dilakukan dengan menambahkan deklarasi beans (komponen) yang sesuai pada file konfigurasi applicationContext.xml dan dispatcher-servlet.xml. Sebuah beans atau komponen adalah objek Java yang lifecycle-nya diatur oleh framework. Dalam studi kasus ini, konfigurasi yang dilakukan meliputi pengaktifan component-scanning, pengaktifan autowiring, dan pembuatan koneksi database. Agar konfigurasi lewat annotation terdeteksi oleh framework, harus dilakukan pengaturan auto-scanning pada file konfigurasi applicationContext.xml dan dispatcher-servlet.xml. Kita melakukan pengaturan dengan menambahkan tag context.component-scan dengan atribut base-package dari kelas-kelas yang ingin di-scan. Konfigurasi lain yang perlu dilakukan adalah mengaktifkan annotation @Autowired. Annotation @Autowired ini berfungsi menyatakan kepada Spring untuk melakukan dependency injection secara otomatis pada kelas yang sesuai. Annotation ini diaktifkan dengan menambahkan bean AutowiredAnnotationBeanPostProcessor pada applicationContext.xml. Koneksi database dibuat dengan mendeklarasikan beans DriverManagerDataSource. Konfigurasi applicationContext.xml yang dihasilkan adalah:

Controller Controller yang diimplementasikan merupakan freeform controller, memanfaatkan fitur @MVC dengan implementasi controller tanpa harus meng-extend suatu kelas controller abstrak atau meng-implement interface. Dalam implementasi sebuah controller, ada dua buah annotation yang sering digunakan yaitu @Controller dan @RequestMapping. Annotation @Controller disebutkan sebelum deklarasi kelas, dan menyatakan bahwa sebuah kelas merupakan controller. Dengan menyatakan sebuah kelas sebagai controller, kita mendaftarkan kepada framework bahwa kelas tersebut bertugas meng-handle sebuah request (diteruskan dari DispatcherServlet). Framework akan menyiapkan mapping untuk kelas tersebut, atau menggunakan mapping yang kita definisikan lewat annotation @RequestMapping. Annotation @RequestMapping akan memetakan request dalam bentuk potongan url, misalnya ListAssets.htm ke sebuah method/kelas. Pada saat user mengakses url tertentu, DispatcherServlet akan meneruskan request tersebut ke kelas controller yang diimplementasikan, dan menjalankan method yang sesuai. Annotation @RequestMapping ini memungkinkan didefinisikannya banyak handler method dalam sebuah kelas. Handling operasi sesungguhnya yang dilakukan akan memanfaatkan kelas-kelas lain yang diinject ke controller tersebut, misalnya JdbcTemplate untuk melakukan operasi langsung ke database. Berikut ini adalah sebuah contoh implementasi controller (LoginController.java):

Package controller; import java.util.Map; import javax.servlet.http.HttpSession; import model.User; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import service.UserManager;

/** * * @author Anselmus Krisma A K */ @Controller public class LoginController { @Autowired private UserManager userManager;

@RequestMapping(value = "login.htm") public String showLogin(Map model, HttpSession session) { if (session.getAttribute("user") != null) { return "redirect:home.htm"; } User user = new User(); model.put("user", user);

return "login";

}

@RequestMapping(value = "login.htm", method = RequestMethod.POST) public String processLogin(User user, Map model, HttpSession session) { user = (User) model.get("user"); if (!userManager.authUser(user)) { model.put("message","Invalid username or password."); return "login"; } session.setAttribute("user", userManager.getUserByUsername(user.getUsername())); return "redirect:home.htm"; }

@RequestMapping(value = "home.htm") public String loginSuccess(Map model, HttpSession session) { if (session.getAttribute("user") == null) { return "redirect:login.htm"; } model.put("user", session.getAttribute("user")); return "index"; }

@RequestMapping(value = "logout.htm") public String processLogout(HttpSession session) { if (session.getAttribute("user") == null) { return "redirect:login.htm"; } session.removeAttribute("user");

return "redirect:login.htm"; } }

Model & Koneksi Data Dalam Spring, model diimplementasikan sebagai kelas Java biasa POJO (Plain Old Java Object). Kelas POJO ini dapat dihubungkan lewat konfigurasi dengan komponen ORM (Object Relational Mapping), misalnya Hibernate. Dalam studi kasus yang diimplementasikan, operasi database yang dilakukan tidak menggunakan ORM, tetapi memanfaatkan library pengaksesan database JdbcTemplate yang disediakan oleh Spring. Kelas JdbcTemplate menyediakan abstraksi operasi database di atas library JDBC. Sebuah JdbcTemplate dideklarasikan sebagai beans dalam applicationContext.xml. Beans/komponen ini kemudian akan di-inject ke kelas lain yang memerlukan dengan menggunakan annotation @Autowired. Kelas POJO ini juga dapat digunakan sebagai form backing object/command object dari controller tertentu. Hal ini diperlukan karena dalam Spring Web MVC, sebuah form perlu dinisialisasi dengan form backing object. Form backing object ini akan diteruskan ke view untuk menampilkan data yang sesuai. Berikut ini contoh implementasi kelas (Asset.java):package model;

/** * * @author Ridho */ public class Asset { private int assetId; private String descrip; private float totalValue; public int getAssetId() { return assetId; } public void setAssetId(int assetId) {

this.assetId = assetId; } public String getDescrip() { return descrip; } public void setDescrip(String descrip) { this.descrip = descrip; } public float getTotalValue() { return totalValue; } public void setTotalValue(float value) { this.totalValue = value; }

View Spring merupakan framework yang sangat fleksibel dan dapat menggunakan berbagai jenis teknologi view, misalnya JSP dan Velocity. Dalam studi kasus ini, digunakan halaman JSP sebagai view. Sebuah controller akan menjalankan suatu proses dan melempar data yang sesuai ke view tertentu. Hubungan antara view yang disebutkan oleh controller dinyatakan dengan menggunakan beans InternalResourceViewResolver ke sebuah direktori tempat filefile JSP berada (dalam kasus ini /WEB-INF/jsp/). Nama view yang dinyatkaan oleh controller akan dihubungkan dengan file yang sesuai. Beans viewResolver ini dideklarasikan dalam dispatcher-servlet.xml. Untuk penyusunan presentasi, dalam file JSP kita dapat menggunakan berbagai jenis tag library, baik dari tag library standar yang ada, seperti JSTL dan tag library yang disediakan oleh Spring framework. Berikut ini contoh implementasi view (AssetForm.jsp): : Ridho

Asset Asset Description: Value: ${command.totalValue}

ANALISA DAN PERBANDINGAN STRUTS - SPRINGInstalasi

Struts : Struts tidak menyertakan server aplikasi di dalam paket instalasinya yang mungkin akan sedikit menyulitkan proses konfigurasinya nanti, tetapi walaupun demikian proses instalasinya sendiri relatif mudah dan cepat. Jika menggunakan NETBEANS sebagai IDE dalam mengembangkan aplikasi ini, terutama versi terbaru 7.0.1, maka proses konfigurasi akan jauh lebih mudah karena struts sudah terinstalasi satu paket dengan server aplikasinya di dalam NETBEANS. Pengembang cukup membuat proyek baru di NETBEANS dengan langkah langkah seperti yang sudah dijelaskan sebelumnya. Namun demikian, jika di dalam IDE Java paket struts belum ada, maka paket framework tersebut harus diunduh terlebih dahulu kemudian diinstalasikan secara terpisah melalui IDE yang digunakan. Dalam contoh kasus ini, framework yang digunakan adalah struts2 dimana framework tersebut masih belum terintegrasi secara default dengan IDE NetBeans 7.0.1 yang digunakan untuk mengembangkan aplikasi. Cara mengintegrasikan plugin struts2 pada IDE NetBeans 7.0.1 adalah dengan membuka menu Tools Plugin, kemudian memilih tab Downloaded dan tekan tombol Add Plugins, dengan catatan bahwa plugin struts2 tersebut sudah di-download terlebih dahulu.

Spring : Jika menggunakan NETBEANS sebagai IDE dalam mengembangkan aplikasi ini, terutama versi terbaru 7.0.1, sama halnya dengan struts, maka proses konfigurasi akan jauh lebih mudah karena spring juga sudah terinstalasi satu paket dengan server aplikasinya di dalam NETBEANS. Pengembang cukup membuat proyek baru di NETBEANS dengan langkah langkah seperti yang sudah dijelaskan sebelumnya. Namun demikian, jika di dalam IDE Java paket spring belum ada, maka paket framework tersebut harus diunduh terlebih dahulu kemudian diinstalasikan secara terpisah melalui IDE yang digunakan. Cara mengintegrasikan plugin spring pada IDE NetBeans 7.0.1 adalah dengan membuka menu Tools Plugin, kemudian memilih tab Downloaded dan tekan tombol Add Plugins, dengan catatan bahwa plugin spring tersebut sudah di-download terlebih dahulu.

Kebanyakan IDE Java saat ini sudah menyertakan kedua framework struts dan spring di dalamnya, sehingga proses instalasi dan konfigurasi akan jauh lebih mudah. Bahkan proses instalasi itu sendiri tidak perlu dilalui, tinggal melakukan konfigurasi. Namun demikian, bagaimana jika kedua frameworks ini belum terintegrasi dengan IDE-nya? Atau bagaimana jika ingin menambahkan frameworks lain ke IDE tersebut? Bagaimana proses instalasinya? Pada dasarnya proses instalasi frameworks di java relatif cepat dan mudah. Idealnya semua frameworks untuk pengembangan aplikasi web berbasis java memiliki dokumentasi yang jelas dalam setiap proses instalasinya, termasuk jika frameworks tersebut akan diinstalasikan di dalam IDE tertentu, maka selain dokumentasi dari frameworks-nya juga harus ada dokumentasi yang jelas dari IDE-nya.

Desain

Dengan semua frameworks yang ada, langkah pertama sebelum melakukan proses desain adalah memahami terlebih dahulu design pattern secara keseluruhan dan kapabilitas dari framework itu sendiri, kemudian permasalahan yang terdapat di dalam aplikasi harus didekomposisikan ke dalam bentuk logik dan objek persistennya, dan item item ini dimapping ke kapabilitas yang sesuai di dalam framework. Struts : Views dan Actions merupakan item utama yang ditemui di aplikasi yang dibangun oleh struts. View-nya berupa halaman JSP yang merupakan mekanisme view standar yang terdapat di dalam struts, dan item Action secara mudah ditentukan dari spesifikasi aslinya. Seperti dalam beberapa kasus lainnya, sangat mungkin untuk memperbaiki atau mengimprovisasi desain awal dengan menggabungkan beberapa fungsi, namun pada contoh kasus aplikasi sederhana ini proses optimasi tidak terlalu besar. Spring :

Gambar di atas menunjukkan arus kerja pada Spring Web MVC. Action pada Struts sama dengan Controller pada Spring, tetapi Controller merupakan interface sehingga setiap komponen dapat Controller dan hal ini dapat memberikan fleksibilitas tinggi bagi desainer untuk mendesain komponennya. Desain ini juga dapat meminimalisir coupling antara aplikasi dengan framework.Pengembangan

Proses coding agak sedikit berbeda untuk masing masing framework. Jumlah file yang harus ditangani dengan banyak varian, dan proses otomatisasi dalam men-generate aplikasi bervariasi secara signifikan dari satu frame ke frame lainnya. Sangat mudah untuk memulai membuat aplikasi dengan menggunakan framework, tapi bukan berarti proses secara keseluruhan dalam mengembangkan aplikasi dengan menggunakan framework ini akan

menjadi lebih mudah. Banyak faktor terkait dengan suksesnya pengembangan aplikasi dengan menggunakan framework. Namun demikian, yang paling penting dari penggunaan framework ini adalah kekuatannya untuk membuat aplikasi menjadi lebih fleksibel dan lebih mudah untuk di-maintain (maintenable). Struts : Pengembangan aplikasi di dalam struts dibantu oleh aplikasi default kosong yang disediakan oleh framework-nya, menyediakan struktur dasar dari aplikasi web yang siap untuk di-deploy, meliputi semua arsip .jar yang dibutuhkan, file definisi taglib, dan file konfigurasi untuk mengakses struts itu sendiri. Dimulai dari aplikasi kosong ini juga developer diberikan template yang dapat diikuti dan kemudian template tersebut diisi sesuai dengan business logic dan presentasi data yang dibutuhkan. Dalam pengembangan aplikasi dengan menggunakan struts terdapat tiga grup dasar dari file : o File JSP, yang menggunakan struts tags. File ini berupa halaman web yang ditempatkan di dalam direktori aplikasi web (web-application). o File sumber java (java source files) untuk objek Action yang dikompilasikan ke dalam file class yang terdapat di dalam direktori WEB-INF/clasess. o Dua form objek bean yang dibuat dan juga dikompilasi ke dalam direktori WEBINF/classes. File struts.xml menghubungkan file file dengan tipe yang berbeda, menentukan action yang mana yang akan dipanggil ketika URL tertentu dipanggil, dan file JSP yang mana yang akan digunakan oleh action tersebut untuk view-nya, bersamaan dengan penggunaan form bean-nya. Spring : Aplikasi Spring dimulai dengan halaman JSP, yang nanti berlanjut menjadi viewer untuk aksi yang akan dilakukan. Pertama adalah halaman login, lalu halaman utama, kemudian halaman daftar Asset, dan terakhir halaman daftar Asset Transaction. Untuk update dan entry baru Asset atau Asset Transaction digunakan halaman form yang sama, dan untuk list dan delete digunakan halaman yang sama. Dibuat juga halaman untuk konfirmasi aksi yang telah dilakukan. Setelah kerangka halaman JSP selesai dibuat, selanjutnya adalah membuat controller untuk empat fungsionalitas yang didefinisikan pada Proses Desain, dan mengasosiasikannya dengan viewer (halaman JSP bersangkutan untuk controller tersebut). Semua aksi CRUD yang dilakukan memanggil kueri SQL secara langsung, dengan memakai koneksi JDBC memakai JDBCTemplate yang dikonfigurasi di jdbc.properties dan applicationContext.xml. Terakhir adalah menyempurnakan kode pengasosiasian pada halaman JSP dengan controller yang menggunakannya (tagging), dan aplikasi siap dijalankan.

Perbedaan Struts dan Spring Secara Umum

Pembeda Ajax Support

Bookmarking dan URL Validation

Testability

Post and Redirect Internalizations Marketability of skills

Struts Spring Dojo built-in, plugin untuk Tidak ada library-nya, GWT, JSON menggunakan DWR dan Spring MVC Extra Mempunyai namespace, Mengizinkan control penuh sehingga menjadi mudah. terhadap URL Menggunakan OGNL untuk Dapat menggunakan ekspresi yang kuat, dimana Commons Validator, yang sisi client hanya bekerja saat merupakan sebuah solusi aturan tertentu pada Action yang mature. Dapat menggunakan mocks Dapat menggunakan mocks (EasyMock, jMock, Spring (EasyMock, jMock, Spring Mocks) Mocks) Membutuhkan solusi Dapat menambah sebuah tertentu. parameter pada redirect. Menggunakan Resource Menggunakan file terpisah Bundle per locale untuk setiap halaman/aksi Struts 1 masih banyak Menjadi lebih tertekan, tetapi digunakan dan dibutuhkan, kebanyakan dikarenakan oleh sedangkan Struts 2 masih fitur dari framework lain. sedikit digunakan.

KESIMPULANStruts memungkinkan masalah yang terdapat di dalam suatu aplikasi untuk secara mudah didekomposisikan ke dalam elemen individual, dan objek action dipetakan secara baik ke masing2 elemen elemen. Pengembangan aplikasi dapat dilakukan secara cepat dan fleksibel, dan sangat mudah untuk memahami mekanisme mekanisme yang harus digunakan di setiap tahapan proses. Salah satu kekuatan terbesar dari struts adalah sangat mudah untuk dipahami serta dapat diimplementasikan secara cepat, dan kekuatan ini terutama ditunjukkan di dalam aplikasi manajemen inventori aset yang sederhana ini. Hasil dari pengembangan aplikasi dengan Spring Web MVC : 1. Penggunaan annotation menyederhanakan pengembangan aplikasi dan mengurangi konfigurasi XML yang perlu dilakukan secara manual. Tidak semua beans perlu dideklarasikan secara eksplisit dalam file XML, semuanya dapat dilakukan dengan menambahkan annotation @Component atau @Controller. Adanya fitur autowiring mempermudah penggabungan dari beans-beans tersebut. 2. Dengan @MVC, controller yang dikembangkan sangat fleksibel (freeform controller). a. Controller tidak perlu extend dari suatu kelas dasar tertentu. b. Signature method yang dikembangkan dapat ditentukan sendiri untuk menginclude object-object global yang tersedia untuk akses sesuai kebutuhan, misalnya HttpSession, ModelMap. c. Sebuah controller dapat digunakan untuk menangani beberapa request. Method yang diinginkan ditentukan melalui @RequestMapping. d. Controller dapat mengembalikan nama view langsung sebagai String, atau langsung mengembalikan ModelAndView. 3. Domain model dapat digunakan kembali sebagai command object/form-backing object. 4. Teknologi view, handler mapping dapat dipilih sesuai kebutuhan. 5. Tersedianya berbagai class library dari SpringFramework yang sangat berguna, misalnya JdbcTemplate. Dapat dilihat bahwa Spring merupakan framework yang sangat fleksibel dan tidak memaksa penggunanya untuk melakukan sesuatu dengan satu cara saja. Spring memiliki sifat yang lebih low coupling daripada Struts.