Spring - JSP

by - 23.11

hampir 1 bulan ini..aku dan teman-teman aku di bikin pusing ama yang namanya tugas JSP

yaa..memang benar kalau salah aku baru ngerjain tugasnya mepet alias 1 minggu sebelum deadlinenya kaya gini

jadi hasil yang aku kumpulin juga rada gak memuaskan gitu..:3

#sumpah nyesel banget

awal niatnya sihh pembagian tugasnya mau di buat rata 1 kelompok..tapi hasilnya...yaa gitu lah

di bilang memuaskan yaa gak memuaskan banget dan kalau di bilang puas sihh

jujur gak puas banget

so let's begin teman..

soryy kalau mengecewakan... heheheh :D



SPRING Framework

*      Definisi Spring

Spring merupakan sebuah framework pengembangan aplikasi yang dikembangkan oleh Rod Johnson,muncul karena spesifikasi EJB yang memaksakan pengembangan komponen harus mengikuti aturan EJB agar dapat berjalan dalam aplikasi server SJAS dan Jboss. Dengan Spring, pengembangan komponen dapat dilakukan dengan teknik pemrograman yang lebih sederhana. Spring juga merupakan sebuah framework opensource Java,yang menjadikan mungkin menggunakan JavaBeans yang masih polos, dimana sebelumnya hanya mampu dilakukan oleh EJB. Keunggulan Spring sendiri adalah menawarkan kesederhanaan, kemudahan testing kode program, serta loose coupling.

*      Sejarah Spring

Spring merupakan open source framework yang diciptakan oleh Rod Johnshon, Pada akhir tahun 1996, Sun menerbitkan spesifikasi Java Beans 1.00A,spesifikasi ini menjelaskan tentang peraturan – peraturan coding java yang memperbolehkan suatu objek yang bisa menjadi komponen yang bisa dipakai berulang – ulang ke dalam suatu aplikasi java yang lebih kompleks.Selanjutnya pada tahun 1998, Sun kembali menerbitkan policiesnya tentang EJB(Enterprise Java Beans) yang merupakan elemen yang reusable namun dengan kelebihan – kelebihan seperti server side dan menyediakan banyak kemampuan untuk enterprise service. EJB dibuat tentunya untuk mempermudah para developer untuk membuat aplikasi enterprise, namun para developer merasa tidak demikian.EJB sulit dan sangat rumit sehingga justru membuat para developer justru kehilangan minat terhadap EJB ini.
      Untungnya sekarang pemrograman JAVA lebih berkembang, seperti adanya AOP(Aspect Oriented Programming) dan IoC(Inversion of Control) sehingga memberikan Java Beans kekuatan yang lebih, dibandingkan EJB yang sangat rumit.

*      Mengapa Spring?

JavaBeans sendiri adalah merupakan sebuah software berupa komponen model untuk Java.Spesifikasi ini mencakup berbagai aturan standar penulisan kode program dalam Java yang memungkinkan sebuah objek dalam Java dapat digunakan kembali ataupun dimodifikasi dengan mudah untuk dikembangkan menjadi objek yang lebih kompleks.Kelebihan EJB yang di terbitkan Sun tahun 1998 adalah mampu bekerja secara server-side dan menyediakan berbagai service untuk aplikasi enterprise namun gagal memenuhi tujuan utama JavaBeans yang dibuat atas dasar kemudahan dan kesederhanaan dalam pengembangan suatu aplikasi enterprise. Namun tak dapat dipungkiri bahwa kemampuan EJB dalam model pemrograman deklaratif telah sukses dalam menyederhanakan banyak aspek insfrastruktur pengembangan aplikasi seperti pada aspek transaksi dan security. Tetapi penggunaan EJB sendiri cukup rumit dalam berbagai hal.
      Kemudian ditemukan teknik baru dalam memanfaatkan JavaBeans, yaitu Injection of Control (IoC) dan Aspect-oriented Programming (AOP). Teknik ini mampu memaksimalkan JavaBeans dengan kekuatan  model pemrograman deklaratif EJB, tetapi dengan tanpa kerumitan kompleksitas EJB. Disinilah framework Spring bermula.
      Spring  menyadari bahwa EJB memang menyediakan service-service yang berharga untuk developers, namun hal itu sebanding dengan kompleksitas EJB untuk menyelesaikan tugas-tugas yang kompleks.Untuk itu,Spring mencoba untuk menjadi penyedia service seperti layaknya EJB dengan cara permograman model yang lebih sederhana. Dengan mengadopsi sebuah filosofi J2EE : “J2EE should be easy to use”,
