Yans─▒ma nedir ve neden faydal─▒d─▒r?


Al─▒nan cevaba git


Yans─▒ma nedir ve neden faydal─▒d─▒r?

Java ile ├Âzellikle ilgileniyorum, ancak ilkelerin herhangi bir dilde ayn─▒ oldu─čunu kabul ediyorum.


1988









Cevap say─▒s─▒n─▒ say: 21






Ad yans─▒mas─▒, ayn─▒ sistemdeki (veya kendisi) di─čer kodlar─▒ kontrol edebilecek kodu tan─▒mlamak i├žin kullan─▒l─▒r.

├ľrne─čin, JavaÔÇÖda bilinmeyen t├╝rde bir nesneye sahip oldu─čunuzu ve varsa bir ÔÇťdoSomethingÔÇŁ y├Ântemini ├ža─č─▒rmak istedi─činizi varsayal─▒m. Java'n─▒n statik yazma sistemi, nesne bilinen bir aray├╝ze uymad─▒─č─▒ s├╝rece bunu destekleyecek ┼čekilde tasarlanmam─▒┼čt─▒r, ancak yans─▒ma kullanarak kodunuz nesneye bakabilir ve 'doSomething' ad─▒nda bir y├Ântem olup olmad─▒─č─▒n─▒ ├Â─črenebilir ve ard─▒ndan istemek.

Bu y├╝zden, Java'da size bunun bir kod ├Ârne─čini vermek i├žin (s├Âz konusu nesnenin foo oldu─čunu hayal edin):

 Method method = foo.getClass().getMethod("doSomething", null);
method.invoke(foo, null);
 

Java'da ├žok yayg─▒n bir kullan─▒m ├Ârne─či, ek a├ž─▒klama i├žeren kullan─▒md─▒r. ├ľrne─čin JUnit 4, @Test ek a├ž─▒klamas─▒yla etiketlenmi┼č y├Ântemler i├žin s─▒n─▒flar─▒n─▒za bakmak i├žin yans─▒ma kullanacak ve daha sonra ├╝nite testini ├žal─▒┼čt─▒r─▒rken bunlar─▒ arayacakt─▒r.

Http://docs.oracle.com/javase/tutorial/reflect/index.html adresinde ba┼člaman─▒z i├žin baz─▒ iyi yans─▒ma ├Ârnekleri vard─▒r.http://docs.oracle.com/javase/tutorial/reflect/index.html

Ve son olarak, evet, kavramlar yans─▒may─▒ destekleyen di─čer statik tip dillerde olduk├ža benzerdir (C # gibi). Dinamik olarak yaz─▒lm─▒┼č dillerde, yukar─▒da a├ž─▒klanan kullan─▒m durumu daha az gereklidir (derleyici herhangi bir nesnenin ├ža─čr─▒lmas─▒na izin verir, ├ž├╝nk├╝ ├žal─▒┼čma zaman─▒nda mevcut de─čilse ba┼čar─▒s─▒z olur), ancak i┼čaretli y├Ântemleri araman─▒n ikinci durumu Belli bir ┼čekilde ├žal─▒┼čmak hala yayg─▒nd─▒r.

Bir yorumdan g├╝ncelleme:

Sistemdeki kodu inceleme ve nesne t├╝rlerini g├Ârme yetene─či yans─▒ma de─čil, Yaz─▒m Denetimi'dir. Daha sonra yans─▒ma, i├ž denetimden faydalanarak ├žal─▒┼čma zaman─▒nda de─či┼čiklik yapma yetene─čidir. Buradaki ayr─▒m, baz─▒ dillerin i├ž g├Âzlemi destekledi─či, ancak yans─▒may─▒ desteklemedi─či i├žin gereklidir. B├Âyle bir ├Ârnek C ++


1630







Yans─▒ma , bir dilin ├žal─▒┼čma zaman─▒nda s─▒n─▒flar─▒, y├Ântemleri, nitelikleri vb. Denetleme ve dinamik olarak arama yetene─čidir.

├ľrne─čin, Java'daki t├╝m nesneler getClass() , derleme zaman─▒nda bilmiyor olsan─▒z bile (├Ârne─čin, bunu bir olarak ilan ettiyseniz Object ) nesnenin s─▒n─▒f─▒n─▒ belirlemenizi sa─člayan bir y├Ânteme sahiptir - bu ├Ânemsiz g├Âr├╝nebilir, ancak bu t├╝r bir yans─▒ma m├╝mk├╝n olmayabilir gibi daha az dinamik dillerde C++ . Daha geli┼čmi┼č kullan─▒mlar, y├Ântemleri, yap─▒c─▒lar─▒ vb. Listeleyip ├ža─č─▒rman─▒z─▒ sa─člar.

Yans─▒ma ├Ânemlidir, ├ž├╝nk├╝ derleme zaman─▒nda her ┼čeyi "bilmek" zorunda olmayan programlar─▒ daha fazla dinamik hale getirir, ├ž├╝nk├╝ ├žal─▒┼čma zaman─▒nda birbirine ba─članabilirler. Kod bilinen aray├╝zlere kar┼č─▒ yaz─▒labilir, ancak kullan─▒lacak ger├žek s─▒n─▒flar, yap─▒land─▒rma dosyalar─▒ndan yans─▒ma kullan─▒larak ba┼člat─▒labilir.

Modern ├žer├ževelerin ├žo─ču bu sebepten dolay─▒ yans─▒may─▒ yo─čun olarak kullan─▒yor. Di─čer bir├žok modern dil de yans─▒ma kullan─▒r ve betik dillerinde (Python gibi), bu dillerin genel programlama modelinde daha do─čal hissetti─činden daha s─▒k─▒ bir ┼čekilde b├╝t├╝nle┼čir.


227







En sevdi─čim yans─▒ma kullan─▒mlar─▒ndan biri, a┼ča─č─▒daki Java bo┼čaltma y├Ântemidir. Herhangi bir nesneyi parametre olarak al─▒r ve her alan ad─▒n─▒ ve de─čerini yazd─▒rmak i├žin Java yans─▒ma API'sini kullan─▒r.

 import java.lang.reflect.Array;
import java.lang.reflect.Field;

public static String dump(Object o, int callCount) {
    callCount++;
    StringBuffer tabs = new StringBuffer();
    for (int k = 0; k < callCount; k++) {
        tabs.append("\t");
    }
    StringBuffer buffer = new StringBuffer();
    Class oClass = o.getClass();
    if (oClass.isArray()) {
        buffer.append("\n");
        buffer.append(tabs.toString());
        buffer.append("[");
        for (int i = 0; i < Array.getLength(o); i++) {
            if (i < 0)
                buffer.append(",");
            Object value = Array.get(o, i);
            if (value.getClass().isPrimitive() ||
                    value.getClass() == java.lang.Long.class ||
                    value.getClass() == java.lang.String.class ||
                    value.getClass() == java.lang.Integer.class ||
                    value.getClass() == java.lang.Boolean.class
                    ) {
                buffer.append(value);
            } else {
                buffer.append(dump(value, callCount));
            }
        }
        buffer.append(tabs.toString());
        buffer.append("]\n");
    } else {
        buffer.append("\n");
        buffer.append(tabs.toString());
        buffer.append("{\n");
        while (oClass != null) {
            Field[] fields = oClass.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                buffer.append(tabs.toString());
                fields[i].setAccessible(true);
                buffer.append(fields[i].getName());
                buffer.append("=");
                try {
                    Object value = fields[i].get(o);
                    if (value != null) {
                        if (value.getClass().isPrimitive() ||
                                value.getClass() == java.lang.Long.class ||
                                value.getClass() == java.lang.String.class ||
                                value.getClass() == java.lang.Integer.class ||
                                value.getClass() == java.lang.Boolean.class
                                ) {
                            buffer.append(value);
                        } else {
                            buffer.append(dump(value, callCount));
                        }
                    }
                } catch (IllegalAccessException e) {
                    buffer.append(e.getMessage());
                }
                buffer.append("\n");
            }
            oClass = oClass.getSuperclass();
        }
        buffer.append(tabs.toString());
        buffer.append("}\n");
    }
    return buffer.toString();
}
 

