Dian's Blog....

Awal cerita dimulai ketika dahulu kala saat saya membuat sebuah aplikasi berbasis swing dengan koneksi database menggunakan jdbc (purba banget yah...). Sebuah kasus muncul ketika saya harus menginisialisasikan setiap Object DataSource di setiap class yang membutuhkan pasokan koneksi ke database. Sebuah teknik yang sangat buruk baik secara penulisan kode yang berulang-ulang dan membuang banyak waktu, lebih buruk lagi pengaruhnya terhadap performa aplikasi karena koneksi ke database merupakan sebuah operasi yang mahal, tidak terbayangkan berapa banyak koneksi yang terjadi hanya untuk membuat satu buah CRUD saja. Singkat cerita setelah cari-cari (curi-curi), disitulah awal mula saya bertemu dengan sebuah istilah yang dinamakan Dependency Injection (DI) dan Inversion of Control (Ioc), nah loh dua buah istilah ternyata :p yaitu sebuah mekanisme dimana sebuah object diinisialisasikan 'sekali' dalam IoC container yang kemudian akan disuntikkan ke setiap class yang membutuhkannya, walaupun saat itu saya masih menggunakan cara manual untuk melakukan injeksi ke setiap class melalui constructor.

Akhir cerita masalah selesai hingga saya meneruskan sebuah project bernama BlueOxygen Postila (yang ini sudah pakai hibernate loh :D). Weeiiitt jangan pergi dulu, cerita masih belum selesai.

Babak satu tuntas, dan babak selanjutnya pun berjalan, dan memang benar, masalah barupun muncul ketika saya membuat aplikasi berbasis web menggunakan Struts2 sebagai controllernya. Teknik injeksi pada Postila sama sekali tidak berlaku pada aplikasi web. Dan lagi-lagi saya dipertemukan dengan teknologi yang bernama SpringFramework, sebuah IoC Container yang terpopuler saat itu (mungkin juga sampai saat ini :D).

"Hoaammmm ngantuk, kepanjangan ceritanya!!!" Wehe saya yakin semua yang baca pasti pada ngantuk...

Gak usah panjang lebar (tapi panjang buaaanget :p), saya mau sharing gimana cara melakukan injeksi pada Struts2 dengan menggunakan Spring sebagai IoC containernya. Disini saya mengambil contoh kasus DataSource dimana setiap... @#$@%#$^%$&%!!! Hehehe, kasusnya sama seperti di awal cerita.

Pertama saya menggunakan Struts versi 2.2.1 dan SpringFramework versi 3.0.1.

Berikut beberapa library yang dibutuhkan (belum pake maven :p)

Kemudian tambahkan baris berikut pada web.xml

  1: <?xml version="1.0" encoding="UTF-8"?>
  2: <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3: 	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  4: 	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  5: 	id="WebApp_ID" version="2.5">
  6: 
  7: 	<display-name>Struts2</display-name>
  8: 
  9: 	<filter>
 10: 		<filter-name>struts2</filter-name>
 11: 		<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
 12: 	</filter>
 13: 
 14: 	<filter-mapping>
 15: 		<filter-name>struts2</filter-name>
 16: 		<url-pattern>/*</url-pattern>
 17: 	</filter-mapping>
 18: 
 19: 	<!-- Spring Configuration -->
 20: 	<context-param>
 21: 		<param-name>contextConfigLocation</param-name>
 22: 		<param-value>classpath:applicationContext*.xml</param-value>
 23: 	</context-param>
 24: 
 25: 	<listener>
 26: 		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 27: 	</listener>
 28: 
 29: 	<welcome-file-list>
 30: 		<welcome-file>index.jsp</welcome-file>
 31: 	</welcome-file-list>
 32: </web-app>

Berikut konfigurasi jdbc connection pada applicationContext-jdbc yang diletakkan pada classpath. Saya menggunakan MySQL DB.

  1: <?xml version="1.0" encoding="UTF-8"?>
  2: <beans xmlns="http://www.springframework.org/schema/beans"
  3: 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4: 	xmlns:p="http://www.springframework.org/schema/p"
  5: 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  6: 		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  7: 
  8: 	<bean id="dataSource"
  9: 		class="org.springframework.jdbc.datasource.DriverManagerDataSource"
 10: 		p:driverClassName="com.mysql.jdbc.Driver" p:username="root"
 11: 		p:password="admin" p:url="jdbc:mysql://localhost:3306/test" />
 12: 
 13: </beans>
 14: 

Kemudian untuk memudahkan implementasi method buat sebuah interface untuk menerima datasource dari konfigurasi bean.

  1: package com.mervpolis.dwx.struts2spring.datasource;
  2: 
  3: import javax.sql.DataSource;
  4: 
  5: public interface DataSourceAware {
  6: 
  7: 	/**
  8: 	 * Action class yang mengimplementasikan method ini akan secara otomatis
  9: 	 * ter-inject oleh object yang telah diinisialisasi pada
 10: 	 * applicationContext-jdbc.xml. Nama method harus sama dengan id pada bean
 11: 	 * (jika id="datasource" maka nama method adalah setDatasource()) dengan
 12: 	 * parameter yang juga harus disesuaikan dengan class pada bean
 13: 	 * (org.springframework.jdbc.datasource.DriverManagerDataSource merupakan
 14: 	 * implementasi dari javax.sql.DataSource)
 15: 	 */
 16: 	void setDataSource(DataSource dataSource);
 17: 
 18: }
 19: 