Spring didesain dengan mengacu pada prinsip :

1.         Desain yang baik jauh lebih penting daripada teknologi yang dipakai,
2.         Loosely Coupled JavaBeans melalui interface adalah desain yang baik. Coupled dalam
             hal ini merupakan ketergantungan JavaBeans terhadap EJB,
3.         Kode program haruslah mudah di uji coba.

*      Keuntungan memakai Spring

1.         Termasuk framework yang lightweight (ringan) baik dari ukuran maupun kinerjanya.  Bentuk JAR-nya tidak lebih besar dari 1MB.

2.         Memiliki kemampuan Injection of Control yang mampu menjadikan objek lebih loose   coupling. Saat IoC aktif, objek secara pasif memberikan daftar objek yang tergantung terhadapnya juga objek apa saja yang dia butuhkan. Spring akan memberikan dependencies mereka saat inisialisasi secara otomatis.

3.         Aspect-oriented Programming, Spring juga memiliki kemampuan untuk memisahkan pengembangan antara aspek business logic dengan system service. Dengan ini objek dapat lebih berkonsentrasi untuk melakukan tugasnya, hanya melakukan business logic sesuai dengan tujuan dia dibuat. Objek-objek tersebut tidak perlu bertanggungjawab atas service-service system seperti logging ataupun mensupport transaksi.

4.         Container, Spring merupakan sebuah container yang dapat mengatur life cycle dari objek-objek aplikasi. Programmer dapat menentukan sendiri bagaimana beans-beans mereka dipakai, apakah hanya dibutuhkan satu inisialisasi beans ataupun menginisialisasi beans baru setiap satu dari mereka dibutuhkan. Semua bisa dilakukan dengan berdasarkan pada prototype yang dapat di konfigurasi.

5.         Framework, Spring memungkinkan programmer untuk lebih berkonsentrasi mengembangkan business logic dari objek-objek aplikasi mereka sementara Spring akan mensupport system service seperti manajemen transaksi, integrasi framework, dll. Semua ini memungkinkan untuk membuat aplikasi yang kompleks dari komponen-komponen yang sederhana

Untuk saat ini Spring mempunyai dua cara dalam memberikan Dependency Injection(DI):

Ø  Pembuat Injection, Dependency di berikan melalui constructor di kelas Spring pada saat Instansiasi kelas.

Ø  Memberikan Injection, Dengan method bean bersifat public.disini Spring Framework menggunakan method setter public untuk menyuntikkan Dependency.Dependency ini didefinisikan dalam file konfigurasi eksternal, yang diambil ke dalam application context spring ketika server web dimulai.Application context Spring adalah sebuah XML, sehingga dalam implementasinya memungkinkan dilakukan hubungan antara satu bean dengan bean lain didalamnya.Sayang sekali,belum ada editor untuk propertis didalam applicationContext, sehingga untuk melihat lebih jelas isi dari sebuah beans ini harus menggunakan XML Editor.

Spring Framework yang bertanggung jawab untuk instansiasi Spring bean dan Spring bean memanggil method setter dan menyuntikkan bean pada saat inisialisasi. Spring Framework menangani bean Dependency Injection melalui pengaturan setter-Getter.Spring di desain untuk menjadi sebuat titik integrasi back-end server dan mampu di pakai untuk java EE yang berbasis server-side seperti tomcat. Spring adalah solusi yang ideal untuk mengintegrasikan dengan RIA (Rich Internet Applications).