104







Yans─▒ma kullan─▒mlar─▒

Yans─▒ma, Java sanal makinesinde ├žal─▒┼čan uygulamalar─▒n ├žal─▒┼čma zaman─▒ davran─▒┼č─▒n─▒ inceleme veya de─či┼čtirme becerisi gerektiren programlar taraf─▒ndan yayg─▒n olarak kullan─▒l─▒r. Bu nispeten geli┼čmi┼č bir ├Âzelliktir ve yaln─▒zca dilin temellerini anlayabilen geli┼čtiriciler taraf─▒ndan kullan─▒lmal─▒d─▒r. Bu uyar─▒ g├Âz ├Ân├╝ne al─▒nd─▒─č─▒nda, yans─▒ma g├╝├žl├╝ bir tekniktir ve uygulamalar─▒n aksi takdirde imkans─▒z olacak i┼člemleri ger├žekle┼čtirmelerini sa─člayabilir.

Geni┼čletilebilirlik ├ľzellikleri

Bir uygulama, tam nitelikli adlar─▒n─▒ kullanarak geni┼čletilebilirlik nesnelerinin ├Ârnekleri olu┼čturarak, kullan─▒c─▒ taraf─▒ndan tan─▒mlanan harici s─▒n─▒flar─▒ kullanabilir. S─▒n─▒f Taray─▒c─▒lar─▒ ve G├Ârsel Geli┼čtirme Ortamlar─▒ Bir s─▒n─▒f taray─▒c─▒s─▒n─▒n, s─▒n─▒f ├╝yelerini s─▒ralayabilmesi gerekir. G├Ârsel geli┼čtirme ortamlar─▒, geli┼čtiricinin do─čru kodu yazmas─▒na yard─▒mc─▒ olmak i├žin yans─▒ma t├╝r├╝ndeki bilgileri kullanman─▒n yararlar─▒ndan yararlanabilir. Hata Ay─▒klay─▒c─▒lar ve Test Ara├žlar─▒ Hata ay─▒klay─▒c─▒lar─▒n s─▒n─▒ftaki ├Âzel ├╝yeleri inceleyebilmesi gerekir. Test donan─▒mlar─▒, bir test tak─▒m─▒nda y├╝ksek d├╝zeyde kod kapsam─▒ sa─člamak i├žin bir s─▒n─▒fta tan─▒mlanm─▒┼č ke┼čfedilebilir ayarlanm─▒┼č API'leri sistematik olarak ├ža─č─▒rmak i├žin yans─▒madan yararlanabilir.

Yans─▒ma Dezavantajlar─▒