Coding terus, terus coding... Berikut konfigurasi dari struts.xml

  1: <?xml version="1.0" encoding="UTF-8" ?>
  2: 
  3: <!DOCTYPE struts PUBLIC
  4:     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  5:     "http://struts.apache.org/dtds/struts-2.0.dtd">
  6: 
  7: <struts>
  8: 	<constant name="struts.enable.DynamicMethodInvocation" value="false" />
  9: 	<constant name="struts.devMode" value="false" />
 10: 	<constant name="struts.convention.action.suffix" value="Controller" />
 11: 	<constant name="struts.convention.default.parent.package" value="struts-default" />
 12: 	<constant name="struts.convention.package.locators" value="action" />
 13: </struts>

Terakhir buat Action Classnya...

  1: package com.mervpolis.dwx.struts2spring.action;
  2: 
  3: import java.sql.Connection;
  4: import java.sql.ResultSet;
  5: import java.util.ArrayList;
  6: import java.util.HashMap;
  7: import java.util.List;
  8: import java.util.Map;
  9: 
 10: import javax.sql.DataSource;
 11: 
 12: import org.apache.struts2.convention.annotation.Action;
 13: import org.apache.struts2.convention.annotation.Result;
 14: import org.apache.struts2.convention.annotation.Results;
 15: 
 16: import com.mervpolis.dwx.struts2spring.datasource.DataSourceAware;
 17: import com.opensymphony.xwork2.ActionSupport;
 18: 
 19: @Results({ @Result(name = ActionSupport.SUCCESS, type = "velocity", location = "/view/item/item_list.vm") })
 20: public class ItemController extends ActionSupport implements DataSourceAware {
 21: 
 22: 	private DataSource dataSource;
 23: 	private List result = new ArrayList();
 24: 
 25: 	@Action("/item/show")
 26: 	public String show() throws Exception {
 27: 		if (dataSource == null) {
 28: 			addActionError("Gagal menyuntik datasource");
 29: 		} else {
 30: 			Connection connection = dataSource.getConnection();
 31: 			ResultSet resultSet = connection.prepareStatement(
 32: 					"SELECT * FROM item").executeQuery();
 33: 			while (resultSet.next()) {
 34: 				Map data = new HashMap();
 35: 				data.put("name", resultSet.getString("name"));
 36: 				data.put("price", resultSet.getString("price"));
 37: 				result.add(data);
 38: 			}
 39: 		}
 40: 
 41: 		return SUCCESS;
 42: 	}
 43: 
 44: 	public List getResult() {
 45: 		return result;
 46: 	}
 47: 
 48: 	/**
 49: 	 * Nah method inilah yang nantinya secara otomatis akan disuntik oleh si spring
 50: 	 */
 51: 	public void setDataSource(DataSource dataSource) {
 52: 		this.dataSource = dataSource;
 53: 	}
 54: }
 55: 

