Aspect Oriented Programming

Dalam membuat software, kita harus memikirkan banyak hal dalam satu waktu seperti proses bisnis, security, logging, persistence, multithreading, transaction, dll. Dari sekian banyak hal yang harus dipikirkan di atas, kita bisa mengelompokkannya menjadi dua kategori (dalam istilah AOP disebut concern). Kategori pertama adalah core concern, yaitu fungsi-fungsi utama sebuah software dibangun. Dalam hal ini tentu saja adalah proses bisnis. Kategori kedua adalah system-wide concern atau crosscutting concern, yaitu fungsi-fungsi yang tersebar di seluruh bagian software. Fungsi-fungsi ini bukan fungsi utama tetapi pendukung sistem, namun keberadaannya tetap diperlukan untuk memenuhi requirement software yang baik. Contohnya adalah security, pooling, logging, dan persistence.

OOP, seperti Java dan C++, telah terbukti sebagai metodologi yang baik untuk implementasi core concern, tapi tidak cukup baik untuk crosscutting concern. Ambil contoh logging. Dengan Java kita terbiasa menulis kode untuk logging bercampur dengan bisnis proses, misalnya untuk debugging. Jika kita ingin mengubah logging, maka kita harus melakukan perubahan di core concern, dalam hal ini class atau method untuk proses bisnis. Sebagai ilustrasi lihat gambar berikut ini yang memperlihatkan sebuah sistem yang terdiri dari beberapa concern menjadi satu, dalam AOP disebut tangled (awut-awutan).



Perhatikan ilustrasi lain berikut ini, Ramnivas Laddad menggambarkan beberapa concern dalam multidimensional-space sebagai berikut



Dari gambar terlihat bahwa sebuah software terdiri dari tiga concern yaitu persistence, logging, dan business logic. Namun dalam implementasinya ketiga concern tersebut tetap menjadi satu dimensi karena metodologi OOP mengharuskannya demikian. Gambar di atas jika diimplementasikan dalam code lebih kurang seperti ini

public class MyAllInOneClass {
public void superMethod() {
// lakukan autorisasi
// logging start business process
// lakukan proses bisnis
// logging end business process
}
public void save() {...}
public void load() {...}
}

Dari implementasi class di atas terlihat bahwa concern persistence berada dalam satu class dengan core concern, juga security dan logging concern berada dalam satu method dengan core concern.

AOP adalah metodologi yang memisahkan antara core concern dan crosscutting concern dengan memperkenalkan sebuah modul yang disebut aspect. Dengan AOP, kita mengimplementasikan crosscutting concern dalam aspect, tidak lagi dalam core concern. Dengan demikian kita tidak perlu mengkhawatirkan masalah crosscutting concern lagi pada saat awal kita membangun software. Kita bisa fokus membangun proses bisnis karena crosscutting concern tersebut bisa ditambahkan ke dalam sistem tanpa kita perlu mengubah core concern.

OOP telah sukses membuktikan diri sebagai metodologi yang tepat untuk memecahkan sistem yang kompleks menjadi sederhana dengan membaginya ke dalam class-class yang dikenal dengan istilah modularisasi. Dalam loosely coupling, OOP juga bisa diandalkan dengan memisahkan interface dan class-class implementasinya.

AOP tidak dimaksudkan untuk menggantikan OOP, sebaliknya, AOP akan menjadikan OOP semakin handal dalam membuat modularisasi melalui pemisahan concern. Dan walaupun pemisahan abstract dan implementasi dalam interface dan class berhasil untuk core concern, namun tidak untuk crosscutting concern. Perhatikan bahwa untuk setiap kita melakukan logging kita tetap harus memanggil API logger di setiap method yang mau logging. Artinya code untuk memanggil API logging akan tersebar di seluruh core concern yang membutuhkannya, yang seperti telah digambarkan di atas sebagai code tangling (awut-awutan). Dengan AOP, kita tidak perlu memanggil API untuk logging dari core concern. Dua gambar berikut adalah ilustrasi sebelum dan sesudah AOP digunakan. Perhatikan bahwa pada gambar pertama kita memanggil API logging sedangkan pada gambar kedua seluruh modul benar-benar terpisah.





AOP Methodology

Membangun sistem menggunakan AOP mirip dengan membangun sistem menggunakan metodologi lainnya : mengidentifikasi concern, mengimplementasikan concern, dan membentuk sistem akhir dengan menggabungkan concern-concern tersebut.

1. Aspectual Decomposition

Pada tahap ini kita melakukan decompose requirements untuk mengidentifikasi core concern dan crosscutting concern.

2. Concern Implementation

Pada tahap ini kita mengimplementasikan tiap concern secara independen. Perhatikan bahwa pada tahap ini masing-masing concern diimplementasikan pada modulnya sendiri, terpisah dengan modul lain. Dengan demikian kita bisa membuat modul per modul secara bertahap, tidak perlu memikirkan sekian banyak modul dalam satu waktu.

3. Aspectual Recomposition

Pada tahap ini kita membuat recomposition rules dengan membuat modularization unit atau aspect. Proses recomposition disebut juga weaving atau integrating, dan akan membentuk sistem akhir berdasarkan aspect tersebut.

Berikut ilustrasi yang digambarkan oleh Ramnivas Laddad :



Bagaimanakah weaver bekerja? Cara yang paling sederhana adalah melalui source-to-source translation. Source code untuk masing-masing modul dan aspect diproses untuk membentuk woven source code. Aspect compiler kemudian mengirimkan woven-source-code tersebut kepada compiler bahasa pemrograman yang dipakai untuk membentuk byte-code. Dengan pendekatan ini menggunakan Java, maka Java-based AOP implementation mengubah masing-masing source code pada tiap modul kedalam woven java source code kemudian java compiler mengubahnya menjadi byte code. Perhatikan bahwa weaver tidak akan mengubah original source code sama sekali.

Berikut adalah contoh untuk memperjelas bagaimana AOP diimplementasikan pada Java

1. Kita memiliki core logic sebagai berikut



2. Kita memiliki crosscutting concern berupa logging interface seperti berikut

public interface Logger {
public void log(String message);
}

3. Kita memiliki aspect berikut



3. Setelah proses weaving maka kita memiliki source code kira-kira seperti berikut