Yans─▒ma g├╝├žl├╝d├╝r, ancak ayr─▒m g├Âzetmeden kullan─▒lmamal─▒d─▒r. Yans─▒ma kullanmadan bir i┼člem yapmak m├╝mk├╝n ise, kullanmaktan ka├ž─▒nmak tercih edilir. Yans─▒ma yoluyla koda eri┼čirken a┼ča─č─▒daki endi┼čeler ak─▒lda tutulmal─▒d─▒r.

  • Performans Tepeg├Âz├╝

Yans─▒ma, dinamik olarak ├ž├Âz├╝mlenmi┼č t├╝rleri i├žerdi─činden, belirli Java sanal makinesi optimizasyonlar─▒ ger├žekle┼čtirilemez. Sonu├ž olarak, yans─▒t─▒c─▒ i┼člemler yans─▒t─▒c─▒ olmayan emsallerinden daha yava┼č performans g├Âsterir ve performansa duyarl─▒ uygulamalarda s─▒k olarak adland─▒r─▒lan kod b├Âl├╝mlerinden ka├ž─▒n─▒lmal─▒d─▒r.

  • G├╝venlik K─▒s─▒tlamalar─▒

Yans─▒tma, bir g├╝venlik y├Âneticisi alt─▒nda ├žal─▒┼č─▒rken bulunmayabilecek bir ├žal─▒┼čma zaman─▒ izni gerektirir. Bu, Applet gibi s─▒n─▒rl─▒ bir g├╝venlik ba─člam─▒nda ├žal─▒┼čmas─▒ gereken kod i├žin ├Ânemli bir husustur.

  • ─░nternallar─▒n Maruz Kalmas─▒

Yans─▒ma, kodun, ├Âzel alanlara ve y├Ântemlere eri┼čmek gibi yans─▒t─▒c─▒ olmayan kodda yasad─▒┼č─▒ olabilecek i┼člemleri ger├žekle┼čtirmesine izin verdi─činden, yans─▒ma kullan─▒m─▒, kodu i┼člevsiz hale getirebilecek ve ta┼č─▒nabilirli─či bozabilecek beklenmeyen yan etkilere neden olabilir. Yans─▒t─▒c─▒ kod soyutlamalar─▒ bozar ve bu nedenle platformun y├╝kseltilmesiyle davran─▒┼č─▒n─▒ de─či┼čtirebilir.

kaynak: Yans─▒ma API'si


77







Yans─▒ma, bir uygulaman─▒n veya ├žer├ževenin hen├╝z yaz─▒lmam─▒┼č bile olsa kodla ├žal─▒┼čmas─▒na izin veren ├Ânemli bir mekanizmad─▒r!

├ľrne─čin, tipik web.xml dosyan─▒z─▒ al─▒n. Bu, yuvalanm─▒┼č bir sunucu uygulamas─▒ s─▒n─▒f─▒ ├Â─čeleri i├žeren bir sunucu uygulamas─▒ ├Â─čeleri listesi i├žerir. Sunucu uygulamas─▒ kab─▒, web.xml dosyas─▒n─▒ i┼čleyecek ve yans─▒ma yoluyla her bir sunucu uygulamas─▒ s─▒n─▒f─▒n─▒n yeni bir ├Ârne─čini olu┼čturacakt─▒r.

Ba┼čka bir ├Ârnek, XML Ayr─▒┼čt─▒rma i├žin Java API (JAXP) olacakt─▒r . Bir XML ayr─▒┼čt─▒r─▒c─▒ sa─člay─▒c─▒s─▒n─▒n, yans─▒ma yoluyla yeni ├Ârnekler olu┼čturmak i├žin kullan─▒lan, iyi bilinen sistem ├Âzellikleriyle 'tak─▒l─▒' oldu─ču durumlarda.

Ve son olarak, en kapsaml─▒ ├Ârnek, fasulyelerini olu┼čturmak i├žin yans─▒ma kullanan ve a─č─▒r proxy kullan─▒m─▒ i├žin Bahar .


40







Her dil yans─▒tmay─▒ desteklemez, ancak ilkeler genellikle onu destekleyen dillerde ayn─▒d─▒r.

Yans─▒tma, program─▒n─▒z─▒n yap─▒s─▒n─▒ "yans─▒tma" yetene─čidir. Veya daha somut. Sahip oldu─čunuz nesnelere ve s─▒n─▒flara bakmak ve programl─▒ olarak uygulad─▒klar─▒ y├Ântemler, alanlar ve aray├╝zler hakk─▒nda bilgi almak i├žin. Ek a├ž─▒klamalar gibi ┼čeylere de bakabilirsiniz.

Bir├žok durumda faydal─▒d─▒r. Dinamik olarak s─▒n─▒flar─▒ kodunuza eklemek istedi─činiz her yerde. ├çok say─▒da nesne ili┼čkisel e┼čle┼čtiricisi, hangi nesneleri kullanacaklar─▒n─▒ ├Ânceden bilmeden, veritabanlar─▒ndan nesneleri ba┼člatabilmek i├žin yans─▒ma kullan─▒r. Eklenti mimarileri, yans─▒man─▒n kullan─▒┼čl─▒ oldu─ču ba┼čka bir yerdir. Kodu dinamik olarak y├╝kleyebilmek ve orada eklenti olarak kullanmak i├žin do─čru aray├╝z├╝ kullanan t├╝rler olup olmad─▒─č─▒n─▒ belirlemek bu durumlarda ├Ânemlidir.