Eits ternya ada satu lagi yang ketinggalan... Jangan lupa buat viewernya juga... (classpath:/vew/item/item_list.vm)

  1: #foreach($error in $actionErrors)
  2: 	$error
  3: #end
  4: 
  5: $!result

Dan akhirnya selesai juga :D coba jalankan, mungkin terkesan ajaib dimana  DataSource tiba-tiba telah terinisialisasi dan aplikasipun berjalan seperti pada normalnya dan disinilah menurut saya kecanggihan dari Spring.

  Akhir-akhir ini saya masih sangat interest nih sama controller yang satu ini. Walaupun banyak orang bilang sekarang lagi hot-hotnya SpringMVC dan Struts merupakan teknologi jaman purba, but hey!! Ini Struts2 yang banyak orang menganggapnya sama dengan Struts(saja), walaupun sebenarnya saya juga belum pernah coba Struts 1 heuheuheu... Tapi biarin aja lah, yang jelas saya masih tetep mau bahas tentang Struts2 ini.

  Salah satu alasan yang bikin saya cinta Struts2 adalah plugin-nya yang cukup banyak yang sampai sekarang 'belum' saya temukan hal serupa pada SpringMVC. Nah karena hal itu kali ini saya mau kasih kabar nih kalau Struts2 ternyata punya versi anotasi untuk menggantikan mappernya yang berbentuk XML (saya juga baru tahu nih :hammer. Kasus ini mirip seperti antara Hibernate Core dengan Hibernate Annotation yang sebenarnya fungsinya sama, hanya berbeda dalam bentuknya saja.

  Langkah awal bagaimana program Struts2 dapat mengenali anotasi adalah dengan menambahkan library struts2-convention-plugin-2xx.jar pada classpath. File ini sudah satu paket dengan struts-core saat kita download library Struts2 (saya menggunakan versi 2.1.6.1).

  Nah untuk mempermudah pemahaman (baca: biar saya gak capek ngetik :p), saya akan membandingkan versi anotasi dengan postingan saya sebelumnya yang masih menggunakan XML.

  Mari memulai membatiknya (baca: coding).

Pertama rubah settingan struts.xml menjadi seperti berikut :

  1: <!DOCTYPE struts PUBLIC
  2:         "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  3:         "http://struts.apache.org/dtds/struts-2.0.dtd">
  4: 
  5: <struts>
  6: 	<constant name="struts.enable.DynamicMethodInvocation" value="false" />
  7: 	<constant name="struts.devMode" value="false" />
  8: 	<!-- default path untuk viewer -->
  9: 	<constant name="struts.convention.result.path" value="/pages" />
 10: 	<!-- struts akan secara otomatis mengenali class yang berakhiran 
 11: 		Controller sebagai Action Class -->
 12: 	<constant name="struts.convention.action.suffix" value="Controller" />
 13: 	<constant name="struts.convention.default.parent.package"
 14: 		value="struts-default" />
 15: </struts>

Suffix bersifat opsional, jika baris tersebut tidak ditulis maka secara default struts akan mengenali class yang berakhiran *Action sebagai action class. Kemudian result path berfungsi untuk setting dimana folder viewer diletakkan (secara default result path /WEB-INF/content/).

Sekarang mari kita bandingkan versi XML dengan Annotation

Berikut contoh versi XML-nya, lihat

  1: 	<package name="default" extends="struts-default" namespace="/cobastruts">
  2: 		<action name="HelloVelocity" class="com.mervpolis.struts.HelloWorldAction">
  3: 			<result name="success" type="velocity">/page/hello.vm</result>
  4: 		</action>
  5: 		<action name="HelloJSP" class="com.mervpolis.struts.HelloWorldAction">
  6: 			<result name="success">/page/hello.jsp</result>
  7: 		</action>
  8: 	</package>

Dan berikut ini versi Anotasinya

  1: package com.mervpolis.struts;
  2: 
  3: import java.sql.Timestamp;
  4: 
  5: import org.apache.struts2.convention.annotation.Action;
  6: import org.apache.struts2.convention.annotation.Actions;
  7: import org.apache.struts2.convention.annotation.Namespace;
  8: import org.apache.struts2.convention.annotation.Result;
  9: 
 10: import com.opensymphony.xwork2.ActionSupport;
 11: 
 12: @Namespace("/cobastruts"
 13: @Actions( {
 14: 		@Action(value = "HelloVelocity", results = { @Result(name = ActionSupport.SUCCESS, type = "velocity", location = "hello.vm" }),
 15: 		@Action(value = "HelloJSP", results = { @Result(name = ActionSupport.SUCCESS, location = "hello.jsp" }) })
 16: public class HelloWorldController extends ActionSupport {
 17: 	private String pesan;
 18: 	private String waktu;
 19: 
 20: 	public String execute() {
 21: 
 22: 		pesan = "HELLO WORLD....!!! Method execute telah dijalankan....";
 23: 		waktu = new Timestamp(System.currentTimeMillis()).toString();
 24: 
 25: 		return SUCCESS;
 26: 	}
 27: 
 28: 	public void setPesan(String pesan) {
 29: 		this.pesan = pesan;
 30: 	}
 31: 
 32: 	public String getPesan() {
 33: 		return pesan;
 34: 	}
 35: 
 36: 	public void setWaktu(String waktu) {
 37: 		this.waktu = waktu;
 38: 	}
 39: 
 40: 	public String getWaktu() {
 41: 		return waktu;
 42: 	}
 43: 
 44: }

Bagaimana? Menurut saya sih annotation lebih efisien daripada XML. Masih berpikir Struts2 susah? Cobain dulu... ^_^

Woho, baru kemaren saya coba bikin aplikasi Android sederhana dengan sedikit bimbingan dari temen :D Ternyata tidak terlalu sulit membuat sebuah tampilan aplikasi sederhana untuk Android ini, apalagi team dari Android ini juga sudah menyediakan tools yang dapat membantu kita dalam membangun application UI. Tools trsebut adalah ADT (Android Development Tools) yang merupakan plugin untuk Eclipse. Tetapi kali ini saya tidak akan membahas tentang bagaimana membuat aplikasi dengan GUI designer tersebut. Mengapa? Karena jika kita menggunakan GUI designer-nya android maka tools akan meng-generate kode dalam bentuk XML yang baru kemudian di-mapping ke dalam kode Java. Jadi? Ya ya ya, saya akan meberi sedikit contoh bagaimana membuat aplikasi Android sederhana dengan menggunakan kode Java secara menyeluruh, lalu kita bandingkan kode tersebut dengan aplikasi berbasis Swing yang saya buat setelahnya.

Pertama download Android SDK dan ADT di sini beserta cara instalasinya.

Buat Android Project Baru, kemudian isikan Project Name, Package Name dan Activity Name-nya.

Berikut baris kodenya :

package com.mervpolis.dwx.android;
 
import android.app.Activity;
import android.app.AlertDialog;
import android.os.Bundle;
import android.view.Gravity;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TableLayout;
import android.widget.TableRow;
import android.widget.TextView;
 
public class Main extends Activity {
	private Button btnSubmit;
	private TextView lblAlamat;
	private TextView lblNama;
	private TableRow row1;
	private TableRow row2;
	private TableRow row3;
	private TableLayout tableLayout;
	private EditText txtAlamat;
	private EditText txtNama;
 
	private void initComponents() {
		tableLayout = new TableLayout(this);
		setContentView(tableLayout);
		{
			row1 = new TableRow(this);
			tableLayout.addView(row1);
			{
				lblNama = new TextView(this);
				lblNama.setText("Nama";
				lblNama.setWidth(100);
				row1.addView(lblNama);
			}
			{
				txtNama = new EditText(this);
				txtNama.setSingleLine();
				txtNama.setWidth(150);
				row1.addView(txtNama);
			}
		}
		{
			row2 = new TableRow(this);
			tableLayout.addView(row2);
			{
				lblAlamat = new TextView(this);
				lblAlamat.setText("Alamat";
				row2.addView(lblAlamat);
			}
			{
				txtAlamat = new EditText(this);
				row2.addView(txtAlamat);
			}
		}
		{
			row3 = new TableRow(this);
			row3.setGravity(Gravity.CENTER);
			tableLayout.addView(row3);
			{
				btnSubmit = new Button(this);
				btnSubmit.setText("Save";
				btnSubmit.setOnClickListener(new OnClickListener() {
					@Override
					public void onClick(View v) {
						btnSubmitOnclick(v);
					}
				});
				row3.addView(btnSubmit);
			}
		}
	}
 
	private void btnSubmitOnclick(View v) {
		AlertDialog d = new AlertDialog.Builder(this).create();
		d.setMessage("Nama : " + txtNama.getText() + " \nAlamat : "
				+ txtAlamat.getText());
		d.setCanceledOnTouchOutside(true);
		d.show();
	}
 
	/*
	 * Main method-nya di sini!
	 */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
 
		initComponents();
	}
}
 

Kemudian bandingkan dengan kode berikut :

package com.mervpolis.dwx.swing;
 
import java.awt.GridLayout;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
 
public class Main extends JFrame {
 
	private JButton btnSubmit;
	private JLabel lblAlamat;
	private JLabel lblNama;
	private JPanel row1;
	private JPanel row2;
	private JPanel row3;
	private JPanel tableLayout;
	private JTextField txtAlamat;
	private JTextField txtNama;
 
	private void initComponents() {
		tableLayout = new JPanel();
		tableLayout.setLayout(new GridLayout(0, 1));
		setContentPane(tableLayout);
		{
			row1 = new JPanel();
			tableLayout.add(row1);
			{
				lblNama = new JLabel();
				lblNama.setText("Nama    ";
				row1.add(lblNama);
			}
			{
				txtNama = new JTextField();
				txtNama.setColumns(10);
				row1.add(txtNama);
			}
		}
		{
			row2 = new JPanel();
			tableLayout.add(row2);
			{
				lblAlamat = new JLabel();
				lblAlamat.setText("Alamat  ";
				row2.add(lblAlamat);
			}
			{
				txtAlamat = new JTextField();
				txtAlamat.setColumns(10);
				row2.add(txtAlamat);
			}
		}
		{
			row3 = new JPanel();
			tableLayout.add(row3);
			{
				btnSubmit = new JButton();
				btnSubmit.setText("Save";
				btnSubmit.addMouseListener(new MouseAdapter() {
					@Override
					public void mouseClicked(MouseEvent e) {
						btnSubmitMouseClicked(e);
					}
				});
				row3.add(btnSubmit);
			}
		}
 
		pack();
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		setVisible(true);
	}
 
	private void btnSubmitMouseClicked(MouseEvent e) {
		JOptionPane.showMessageDialog(this, "Nama : " + txtNama.getText()
				+ " \nAlamat : " + txtAlamat.getText());
	}
 
	public static void main(String a[]) {
		new Main().initComponents();
	}
 
}
 

Kemudian jalankan keduanya kode yang paling atas akan menghasilkan tampilan seperti berikut :

Sedangkan kode dibawahnya akan menghasilkan :

Fiuh, akhirnya selesai juga :D Amati kedua-duanya, tidak jauh berbeda bukan baris kodenya? Dan menariknya keduanya menghasilkan tampilan yang hampir sama, hanya saja perbedaannya program pertama berjalan pada Android, sedangkan program kedua berjalan pada komputer desktop. Selamat mencoba...

Special thanks to Dias.

Saya masih tertarik nih dengan model aplikasi MVC, kali ini saya akan membahas sedikit tentang Controller pada aplikasi Java Web yang dikenal merupakan solusi MVC paling mudah yaitu Struts2. Tapi ada yang tau apa itu Controller? Nih saya copas dari modul JENI :P ?Controller merupakan sebuah layer yang bekerja untuk mengurusi urusan antar layer, yang artinya bertanggung jawab terhadap eksekusi aplikasi.? Sedangkan untuk masalah Viewer Layer saya menggunakan Velocity yang saya rasa juga lebih mudah dibandingkan dengan JSP.

Langsusng saja dari pada bingung apa maksudnya mending kita langsung terjun ke lapangan. Untuk memulai membuat project pertama buka IDE anda :D dalam kasus kali ini saya menggunakan Eclipse IDE. Eits, jangan lupa untuk mendownload library, bagi anda yang belum mempunyai library Struts2 dan Velocity silakan download di sini.

Nah mari menuju medan perang!

Pertama buat project baru.

Untuk Eclipse silakan klik ?File ? New ? Other ? Web ? Dynamic Web Project? Maka otomatis akan langsung terbentuk folder src dan WebContent. Copy semua library yang sudah didownload ke dalam folder WebContent/WEB-INF/lib maka library tersebut akan langsung dikenali sebagai Web App Libraries.

Nah setelah semua library siap langkah pertama untuk membuat sebuah aplikasi Struts2 adalah dengan mengkonfigurasi web.xml yang terdapat pada folder WebContent/WEB-INF.

Berikut konfigurasi yang harus ditambahkan pada web.xml :

  1: <?xml version="1.0" encoding="UTF-8"?>
  2: <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  3:   <display-name>Struts2</display-name>
  4:   <filter>
  5:     <filter-name>struts2</filter-name>
  6:     <filter-class>org.apache.struts2.dispatcher.ng.filter. StrutsPrepareAndExecuteFilter</filter-class>
  7:   </filter>
  8:   <filter-mapping>
  9:     <filter-name>struts2</filter-name>
 10:     <url-pattern>/*</url-pattern>
 11:   </filter-mapping>
 12:   <welcome-file-list>
 13:     <welcome-file>index.jsp</welcome-file>
 14:   </welcome-file-list>
 15: </web-app>

Selanjutnya kita buat class action dari Struts2, action ini adalah class yang fungsinya tidak jauh berbeda dengan class POJO yaitu menampung properti-properti yang akan dikenal pada presentation layer MVC yang mengimplementasikan action pada Struts2.

Berikut contohnya :

  1: package com.mervpolis.struts;
  2: 
  3: import java.sql.Timestamp;
  4: 
  5: import com.opensymphony.xwork2.ActionSupport;
  6: 
  7: public class HelloWorldAction extends ActionSupport {
  8: 	private String pesan;
  9: 	private String waktu;
 10: 
 11: 	public String execute() {
 12: 
 13: 		pesan = "HELLO WORLD....!!! Method execute telah dijalankan....";
 14: 		waktu = new Timestamp(System.currentTimeMillis()).toString();
 15: 
 16: 		return SUCCESS;
 17: 	}
 18: 
 19: 	public void setPesan(String pesan) {
 20: 		this.pesan = pesan;
 21: 	}
 22: 
 23: 	public String getPesan() {
 24: 		return pesan;
 25: 	}
 26: 
 27: 	public void setWaktu(String waktu) {
 28: 		this.waktu = waktu;
 29: 	}
 30: 
 31: 	public String getWaktu() {
 32: 		return waktu;
 33: 	}
 34: 
 35: }

Contoh diatas hampir mirip dengan class POJO yang memiliki method get dan set, perbedaannya adalah action dari Struts2 memiliki method execute() yang akan dijalankan ketika client memangil action tersebut.

Tinggal kita membuat viewnya, pada bagian ini sudah saya jelaskan sebelumnya kita akan menggunakan Velocity sebagai viewer layernya, kita buat file hello.vm pada folder WebContent/view.

  1: <html>
  2:   <head>
  3:     <title>Project Struts2 Pertama</title>
  4:   </head>
  5:   <body>
  6:     <p>Pesan : $pesan</p>
  7:     <p>Waktu hari ini : $waktu</p>
  8:   </body>
  9: </html>

Sepertinya baris kode diatas sudah cukup untuk menjelaskan mengapa saya menyebut Velocity lebih simple daripada JSP. Sekarang bandingkan dengan hello.jsp berikut.

  1: <%@taglib prefix="s" uri="/struts-tags" %>
  2: <html>
  3:   <head>
  4:     <title>Project Struts2 Pertama</title>
  5:   </head>
  6:   <body>
  7:     <p>Pesan : <s:property value="pesan" /></p>
  8:     <p>Waktu hari ini : <s:property value="waktu" /></p>
  9:   </body>
 10: </html>

Nah anda tinggal pilih lebih suka menggunakan viewer yang mana.

Sekarang kita masuk ke bagian inti dari semua itu yaitu membuat file konfigurasi struts.xml yang diletakkan pada folder src. Selanjutnya kita hanya perlu memapping action yang telah kita buat ke dalam file konfigurasi ini.

  1: <?xml version="1.0" encoding="UTF-8" ?>
  2: 
  3: <!DOCTYPE struts PUBLIC
  4:     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  5:     "http://struts.apache.org/dtds/struts-2.0.dtd">
  6: 
  7: <struts>
  8:   <package name="default" extends="struts-default" namespace="/cobastruts">
  9:     <action name="HelloVelocity" class="com.mervpolis.struts.HelloWorldAction">
 10:       <result name="success" type="velocity">/view/hello.vm</result>
 11:     </action>
 12:     <action name="HelloJSP" class="com.mervpolis.struts.HelloWorldAction">
 13:       <result name="success">/view/hello.jsp</result>
 14:     </action>
 15:   </package>
 16: </struts>

Buat file index.jsp yang akan me-redirect halaman langsung ke action, file ini akan dijalankan pertama kali saat aplikasi baru dijalankan.

  1: <%
  2:   response.sendRedirect("cobastruts/HelloVelocity.action");
  3: %>

Sekarang coba jalankan aplikasi tersebut pada server dengan mengetik

http://[host]:[port]/[namaproject]/

Dan hasilnya adalah :

Selesai sudah bahasan hari ini :D Mudah bukan membuat aplikasi web menggunakan Controller Struts2, tinggal menambahkan kreativitas dan sedikit ide gila anda untuk menjadikan banyak aplikasi yang mungkin tidak pernah terpikirkan sebelumnya.

Seperti janji saya kemarin (mungkin dulu), kali ini saya akan membahas mengenai proses CRUD dengan EclipseLink karena pada postingan saya yang terdahulu (nggak dulu-dula amat ah….) hanya membahas mengenai inisialisasi EntityManagerFactory.

Sedikit penjelasan mengenai bahasan kali ini yaitu seperti namanya CRUD merupakan proses Create, Read, Update, dan Delete suatu data ke dalam database. Mohon maaf karena kali ini saya hanya akan membahas Create-nya saja.

Ok langsung saja saya jelaskan ……

Pertama buat entity class kemudian buat konfigurasi persistence nya, untuk mempersingkat waktu silakan lihat di sini. Anda bisa memilih menggunakan persistence.xml ataupun Spring. Dalam contoh kali ini saya kan menggunakan Spring untuk inisialisasi EntityManagerFactory-nya.

Dan berikut ini script-nya

  1: package nagasakti.crud;
  2: 
  3: import javax.persistence.EntityManager;
  4: import javax.persistence.EntityManagerFactory;
  5: import nagasakti.entity.Siswa;
  6: import org.springframework.context.ApplicationContext;
  7: import org.springframework.context.support.ClassPathXmlApplicationContext;public class Main {
  8:     private ApplicationContext app;
  9:     private EntityManagerFactory emf;
 10:     private EntityManager em;
 11: 
 12:     public Main() {
 13:         app = new ClassPathXmlApplicationContext("applicationContext-EclipseLink.xml");
 14:         emf = (EntityManagerFactory) app.getBean("myEntityManagerFactory");
 15:         em  = emf.createEntityManager();
 16:     }
 17: 
 18:     public void save(Siswa siswa) {
 19:         em.getTransaction().begin();
 20:         em.persist(siswa);
 21:         em.getTransaction().commit();
 22:     }
 23: 
 24:     public static void main(String[] args) {
 25:         Siswa sis = new Siswa();
 26: 
 27:         sis.setName("Kampret");
 28:         sis.setAge("14");
 29: 
 30:         Main main = new Main();
 31:         main.save(sis);
 32:     }
 33: }

Bisa kita lihat dari baris kode diatas, inisialisasi EntityManager berada pada constructor dari class Main, sedangkan proses save data berada pada method save(). Ketika kode diatas dijalankan lihatlah keajaiban yang terjadi, secara otomatis akan terbentuk sebuah table dengan nama siswa serta di dalamnya sudah terisi satu record dengan value “Kampret, 14”. Dari contoh diatas kita bisa lihat betapa mudahnya mengimplementasikan orm pada aplikasi yang kita buat. Monggo dicoba ……..