JAVA Reflection Method Invoke

Tulisan ini merupakan kelanjutan dari tulisan saya sebelumnya yaitu JAVA Reflection Instantiate Object dimana pada tulisan tersebut saya telah menjanjikan akan membuat tulisan mengenai akses method menggunakan JAVA Reflection. Untuk memulai praktikum ini maka anda harus membaca dahulu tulisan saya sebelumnya yaitu JAVA Reflection Property Access. Kenapa saya bilang harus, karena source code yang akan dibahas pada tulisan ini core-nya mengambil dari tulisan saya tersebut. Baiklah untuk mempersingkat waktu mari kita mulai praktikum kita dengan langkah-langkah berikut:

1. Tambahkan Source Code Berikut Pada KelasInduk dan KelasAnak
Tambahkan method-method berikut pada KelasInduk.java

    private void methodIndukPrivate() {
        System.out.print("Dalam Method Induk Private");
    }

    protected void methodIndukProtected(StringBuilder params) {
        System.out.print("dalam Method Induk Protected: " + params.toString());
    }

    public String methodIndukPublic(String params, Double nilai) {
        return "dalam Method Induk Public: " + params + " < ==> " + nilai;
    }

Setelah menambahkan method-method diatas pada KelasInduk.Java berikutnya adalah tambahkan method-method berikut pada KelasAnak.java

    private void methodPrivate(){
        System.out.print("Dalam Method Private");
    }

    protected void methodProtected(String params){
        System.out.print("dalam Method Protected: " + params);
    }     
    
    public String methodPublic(String params, Integer nilai){
        return "dalam Method Public: " + params + " < ==> " + nilai;
    }     

Method-method yang telah dideklarasikan diatas adalah method-method yang akan dieksekusi secara reflection oleh procedure (method) yang akan kita buat.

2. Buat Procedure Untuk Mengakses Method Menggunakan Java Reflection
Pada langkah ini sekilas algoritmanya adalah sebagai berikut:

  • 1. List semua method yang ada dalam suatu kelas.
  • 2. Cek apakah method-method yang akan dieksekusi mempunyai parameter atau tidak
  • 2(a). Jika method yang akan dijalankan memiliki parameter maka list semua parameternya dan kumpulkan dalam suatu list dan tidak lupa instantiate nilai masing-masing parameter tersebut untuk kemudian di-eksekusi (langkah 3).
  • 2(b). Jika method yang akan dijalankan tidak memiliki parameter lakukan eksekusi (langkah 3).
  • 3. Eksekusi method dengan menggunakan method invoke.

Keseluruhan dari gambaran algoritma diatas dapat dilihat pada potongan source code berikut

    public void callMethodReflection(Object obj, Class clazz) {
        try {
            for (Method method : clazz.getDeclaredMethods()) {
                boolean isAccessible = method.isAccessible();
                System.out.println("Nama Method  : " + method.getName());
                System.out.println("Accessible   : " + isAccessible);
                System.out.println("Modifier     : " + this.getMethodModifier(method.getModifiers()));
                System.out.print("Hasil Invoke : ");

                Object[] params = null; // initiate params
                // cek apakah method mempunyai parameter
                if (method.getParameterTypes().length > 0) {
                    params = new Object[method.getParameterTypes().length];
                    Class< ?>[] parameterTypes = method.getParameterTypes();
                    for (int i = 0; i < parameterTypes.length; i++) {
                        //instantiate parameter
                        params[i] = this.instantiateParameter(parameterTypes, i);
                    }
                }
                // eksekusi method
                Object result = this.invokeMethod(method, obj, isAccessible, params);
                if (result != null) {
                    System.out.print(result);
                }
                System.out.println("\n==============\n");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

Pada algoritma 2.a disebutkan untuk meng-instantiate nilai parameter dari method tersebut. Adapun proses untuk memperjelas proses instantiate-nya dapat dilihat pada tulisan saya instantiate object using java reflection.

3. Buat Method Untuk Invoke Method
Langkah ini merupakan kelanjutan pada algoritma yang disebutkan diatas dimana untuk mengeksekusi method dilakukan dengan cara invoke method. Potongan source code dari method invoke tersebut adalah

    private Object invokeMethod(Method method, Object obj, boolean isAccessible, Object[] params) {
        Object result = null;
        try {
            if (!isAccessible) {
                method.setAccessible(true);
                result = method.invoke(obj, params);
                method.setAccessible(false);
            } else {
                result = method.invoke(obj, params);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            result = null;
        }
        return result;
    }

Dari source code diatas untuk invoke method dari KelasAnak dan KelasInduk bisa dilihat pada potongan source code berikut

  // invoke KelasAnak
  new MethodReflection().callMethodReflection(object, object.getClass());

  // invoke KelasInduk
  new MethodReflection().callMethodReflection(object, object.getClass().getSuperclass());

Demikian kegiatan ngoprek kali ini saya persembahkan. Mungkin dari penjelasan diatas berikut source code yang disertakan kurang dapat dipahami. Untuk itu dalam tulisan ini saya sertakan source code lengkap sehingga dapat memudahkan untuk dipelajari. Silahkan download source code yang saya sertakan pada bagian paling bawah dari tulisan ini.

Source: MethodReflection




Leave a Reply

[+] kaskus emoticons nartzco