35







Yans─▒ma, uygulama hakk─▒nda ├Ânceden bilgi sahibi olmadan ├žal─▒┼čma s─▒ras─▒nda dinamik olarak ├žal─▒┼čma s─▒ras─▒nda yeni nesnelerin somutla┼čt─▒r─▒lmas─▒na, y├Ântemlerin ├ža─čr─▒lmas─▒na ve s─▒n─▒f de─či┼čkenlerinde get / set i┼člemlerine izin verir.

 Class myObjectClass = MyObject.class;
Method[] method = myObjectClass.getMethods();

//Here the method takes a string parameter if there is no param, put null.
Method method = aClass.getMethod("method_name", String.class); 

Object returnValue = method.invoke(null, "parameter-value1");
 

Yukar─▒daki ├Ârnekte, null parametresi, y├Ântemi ├ža─č─▒rmak istedi─činiz nesnedir. Metot statik ise null sa─člay─▒n. E─čer y├Ântem statik de─čilse, ├ža─č─▒r─▒rken null yerine ge├žerli bir MyObject ├Ârne─či vermeniz gerekir.

Yans─▒tma ayr─▒ca, bir s─▒n─▒f─▒n ├Âzel ├╝yesine / y├Ântemlerine eri┼čmenizi sa─člar:

 public class A{

  private String str= null;

  public A(String str) {
  this.str= str;
  }
}
 

.

 A obj= new A("Some value");

Field privateStringField = A.class.getDeclaredField("privateString");

//Turn off access check for this field
privateStringField.setAccessible(true);

String fieldValue = (String) privateStringField.get(obj);
System.out.println("fieldValue = " + fieldValue);
 
  • S─▒n─▒flar─▒n incelenmesi i├žin (ayr─▒ca inceleme olarak da bilinir) yans─▒ma paketini ( java.lang.reflect ) i├že aktarman─▒z gerekmez . S─▒n─▒f meta verilerine eri┼čilebilir java.lang.Class .

Yans─▒tma ├žok g├╝├žl├╝ bir API'dir, ancak ├žal─▒┼čma zaman─▒ndaki t├╝m t├╝rleri ├ž├Âzd├╝─č├╝ i├žin a┼č─▒r─▒ kullan─▒l─▒rsa uygulamay─▒ yava┼člatabilir.


33







Java Reflection olduk├ža g├╝├žl├╝ ve ├žok faydal─▒ olabilir. Java Reflection , derleme zaman─▒nda s─▒n─▒flar─▒n adlar─▒n─▒, y├Ântemlerini vb. Bilmeden ├žal─▒┼čma zaman─▒ndaki s─▒n─▒flar─▒, aray├╝zleri, alanlar─▒ ve y├Ântemleri incelemeyi m├╝mk├╝n k─▒lar . Yans─▒ma kullanarak yeni nesneleri ba┼člatmak, y├Ântemleri ├ža─č─▒rmak ve alan de─čerlerini almak / ayarlamak da m├╝mk├╝nd├╝r .

Yans─▒ma kullanman─▒n size neye benzedi─čini g├Âsteren h─▒zl─▒ bir Java Yans─▒mas─▒ ├Ârne─či:

 Method[] methods = MyObject.class.getMethods();

    for(Method method : methods){
        System.out.println("method = " + method.getName());
    }
 

Bu ├Ârnek, Class nesnesini MyObject adl─▒ s─▒n─▒ftan al─▒r. S─▒n─▒f nesnesini kullanarak, ├Ârnek o s─▒n─▒ftaki y├Ântemlerin bir listesini al─▒r, y├Ântemleri yineler ve adlar─▒n─▒ yazd─▒r─▒r.

Tam olarak t├╝m bu i┼čler burada nas─▒l a├ž─▒klanmaktad─▒r?

D├╝zenleme : Neredeyse 1 y─▒l sonra bu cevab─▒ de─či┼čtiriyorum, yans─▒ma hakk─▒nda okurken Reflection'dan daha az faydaland─▒m.

  • Yay, a┼ča─č─▒daki gibi fas├╝lye konfig├╝rasyonunu kullan─▒r:


 <bean id="someID" class="com.example.Foo">
    <property name="someField" value="someValue" />
</bean>
 

Spring ba─člam─▒ bu <bean> ├Â─česini i┼čledi─činde, bu s─▒n─▒f─▒ ba┼člatmak i├žin Class.forName (String) "com.example.Foo" arg├╝man─▒yla kullan─▒r.

Daha sonra <├Âzellik> eleman─▒ i├žin uygun ayarlay─▒c─▒y─▒ elde etmek i├žin yans─▒ma kullanacak ve de─čerini belirtilen de─čere ayarlayacakt─▒r.

  • Junit, ├Âzellikle ├ľzel / Korumal─▒ y├Ântemleri test etmek i├žin Yans─▒ma'y─▒ kullan─▒r.

├ľzel y├Ântemler i├žin

 Method method = targetClass.getDeclaredMethod(methodName, argClasses);
method.setAccessible(true);
return method.invoke(targetObject, argObjects);
 

├ľzel alanlar i├žin

 Field field = targetClass.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
 

21


2014-09-08





├ľrnek:

├ľrne─čin, uygulaman─▒za API Y├Ântemlerini kullanarak edindi─činiz bir nesneyi veren uzak bir uygulamay─▒ ele alal─▒m. ┼×imdi nesneyi temel alarak bir ├že┼čit hesaplama yapman─▒z gerekebilir.