Gambar Spring Framework Arsitektur Modul :




*      Contoh Konfigurasi Framework SPRING
Contoh konfigurasi yang di buat kali ini adalah membalik isi String.
1. Buatlah project baru dengann nama misalnya “SimpleSpring”
2. Tambahkan library Spring Framework 2.5.6 (versi yang tersedia pada Netbeans 7.0)
3. Buat kelas baru dengan nama misal “ReverseString” didalam package “com.spring”.  Kemudian modifikasi kelas ReverseString dengan isi seperti berikut ini :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.spring;

/**
*
* @author vyoroppier
*/
public class ReverseString {

private StringBuilder builder;
private String teks;

public void setBuilder(StringBuilder builder) {
this.builder = builder;
}

public void setTeks(String teks) {
this.teks = teks;
}

public String getTeks() {
builder.append(teks);
return builder.reverse().toString();
}
}
4. Buat konfigurasi spring dengan nama “springcontext.xml” yang ditaruh didalam package “com.spring”, kemudian modifikasi isinya seperti berikut :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="stringBuilder" class="java.lang.StringBuilder"/>

    <bean id="reverseString" class="com.spring.ReverseString">
        <property name="builder" ref="stringBuilder"/>
        <property name="teks" value="Hello World"/>
    </bean>
</beans>
Jika diperhatikan pada konfigurasi springcontext tadi bahwa kita memberitahukan kepada spring bahwa ada kelas yang namanya “ReverseString” dengan property “builder” dan “teks”, dimana didalam kelas tersebut nantinya tidak perlu kita buatkan object baru dari kelas StringBuilder dan variabel teks karena nantinya spring yang akan mengisi kedua property ini. Property “builder” ini sendiri didalam konfigurasi spring di referensikan ke kelas java.lang.StringBuilder. Kemudian nama bean dari kelas ReverseString adalah “reverseString”.

5. Selajutnya kita buatkan kelas untuk mengakses spring tersebut misal dengan nama “Main”. Modifikasilah isinya seperti berikut ini :
package simplespring;

import com.spring.ReverseString;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
*
* @author vyoroppier
*/
public class Main {

public static void main(String[] args) {
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("com/spring/springcontext.xml");
ReverseString reverseString = (ReverseString) applicationContext.getBean("reverseString");
System.out.println(reverseString.getTeks());
}
}
Jika diperhatikan pada source code diatas, object dari kelas ReverseString tidak perlu dibuatkan karena spring yang sudah secara otomatis mengkonfigurasikan dan membuat object dari kelas tersebut. Dengan demikian keuntungan yang dimiliki adalah kita tidak perlu repot-repot membuat object untuk kelas yang dimaksud dan mengatur bagaimana object itu berperilaku misal hanya bisa dibuat sekali saja, kalo sudah ada ga usah dibuat lagi. Jika menggunakan coding konvensional panjang baris perintahnya, dengan spring sudah secara otomatis di manage.


*      Arsitektur spring framework

1.      Spring AOP
Salah satu komponen utama Spring adalah AOP framework, AOP framework digunakan untuk :
v  Untuk menyediakan layanan Enterprise, terutama sebagai pengganti EJB. Layanan    terpenting dalam layanan ini adalah untuk mendekralif manajemen transaksi, yang telah disediakan dalam abstraksi spring transaction.
v  Untuk memungkinkan pengguna dalam menerapkan AOP dalam penggunaan OOP.

2.      Spring ORM
Spring ORM berhubungan dengan akses database dan menyediakan lapisan layer terintegrasi dengan ORM yang populer termasuk JDO, Hibernate dan iBatis.

3.       Spring Web
Merupakan bagian dari modul pengembangan Web Spring termasuk Spring Web MVC.

4.       Spring DAO
DAO (Data Access Object) mendukung standarisasi akses data yang menggunakan teknologi seperti JDBC, Hibernate dan JDO.

5.       Spring Context
Paket ini didasari pada paket beans untuk menambah dukungan sumber pesan dan untuk pola desain Observer, dan kemampuan untuk mendapatkan sumber daya yang konsisten dengan menggunakan API.

