Aspect Oriented Programming dengan Spring AspectJ Part II

Melanjutkan artikel sebelumnya kali ini saya akan mencoba membahas penggunaan aspect control guna mengatur aspect mana yang akan dijalankan terlebih dahulu pada target class. Pada artikel sebelumnya kita hanya menggunakan sebuah aspect yaitu aspect logging yang berfungsi untuk mencatat aktivitas yang terjadi pada sebuah target class. Masalah yang terjadi dalam membuat aplikasi adalah penggunaan beberapa aspect dalam sebuah target class. Misal : Dalam kasus sebelumnya kita ingin menambahkan aspect validasi guna melakukan validasi terhadap target class.
Cara ini dapat diselesaikan dengan mengimplementasikan interface dari kelas Ordered:

     public AspectKelas implements Ordered{

	public int getOrder(){
	 return 0;
	}
}

Cara yang lebih mudah lagi adalah dengan menggunakan anotasi @Order(value=(int)). Ok,, sekarang kita mulai…
Pertama-tama kita membuat kelas yang sama dengan artikel sebelumnya :

public interface Kalkulator {

    public double kali(double x, double y);

    public double bagi(double x, double y);
}

Implementasikan kelas tersebut :

public class KalkulatorImpl implements Kalkulator {

    public double bagi(double x, double y) {
        double hasil = x / y;
        return hasil;

    }

    public double kali(double x, double y) {
        double hasil = x * y;
        return hasil;
    }
}

Kemudian kita buat sebuah aspect untuk menangani logging, pada kelas ini kita mencoba menggunakan arround advice. Aspect logging ini akan kita jalankan setelah Aspect validasi dijalankan. Jadi kita berikan nilai pada anotasi @Order dengan nilai 1.

@Aspect
@Order(1)
public class KalkulatorLoggingAspect {

    private Log log = LogFactory.getLog(this.getClass());

    @Around("execution(* *.*(..))")
    public Object logArround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("Method " + joinPoint.getSignature().getName() + " () dijalankan dengan paramter " + Arrays.toString(joinPoint.getArgs()));
        try {
            Object result = joinPoint.proceed();
            log.info("Method " + joinPoint.getSignature().getName() + " () dijalankan dengan hasil " + result);
            return result;
        } catch (Exception e) {
            log.error("Terjadi error pada method " + joinPoint.getSignature().getName() + " () ");
            throw e;
        }

    }
}

Langkah selanjutnya adalah mencoba membuat aspect untuk menangani validasi, dalam kasus ini misal operasi-operasi yang terjadi dalam kelas Kalkulator hanya dapat berisi bilangan yang lebih besar dari 0. Aspect ini akan dijalankan pertama kali sebelum aspect logging dijalankan, maka kita berikan nilai pada anotasi @Order dengan nilai 0.

@Aspect
@Order(0)
public class KalkulatorValidationAspect {

    @Before("execution(* *.*(double,double))")
    public void validateBefore(JoinPoint joinPoint) {
        for (Object args : joinPoint.getArgs()) {
            System.out.println(Arrays.toString(joinPoint.getArgs()));
            validate((Double) args);
        }
    }

     private void validate(double x,JoinPoint joinPoint) {
        if (x < 0) {
            throw new IllegalArgumentException("Bilangan tidak valid pada method "+joinPoint.getSignature().getName());
        }
    }
}

Pada validasi diatas kita hanya menggunakan before advice. Dimana target method dari target kelas tujuan akan divalidasi dulu dengan cara before advice. Setelah itu kita injeksi didalam container.

….

    <aop:aspectj-autoproxy/>

    <bean id="kalkulator" class="org.kris.aop.wordpress.KalkulatorImpl"/>

    <bean class="org.kris.aop.wordpress.KalkulatorValidationAspect"/>

    <bean class="org.kris.aop.wordpress.KalkulatorLoggingAspect"/>
….

Kemudian kita buatkan main kelasnya.

….
public class MainClass {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("container.xml");
        Kalkulator kalkulator=(Kalkulator) context.getBean("kalkulator");
        kalkulator.kali(2, 2);
        kalkulator.bagi(2, 2);
    }
}

Hasilnya :

Nov 29, 2009 10:40:29 AM org.kris.aop.wordpress.KalkulatorLoggingAspect logArround
INFO: Method kali () dijalankan dengan paramter [2.0, 2.0]
Nov 29, 2009 10:40:29 AM org.kris.aop.wordpress.KalkulatorLoggingAspect logArround
INFO: Method kali () dijalankan dengan hasil 4.0
Nov 29, 2009 10:40:29 AM org.kris.aop.wordpress.KalkulatorLoggingAspect logArround
INFO: Method bagi () dijalankan dengan paramter [2.0, 2.0]
Nov 29, 2009 10:40:29 AM org.kris.aop.wordpress.KalkulatorLoggingAspect logArround
INFO: Method bagi () dijalankan dengan hasil 1.0

Dari hasil diatas kita program sukses dijalankan tanpa error. Nah..pada main kelas kedua kita akan mencoba memasukan nilai lebih kecil dari 0.

….
public class MainClass {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("container.xml");
        Kalkulator kalkulator=(Kalkulator) context.getBean("kalkulator");
        kalkulator.kali(-1, 2);
        kalkulator.bagi(2, 2);
    }
}

Hasilnya :

Exception in thread "main" java.lang.IllegalArgumentException: Bilangan tidak valid pada method kali
        at org.kris.aop.wordpress.KalkulatorValidationAspect.validate(KalkulatorValidationAspect.java:31)

Dari hasil diatas maka program tidak akan menyentuh aspect logging. Hal ini dikarenakan pada aspect validasi kita memberikan nilai lebih kecil daripada aspect logging. Semisal kita memberikan nilai lebih besar dari aspect logging maka hasilnya akan seperti berikut :

….
Nov 29, 2009 10:45:16 AM org.kris.aop.wordpress.KalkulatorLoggingAspect logArround
INFO: Method kali () dijalankan dengan paramter [-1.0, 2.0]
Nov 29, 2009 10:45:16 AM org.kris.aop.wordpress.KalkulatorLoggingAspect logArround
SEVERE: Terjadi error pada method kali ()
Exception in thread "main" java.lang.IllegalArgumentException: Bilangan tidak valid pada method kali
        at org.kris.aop.wordpress.KalkulatorValidationAspect.validate(KalkulatorValidationAspect.java:31)
….

Dari hasil diatas dapat kita lihat aspect logging akan tetap dijalankan meskipun terjadi error. Ok… mudah bukan, pada artikel selanjutnya saya akan mencoba membahas gaya-gaya yang dapat digunakan dalam mengimplementasikan Spring Aspectj dalam mengembangkan sebuah aplikasi,,,
Ditunggu ya……….