Sa─člay─▒c─▒, bu nesnenin 3 tip olabilece─čini garanti eder ve ne t├╝r bir nesne temelinde hesaplama yapmam─▒z gerekir.

Bu y├╝zden, her biri farkl─▒ bir mant─▒k i├žeren 3 s─▒n─▒fa uygulayabiliriz. A├ž─▒k├žas─▒, nesne bilgisi ├žal─▒┼čma zaman─▒nda mevcuttur, bu nedenle hesaplama yapmak i├žin statik olarak kodlama yapamazs─▒n─▒z, bu nedenle yans─▒ma, hesaplamay─▒ ger├žekle┼čtirmek i├žin ihtiya├ž duydu─čunuz s─▒n─▒f─▒n nesnesini ba┼člatmak i├žin kullan─▒l─▒r. sa─člay─▒c─▒dan al─▒nan nesne.


21







Yans─▒ma , ├žal─▒┼čma zaman─▒nda y├Ântemlerin, s─▒n─▒flar─▒n, arabirimlerin davran─▒┼člar─▒n─▒ incelemek veya de─či┼čtirmek i├žin kullan─▒lan bir API'dir .

  1. Yans─▒ma i├žin gerekli s─▒n─▒flar alt─▒nda verilmi┼čtir java.lang.reflect package .
  2. Yans─▒ma bize bir nesnenin ait oldu─ču s─▒n─▒f ve ayn─▒ zamanda nesneyi kullanarak ger├žekle┼čtirilebilecek s─▒n─▒flar hakk─▒nda bilgi verir.
  3. Yans─▒ma yoluyla, ├žal─▒┼čma zaman─▒nda, bunlarla kullan─▒lan eri┼čim belirtecinden ba─č─▒ms─▒z olarak y├Ântemleri ├ža─č─▒rabiliriz.

java.lang Ve java.lang.reflect paketler java yans─▒mas─▒ i├žin s─▒n─▒flar─▒ sa─člar.

Yans─▒ma hakk─▒nda bilgi almak i├žin kullan─▒labilir -

  1. S─▒n─▒f getClass() Bir nesnenin ait oldu─ču s─▒n─▒f─▒n ad─▒n─▒ almak i├žin bu y├Ântem kullan─▒l─▒r.

  2. Yap─▒c─▒lar getConstructors() y├Ântem nesnesinin ait oldu─ču s─▒n─▒f─▒n genel kurucular elde etmek i├žin kullan─▒l─▒r.

  3. Y├Ântem getMethods() y├Ântem, nesnelerin ait oldu─ču s─▒n─▒f─▒n genel y├Ântemleri elde etmek i├žin kullan─▒l─▒r.

Reflection API esas olarak kullan─▒l─▒r:

IDE (T├╝mle┼čik Geli┼čtirme Ortam─▒) ├Ârne─čin Eclipse, MyEclipse, NetBeans vb.
Hata Ay─▒klay─▒c─▒ ve Test Ara├žlar─▒ vb.




Yans─▒ma Kullanman─▒n Avantajlar─▒:

Geni┼čletilebilirlik ├ľzellikleri: Bir uygulama, tam nitelikli adlar─▒n─▒ kullanarak geni┼čletilebilirlik nesnelerinin ├Ârnekleri olu┼čturarak, kullan─▒c─▒ taraf─▒ndan tan─▒mlanan harici s─▒n─▒flar─▒ kullanabilir.

Hata ay─▒klama ve test ara├žlar─▒: Hata ay─▒klay─▒c─▒lar, s─▒n─▒flardaki ├Âzel ├╝yeleri incelemek i├žin yans─▒ma ├Âzelli─čini kullan─▒r.

Dezavantajlar─▒:

Performans Tepeg├Âz├╝: Yans─▒t─▒c─▒ i┼člemler, yans─▒t─▒c─▒ olmayan emsallerinden daha yava┼č performans g├Âsterir ve performansa duyarl─▒ uygulamalarda s─▒k olarak adland─▒r─▒lan kod b├Âl├╝mlerinden ka├ž─▒n─▒lmal─▒d─▒r.

─░├žsellerin Maruz Kalmas─▒: Yans─▒t─▒c─▒ kod soyutlamalar─▒ bozar ve bu nedenle platformun y├╝kseltilmesiyle davran─▒┼č─▒n─▒ de─či┼čtirebilir.

Ref: Java Yans─▒ma javarevisited.blogspot.in


17







Yans─▒ma i├žin basit bir ├Ârnek. Bir satran├ž oyununda, kullan─▒c─▒ taraf─▒ndan ├žal─▒┼čma zaman─▒nda ne ta┼č─▒naca─č─▒n─▒ bilmiyorsunuz. Yans─▒ma, ├žal─▒┼čma zaman─▒nda zaten uygulanan y├Ântemleri ├ža─č─▒rmak i├žin kullan─▒labilir:

 public class Test {

    public void firstMoveChoice(){
        System.out.println("First Move");
    } 
    public void secondMOveChoice(){
        System.out.println("Second Move");
    }
    public void thirdMoveChoice(){
        System.out.println("Third Move");
    }

    public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException { 
        Test test = new Test();
        Method[] method = test.getClass().getMethods();
        //firstMoveChoice
        method[0].invoke(test, null);
        //secondMoveChoice
        method[1].invoke(test, null);
        //thirdMoveChoice
        method[2].invoke(test, null);
    }

}
 