6.       Spring Web MVC
Menyediakan implementasi MVC untuk aplikasi web.

7.      Spring Core
Paket Spring Core ini merupakan komponen paling penting dari Spring Framework. Komponen ini menyediakan fitur Dependency Injection. BeanFactory memisahkan dependensi seperti inisialisasi, pembentukan dan akses object dari logika program user.

*      FITUR FITUR dari spring framework

Ø  Transaction Management : Spring framework menyediakan sebuah layer abstrak yang generik untuk manajemen transaksi, sehingga memudahkan para developer dalam melakukan manajemen transaksi.
Ø  JDBC Exception Handling : layer abstrak JDBC menawarkan exception yang bersifat hierarki sehingga memudahkan penanganan error.
Ø  Integration with Hibernate, JDO, and iBatis : Spring menawarkan layanan integrasi terbaik dengan Hibernate, JDO dan iBatas
Ø  AOP Framework : Spring merupakan framework AOP Terbaik yang pernah ada.
Ø  MVC Framework : Spring hadir dengan framework aplikasi web MVC, yang dibangun di atas inti Spring. Spring merupakan framework yang sangat fleksibel dalam pengaturan strategi interface, dan mengakomodasi beberapa teknologi view seperti JSP, Velocity, Tiles, iText, dan POI.
Dalam skala Enterprise Application dikenal adanya konsep MVC (Modelling View Controller) yang mana konsep ini akan memisahkan proses pembangunan aplikasi kepada beberapa layer utama. Hal ini dilakukan untuk mencapai target “separation of concern”, dimana tiap layer memiliki fungsi yang berbeda-beda sehingga perlu dipisahkan. Dalam penerapannya, layer bisa dipisahkan menjadi 3 bagian utama :
  1. Presentation Layer
  2. Business Layer
  3. Data Access Layer
Dalam proses pembagian layer ini,programmer akan mengenal beberapa teknologi lagi selain Spring yang menjadi Core/ Inti dari semuanya. Sebelum pembahasan melebar, alasan kenapa harus “separation of concern”??, adalah sederhananya seperti contoh berikut :
Anda memiliki aplikasi Sistem Online KRS yang terdiri dari 3 modul utama yaitu Tambah data, Edit data dan delete data, dimana 3 modul utama dipisahkan menjadi 3 file utama yaitu AddKrs.jsp, EditKrs.jsp dan DeleteKrs.jsp. Dalam ketiga file ini,pastinya membutuhkan koneksi ke database,sehinggaakan membuat proses initiasialisasi database pada tiap file tersebut :
Pada file AddKrs.jsp, EditKrs.jsp dan DeleteKrs.jsp :
1
2
3
4
5
6
7
<%
 Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
 <strong>Connection</strong> conn = DriverManager.getConnection("jdbc:odbc:<DSN name>")
 %
<html>
...
</html>
Pada contoh diatas anda telah melakukan pelanggaran konsep MVC, dimana anda mencampuradukkan seluruh layer ke dalam satu layer saja. Sehingga yang terjadi adalah kita melakukan re-inisialisasi koneksi pada tempat yang terpisah-pisah (Scattering) , sehingga kode program terlihat sangat kusut dan “hard to maintain”/sulit untuk dirawat.
Ilustrasi sederhana diatas jika terus digunakan hingga menjadi aplikasi yang semi-enterprise bahkan enterprise bisa-bisa menjadi aplikasi yang sangat sulit untuk dilakukan proses maintenance bahkan merubah koneksi saja bisa melibatkan hampir seluruh file. Sehingga dibutuhkan konsep MVC dimana akan memisahkan perhatian kita dari tampilan/UI/Presentation layer hingga data akses.