17







Anlay─▒┼č─▒ma g├Âre:

Yans─▒tma, programc─▒n─▒n programdaki varl─▒klara dinamik olarak eri┼čmesini sa─člar. yani e─čer programc─▒ bir s─▒n─▒ftan veya onun y├Ântemlerinden habersizse, bir uygulamay─▒ kodlarken, bu s─▒n─▒ftan yans─▒ma kullanarak dinamik olarak (├žal─▒┼čma zaman─▒nda) faydalanabilir.

Bir s─▒n─▒f ad─▒n─▒n s─▒k s─▒k de─či┼čti─či senaryolarda s─▒kl─▒kla kullan─▒l─▒r. B├Âyle bir durum ortaya ├ž─▒karsa, programc─▒n─▒n uygulamay─▒ yeniden yazmas─▒ ve s─▒n─▒f─▒n ad─▒n─▒ tekrar tekrar de─či┼čtirmesi karma┼č─▒kt─▒r.

Bunun yerine, yans─▒ma kullanarak, muhtemelen de─či┼čen bir s─▒n─▒f ad─▒ i├žin endi┼čelenmeniz gerekir.


15







Yans─▒ma, program─▒n─▒z─▒n ├žal─▒┼čma zaman─▒ bilgisine eri┼čmenizi ve davran─▒┼č─▒n─▒ de─či┼čtirmenizi sa─člayan bir tak─▒m i┼člevdir (baz─▒ s─▒n─▒rlamalarla).

Bu, program─▒n─▒z─▒n meta bilgisine ba─čl─▒ olarak ├žal─▒┼čma zaman─▒n─▒ de─či┼čtirmenize izin verdi─či i├žin yararl─▒d─▒r, yani, bir i┼člevin d├Ân├╝┼č t├╝r├╝n├╝ kontrol edebilir ve durumu i┼čleme ┼čeklinizi de─či┼čtirebilirsiniz.

├ľrne─čin, C # 'da bir derleme (a .dll) ├žal─▒┼čma zaman─▒nda y├╝kleyebilir, inceleyebilir, s─▒n─▒flar aras─▒nda gezinebilir ve bulduklar─▒n─▒za g├Âre i┼člem yapabilirsiniz. Ayr─▒ca, ├žal─▒┼čma zaman─▒nda bir s─▒n─▒f ├Ârne─či olu┼čturman─▒z─▒, y├Ântemini ├ža─č─▒rman─▒z─▒ vb. Sa─člar.

Nerede yararl─▒ olabilir? Her zaman i┼če yaramaz, ancak somut durumlar i├žin faydal─▒d─▒r. ├ľrne─čin, oturum a├žma ama├žlar─▒ i├žin s─▒n─▒f─▒n ad─▒n─▒ almak, bir yap─▒land─▒rma dosyas─▒nda belirtilenlere g├Âre olaylar i├žin dinamik olarak i┼čleyiciler olu┼čturmak i├žin kullanabilirsiniz.


14







Yans─▒ma nesnenin g├Âr├╝n├╝┼č├╝n├╝ g├Ârmesine izin vermektir. Bu arg├╝man yans─▒ma ile ilgisi yok gibi g├Âr├╝n├╝yor. Asl─▒nda, bu "kendini tan─▒mlama" yetene─čidir.

Yans─▒man─▒n kendisi, Java ve C # olarak kendi kendini tan─▒ma ve kendini alg─▒lama yetene─čine sahip olmayan diller i├žin bir kelimedir. ├ľz-bilgi kabiliyetine sahip olmad─▒klar─▒ i├žin, nas─▒l g├Âr├╝nd├╝─č├╝n├╝ g├Âzlemlemek istedi─čimizde, nas─▒l g├Âr├╝nd├╝─č├╝n├╝ yans─▒tacak ba┼čka bir ┼čeyimiz olmal─▒. Ruby ve Python gibi m├╝kemmel dinamik diller, di─čer ki┼čilerin yard─▒m─▒ olmadan kendi yans─▒mas─▒n─▒ alg─▒layabilir. Java nesnesinin, yans─▒ma s─▒n─▒f─▒n─▒n bir nesnesi olan bir ayna olmadan nas─▒l g├Âr├╝nd├╝─č├╝n├╝ anlayamad─▒─č─▒n─▒ s├Âyleyebiliriz, ancak Python'daki bir nesne onu ayna olmadan alg─▒layabilir. Bu y├╝zden Java'da yans─▒maya ihtiyac─▒m─▒z var.


11







Sadece listelenenlerin t├╝m├╝ne bir nokta eklemek istiyorum.

Reflection API ile toString() herhangi bir nesne i├žin evrensel y├Ântem yazabilirsiniz .

Hata ay─▒klamada kullan─▒┼čl─▒d─▒r.

─░┼čte baz─▒ ├Ârnek:

 class ObjectAnalyzer {

   private ArrayList<Object> visited = new ArrayList<Object>();

   /**
    * Converts an object to a string representation that lists all fields.
    * @param obj an object
    * @return a string with the object's class name and all field names and
    * values
    */
   public String toString(Object obj) {
      if (obj == null) return "null";
      if (visited.contains(obj)) return "...";
      visited.add(obj);
      Class cl = obj.getClass();
      if (cl == String.class) return (String) obj;
      if (cl.isArray()) {
         String r = cl.getComponentType() + "[]{";
         for (int i = 0; i < Array.getLength(obj); i++) {
            if (i > 0) r += ",";
            Object val = Array.get(obj, i);
            if (cl.getComponentType().isPrimitive()) r += val;
            else r += toString(val);
         }
         return r + "}";
      }

      String r = cl.getName();
      // inspect the fields of this class and all superclasses
      do {
         r += "[";
         Field[] fields = cl.getDeclaredFields();
         AccessibleObject.setAccessible(fields, true);
         // get the names and values of all fields
         for (Field f : fields) {
            if (!Modifier.isStatic(f.getModifiers())) {
               if (!r.endsWith("[")) r += ",";
               r += f.getName() + "=";
               try {
                  Class t = f.getType();
                  Object val = f.get(obj);
                  if (t.isPrimitive()) r += val;
                  else r += toString(val);
               } catch (Exception e) {
                  e.printStackTrace();
               }
            }
         }
         r += "]";
         cl = cl.getSuperclass();
      } while (cl != null);

      return r;
   }    
}
 

10







Java dok├╝mantasyon sayfas─▒ndan

java.lang.reflect paket, s─▒n─▒flar ve nesneler hakk─▒nda yans─▒t─▒c─▒ bilgiler elde etmek i├žin s─▒n─▒flar ve aray├╝zler sa─člar. Yans─▒tma, y├╝klenen s─▒n─▒flar─▒n alanlar─▒, y├Ântemleri ve yap─▒c─▒lar─▒ ve yans─▒t─▒lan alanlar─▒n, y├Ântemlerin ve yap─▒c─▒lar─▒n, g├╝venlik k─▒s─▒tlamalar─▒ dahilindeki temel meslekta┼člar─▒ ├╝zerinde ├žal─▒┼čmak i├žin kullan─▒lmas─▒ hakk─▒nda bilgilere programatik eri┼čim sa─člar.

AccessibleObject gerekli ReflectPermission olmas─▒ halinde eri┼čim kontrollerinin engellenmesine izin verir .

─░le birlikte bu pakette S─▒n─▒flar, java.lang.Class b├Âyle debugger'lar, terc├╝manlar, nesne m├╝fetti┼čleri, s─▒n─▒f taray─▒c─▒lar ve gibi hizmetleri gibi uygulamalar bar─▒nd─▒rmak Object Serialization ve JavaBeans bir hedef nesnenin kamu ├╝yelerine ya o ihtiyac─▒ eri┼čimi (kendi ├žal─▒┼čma zaman─▒ s─▒n─▒f─▒na g├Âre) veya ├╝yeleri taraf─▒ndan ilan verilen bir s─▒n─▒f

A┼ča─č─▒daki i┼člevselli─či i├žerir.

  1. S─▒n─▒f nesnelerinin elde edilmesi,
  2. Bir s─▒n─▒f─▒n ├Âzelliklerinin incelenmesi (alanlar, y├Ântemler, yap─▒c─▒lar),
  3. Alan de─čerlerini belirlemek ve almak,
  4. ├ça─č─▒rma y├Ântemleri
  5. Yeni nesne ├Ârnekleri olu┼čturma.

S─▒n─▒f taraf─▒ndan maruz b─▒rak─▒lan y├Ântemler i├žin bu dok├╝mantasyon ba─člant─▒s─▒na bir g├Âz at─▒n Class .

Bu makaleden (Dennis Sosnoski, Sosnoski Yaz─▒l─▒m ├ç├Âz├╝mleri, Inc Ba┼čkan─▒) ve bu makaleden (g├╝venlik ara┼čt─▒rmalar─▒ pdf):

Reflection kullan─▒m─▒ndan ├žok dezavantajlar g├Ârebiliyorum

Yans─▒ma Kullan─▒c─▒s─▒:

  1. Program bile┼čenlerini dinamik olarak ba─člamak i├žin ├žok y├Ânl├╝ bir yol sa─člar
  2. Nesnelerle ├žok genel yollarla ├žal─▒┼čan k├╝t├╝phaneler olu┼čturmak i├žin kullan─▒┼čl─▒d─▒r.

Yans─▒ma Dezavantajlar─▒:

  1. Alan ve y├Ântem eri┼čimi i├žin kullan─▒ld─▒─č─▒nda yans─▒ma do─črudan koddan daha yava┼čt─▒r.
  2. Kodunuzda ger├žekte neler olup bitti─čini gizleyebilir
  3. Kaynak kodunu atlar bak─▒m sorunlar─▒ yaratabilir
  4. Yans─▒tma kodu ayn─▒ zamanda ilgili do─črudan koddan daha karma┼č─▒kt─▒r.
  5. Veri eri┼čim korumas─▒ ve t├╝r g├╝venli─či gibi temel Java g├╝venlik k─▒s─▒tlamalar─▒n─▒n ihlal edilmesini sa─člar

Genel suiistimaller:

  1. S─▒n─▒rl─▒ s─▒n─▒flar─▒n y├╝klenmesi,
  2. K─▒s─▒tl─▒ bir s─▒n─▒f─▒n yap─▒c─▒lar─▒na, y├Ântemlerine veya alanlar─▒na referans alma,
  3. Yeni nesne ├Ârnekleri olu┼čturma, y├Ântemleri ba┼člatma, k─▒s─▒tlanm─▒┼č bir s─▒n─▒f─▒n alan de─čerlerini alma veya ayarlama.