Presentation Layer,dapat dikatakan sebagai layer terdepan yang bisa dilihat oleh user.Kita bisa menggunakan beberapa extension dan tag semacam html, jsp dan php namun pada akhirnya seluruh tampilan tetap saja akan di-render menjadi tag html, karena itulah yang hanya akan dibaca oleh browser kita.
Business Layer, pada layer ini akan menangani seluruh inputan dan permintaan dari presentation layer, dari logika add, delete, edit hingga list data semua diolah oleh layer ini. Dimana business layer terdiri dari “Front Controller” dan “End Controller”. Pada konteks java kita mengenalnya sebagai back bean (Istilah JSF) atau Form Action (istilah struts) untuk merepresentasi kode server yang akan menangani seluruh data yang masuk. Pada layer ini biasanya menggunakan POJO (Plain Old Java Object) yang akan melakukan aktivitas dari validasi data, konversi inputan hingga proses yang berkaitan langsung dengan sisi terdalam dari business layer (End Controller) itu sendiri, misalnya interaksi ke database, proses pengiriman message melalui JMS, proses setting time scheduler dan lain-lain.
Data Access Layer, Pada layer ini / layer terakhir akan berinteraksi langsung ke database aplikasi, dari membuat SQL query untuk insert,delete hingga select, keseluruhan yang berkenaan dengan pengaksesan data harus diolah pada layer ini. Layer ini pun memiliki beberapa teknologi turunan semacam ORM (Object Relational Mapping) , JPA atau JDO, 
 


Setelah kita memahami konsep “separation of concern” itu sendiri , lalu pada konsep munculnya Spring Framework adalah berfungsi untuk mengintegrasi seluruh modul yang akan kita gunakan ke dalam satu file konfigurasi saja, yang kita kenal dengan Application-Context.xml. File ini dibutuhkan untuk melakukan proses sentralisasi konfigurasi sehingga terawat dan tidak kusut, itu harfiahnya.
Rod Johnson dalam menjelaskan beberapa keunikan Spring menjelaskan diantaranya adalah  Spring secara bertahap melakukan integrasi,spring akan mengelola seluruh bisnis objek anda pada satu tempat saja, contonya penggunaan JDBC untuk koneksi database, Time Scheduler, JMS, DAO (Data Access Object) dan lain-lain).

Dengan adanya satu file konfigurasi yang mengelola keseluruhan objek, tiap class yang terkait dengan proses-proses semacam add , delete, insert dan lain-lain, cukup menginisialisasi objek yang telah di “boot” oleh spring tanpa perlu melakukan konfigurasi-konfigurasi lainnya pada saat digunakan.
Berikut potongan tampilan dari application-context.xml :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<beans>

  <bean id="myDataSource"
    class="org.apache.commons.dbcp.BasicDataSource"
    destroy-method="close">
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    <property name="url" value="jdbc:mysql://localhost:3306/mydb" />
    <property name="username" value="someone" />
  </bean>
….
<bean id="exampleDataAccessObject"
        class="example.ExampleDataAccessObject">
    <property name="dataSource" ref="myDataSource" />
  </bean>
….
</beans>
Tag diatas digunakan untuk melakukan inisialisasi database dengan id adalah myDataSource dan kita coba mendefinisikan satu objek data access yang menggunakan data source (exampleDataAccessObject), dimana property data source akan di-reference ke id myDataSource, lalu setelah konfigurasi ini di “bootstrap” diawal, setiap class yang ada pada tataran business layer dapat menggunakan objek ini cukup dengan melakukan set saja, contoh :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ExampleBusinessObject implements MyBusinessObject {

    private ExampleDataAccessObject dao;
    private int exampleParam;

    public void setDataAccessObject(ExampleDataAccessObject dao) {
        this.dao = dao;
    }

    public void setExampleParam(int exampleParam) {
        this.exampleParam = exampleParam;
    }

    public void myBusinessMethod() {
        // do stuff using dao
    }
}

  ini hasil makalah dari kelompok aku..semoga bermanfaat buat kalian semua yang emang butuh bantuan.. :)






10 februari 2014
@_putrikus (◕‿◕✿)

Share
Tweet
Pin
Share
Tags : , , , ,

You May Also Like

0 comments