Yans─▒ma ├Âzelli─činin k├Ât├╝ye kullan─▒lmas─▒yla ilgili bu SE soruya bir g├Âz at─▒n:

Java'da ├Âzel bir alan─▒ nas─▒l okurum?

├ľzet:

Bir sistem kodundan y├╝r├╝t├╝len i┼člevlerinin g├╝vensiz kullan─▒m─▒ da kolayca bir Java g├╝venlik modunun uzla┼čmas─▒na yol a├žabilir . Yani bu ├Âzelli─či az miktarda kullan─▒n


9







Ad─▒ndan da anla┼č─▒laca─č─▒ gibi, ├žal─▒┼čma zaman─▒nda dinamik olarak ├Ârnek olu┼čturma y├Ântemini ├ža─č─▒rmak i├žin ├Âzellik sa─člama d─▒┼č─▒nda, s─▒n─▒f y├Ântemi vb.

Ah┼čab─▒n alt─▒ndaki bir├žok ├žer├ževe ve uygulama taraf─▒ndan, ger├žekte kodu bilmeden hizmet ├ža─č─▒rmak i├žin kullan─▒l─▒r.


9







Yans─▒ma size daha genel kod yazma yetene─či verir. ├çal─▒┼čma zaman─▒nda bir nesne olu┼čturman─▒za ve ├žal─▒┼čma zaman─▒nda onun y├Ântemini ├ža─č─▒rman─▒za olanak tan─▒r. Dolay─▒s─▒yla program olduk├ža parametreli hale getirilebilir. Ayr─▒ca, nesnenin ve s─▒n─▒f─▒n d─▒┼č d├╝nyaya maruz kalan de─či┼čkenlerini ve y├Ântemini tespit etmesine izin verir.


7







Reflection bir├žok kullan─▒m alan─▒ vard─▒r . Daha a┼čina oldu─čum, an─▒nda kod olu┼čturabilmek.

IE: dinamik s─▒n─▒flar, fonksiyonlar, yap─▒c─▒lar - herhangi bir verilere dayanarak (xml / array / sql results / hardcoded / etc ..)


6







Bu soruya ├Ârnek olarak cevap vermek istiyorum. Her ┼čeyden ├Ânce Hibernate proje , ├žal─▒┼čan uygulama ile kal─▒c─▒l─▒k deposu aras─▒ndaki u├žurumun k├Âpr├╝lenmesi i├žin ifadeler Reflection API ├╝retmek CRUD i├žin kullan─▒r . Etki alan─▒nda bir ┼čeyler de─či┼čti─činde, Hibernate onlar─▒ veri deposuna s├╝rd├╝rebilmeleri ve bunun tersi de bilmek zorundad─▒r.

Alternatif olarak ├žal─▒┼č─▒r Lombok Project . Derleme zaman─▒nda yaln─▒zca kodu enjekte eder, kodun etki alan─▒ s─▒n─▒flar─▒n─▒za eklenmesiyle sonu├žlan─▒r. (Ben al─▒c─▒lar ve ayarlay─▒c─▒lar i├žin tamam oldu─čunu d├╝┼č├╝n├╝yorum)

Hibernate reflection bir uygulama i├žin olu┼čturma i┼člemi ├╝zerinde ├žok az etkisi oldu─ču i├žin se├žti .

Ve Java 7'den bizde oldu─ču MethodHandles gibi ├žal─▒┼č─▒yoruz Reflection API . Projelerde, loggerlerle ├žal─▒┼čmak i├žin bir sonraki kodu kopyalay─▒p yap─▒┼čt─▒r─▒yoruz:

 Logger LOGGER = Logger.getLogger(MethodHandles.lookup().lookupClass().getName());
 

Çünkü bu durumda yazım hatası yapmak zor.


3







├ľrnek olarak a├ž─▒klamay─▒ en iyi buldu─čum gibi, cevaplar─▒n hi├žbiri de ├Âyle g├Âr├╝nm├╝yor ...

Yans─▒malar─▒ kullanman─▒n pratik bir ├Ârne─či, Java'da yaz─▒lm─▒┼č bir Java Dil Sunucusu veya PHP'de yaz─▒lm─▒┼č bir PHP Dil Sunucusu olabilir. Yazarken olas─▒ t├╝m e┼čle┼čmeleri g├Âstermek i├žin t├╝m etiket adlar─▒n─▒n (otomatik olarak tamamlanabilen kelimeler) sahip olmas─▒ i├žin, Dil Sunucusu'nun, doc bloklar─▒ ve ├Âzel ├╝yeler dahil olmak ├╝zere s─▒n─▒fla ilgili her ┼čeyi incelemesi gerekir. Bunun i├žin s├Âz konusu s─▒n─▒f─▒n bir yans─▒mas─▒na ihtiyac─▒ var.

Farkl─▒ bir ├Ârnek, ├Âzel bir y├Ântemin birim testi olabilir. Bunu yapman─▒n bir yolu, bir yans─▒ma olu┼čturmak ve testin kurulum a┼čamas─▒nda y├Ântemin kapsam─▒n─▒ halka a├ž─▒klamakt─▒r. Tabii ki ki┼či ├Âzel y├Ântemlerin do─črudan test edilmemesi gerekti─čini, ancak mesele bu olmad─▒─č─▒n─▒ iddia edebilir.


3


2019-04-26