Was ist Reflexion und warum ist es nützlich?

Question

Was ist Reflexion, und warum ist es nützlich?

Ich bin besonders daran interessiert, in Java, aber ich nehme an, die Prinzipien sind die gleichen in jeder Sprache.

Answer 1

Der name der Reflexion ist verwendet, um zu beschreiben, code, die ist in der Lage zu inspizieren anderen code im selben system (oder sich selbst).

Zum Beispiel, sagen, Sie haben ein Objekt von einer unbekannten Typ in Java, und wenn Sie möchten, zu nennen, 'doSomething' - Methode auf, wenn eine vorhanden ist.Javas statische Typisierung system ist nicht wirklich entworfen, um dies zu unterstützen, es sei denn, das Objekt erfüllt die Schnittstelle bekannt, aber die Verwendung von reflektion, Ihren code betrachten Sie das Objekt an und finden heraus, ob es eine Methode namens "doSomething" und dann nennen Sie es, wenn Sie möchten.

Also, geben Sie ein code-Beispiel in Java (man Stelle sich das Objekt in Frage, foo) :

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

Ein sehr häufiger Anwendungsfall in Java ist die Verwendung mit Anmerkungen.JUnit 4, für Beispiel, werden mithilfe von reflektion schauen Sie durch Ihre Klassen für Methoden tagged mit der @Test-annotation, und dann rufen Sie beim ausführen der unit-test.

Es gibt einige gute Reflexion Beispiele um Ihnen den Einstieg in http://docs.oracle.com/javase/tutorial/reflect/index.html

Und schließlich, ja, aber die Konzepte sind ähnlich wie in anderen statisch Arten Sprachen, die Unterstützung der reflektion (C#).In dynamisch typisierten Sprachen, ist die Verwendung oben beschriebenen Fall ist weniger notwendig (da der compiler erlauben keine Methode aufgerufen werden, auf ein Objekt, andernfalls wird zur Laufzeit, wenn es nicht existiert), aber der zweite Fall, auf der Suche nach Methoden, die gekennzeichnet sind oder eine bestimmte Arbeitsweise ist immer noch üblich.

Update aus einem Kommentar:

Die Fähigkeit, prüfen Sie den code in das system und sehen Objekttypen nicht Reflexion, sondern Geben die Selbstbeobachtung.Reflexion ist dann die Fähigkeit, änderungen zur Laufzeit durch die Verwendung von Introspektion.Die Unterscheidung ist hier notwendig, da einige Sprachen support Introspektion, aber nicht unterstützen die Reflexion.Ein Beispiel ist C++

Answer 2

Reflexion ist eine Sprache, die Fähigkeit zu kontrollieren und dynamisch aufrufen, Klassen, Methoden, Attribute, etc.zur Laufzeit.

Zum Beispiel, alle Objekte in Java die Methode getClass(), können Sie bestimmen Klasse des Objekts, auch wenn Sie nicht wissen, die es zur Kompilierzeit (z.B.wenn Sie deklarierten es als Object) - dies mag trivial erscheinen, aber eine solche Reflexion ist nicht möglich, in weniger dynamische Sprachen wie C++.Mehr advanced verwendet, können Sie die Liste und rufen Methoden, Konstruktoren, etc.

Reflexion ist wichtig, denn hier können Sie Programme schreiben, die nicht an "wissen" alles, was zur compile-Zeit, sodass Sie mehr Dynamik, weil Sie zusammen gebunden zur Laufzeit.Der code kann geschrieben werden gegen bekannte Schnittstellen, aber die tatsächlichen Klassen verwendet werden, die instanziiert werden können, mithilfe von reflektion von Konfigurationsdateien.

Viele moderne frameworks verwenden, Reflexion ausgiebig aus diesem Grund.Die meisten anderen modernen Sprachen, die reflektion verwenden, als auch, und in scripting-Sprachen (z.B. Python) sind Sie sogar stärker integriert, da fühlt es sich natürlicher in die Allgemeine Programmierung Modell dieser Sprachen.

Answer 3

Einer meiner Favoriten, verwendet der Reflexion der unten Java-dump-Methode.Es dauert ein beliebiges Objekt als parameter und verwendet die Java-reflection-API zu drucken Sie alle Felder name und Wert.

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();
}

Answer 4

Verwendet der Reflexion

Reflexion wird Häufig von Programmen verwendet, die die Fähigkeit erfordern, zu prüfen oder zu ändern, die das Laufzeitverhalten von Anwendungen in die Java virtual machine.Dies ist eine relativ fortgeschrittene Funktion und sollte verwendet werden nur für Entwickler, die ein hohes Verständnis für die Grundlagen der Sprache.Mit dieser Warnung im Hinterkopf, Reflexion ist eine leistungsstarke Technik und können Anwendungen aktivieren, die Vorgänge ausführen, die sonst nicht möglich wären.

Erweiterungsmöglichkeiten

Eine Anwendung kann sich der externe benutzerdefinierte Klassen erstellen von Instanzen der Erweiterbarkeit Objekte mit Ihren vollständig qualifizierten Namen.Klasse Browser und Visuellen Entwicklungsumgebungen Ein Klasse browser muss in der Lage sein aufzählen, die Mitglieder von Klassen.Visuelle Entwicklungsumgebungen profitieren vom Typ verfügbaren Informationen in der Reflexion zur Unterstützung der Entwickler, schriftlich richtigen code.Debugger und Test-Tools Debugger müssen in der Lage sein, zu prüfen, private Mitglieder in Klassen.Test-harnesses können machen verwenden der Reflexion systematisch Aufruf einer erkennbar set-APIs in einer Klasse definiert, zu gewährleisten eine hohe code coverage in a test suite.

Nachteile der Reflexion

Reflexion ist mächtig, aber sollte nicht wahllos verwendet werden.Wenn es möglich ist, einen Vorgang auszuführen, ohne die Verwendung von reflektion, dann ist es besser zu vermeiden, es zu benutzen.Die folgenden Bedenken sollte gehalten werden in Geist, wenn der Zugriff von code per Reflexion.

• Performance-Overhead

Da reflektion umfasst die Arten, die dynamisch aufgelöst, bestimmte Java-virtual-machine-Optimierungen können nicht durchgeführt werden.Folglich, reflektierende Operationen wesentlich langsamer sind als Ihre nicht-reflektierende Kollegen und sollte vermieden werden in Abschnitte von code, die aufgerufen werden Häufig in performance-kritischen Anwendungen.

• Sicherheits-Beschränkungen

Reflexion erfordert eine runtime-Berechtigung, die möglicherweise nicht anwesend sein, wenn unter einem Sicherheits-manager.Dies ist ein wichtiger Aspekt für die code, die hat zu laufen, in einem beschränkten Sicherheitskontext, wie in einem Applet.

• Exposition Interna

Da die Reflexion an, die dem code für Operationen, die illegal wäre, in nicht-reflektierende-code, wie den Zugriff auf private Felder und Methoden, die Verwendung von Reflexion kann dazu führen, unerwartete Nebenwirkungen, die möglicherweise dazu, dass der code dysfunktional und zerstören kann Portabilität.Reflektierende code bricht Abstraktionen und daher können sich ändern Verhalten mit upgrades der Plattform.

Quelle: Die Reflection-API

Answer 5

Reflexion ist ein wichtiger Mechanismus, damit eine Anwendung oder ein framework für die Arbeit mit code, der möglicherweise nicht einmal geschrieben worden, doch!

Nehmen Sie zum Beispiel Ihre typische web.xml Datei.Diese enthält eine Liste von servlet-Elementen, die Ineinander verschachtelt servlet-Klasse-Elementen.Der servlet container Prozess der web.xml Datei und neu erstellen Sie eine neue Instanz von jedem servlet-Klasse durch Reflexion.

Ein weiteres Beispiel wäre die Java-API für XML-Parsing (JAXP).Wo ein XML-parser Anbieter ist 'plugged-in' über die bekannten Eigenschaften, die verwendet werden, um den Bau neuer Instanzen durch Reflexion.

Und schließlich, das umfassendste Beispiel ist Frühling was nutzt die Reflexion zu schaffen, die Bohnen, und für Ihren starken Einsatz von proxies

Answer 6

Nicht jede Sprache unterstützt die Reflexion, sondern die Prinzipien sind in der Regel die gleichen, die in Sprachen, die Sie unterstützen.

Reflexion ist die Fähigkeit zu "spiegeln" auf die Struktur des Programms.Oder noch konkreter.Blick auf die Objekte und Klassen, die Sie haben und programmgesteuert erhalten Informationen über die Methoden, Felder und die Schnittstellen, die Sie implementieren.Sie können auch auf Dinge wie Anmerkungen.

Es ist nützlich in vielen Situationen.Überall Sie wollen zu werden in der Lage, dynamisch-plug-in-Klassen in Ihren code.Eine Menge von Objekt-relationalen Mapper verwenden Sie Reflexion in der Lage sein, um Objekte zu instanziieren von Datenbanken, ohne im Voraus zu wissen, welche Objekte Sie gehen zu verwenden.Plug-in-Architekturen ist ein weiterer Ort, wo Reflexion ist nützlich.Werden in der Lage, das dynamische laden von code und festzustellen, ob es Typen gibt, die bei der Umsetzung des rechts-Schnittstelle zur Nutzung als plugin ist wichtig, in diesen Situationen.

Answer 7

Reflexion ermöglicht Instanziierung von neuen Objekten, Aufruf von Methoden und get/set-Operationen auf Klassen-Variablen dynamisch zur Laufzeit, ohne Vorwissen an der Umsetzung.

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");

Im obigen Beispiel ist der parameter null ist das Objekt, das Sie aufrufen möchten die Methode auf.Wenn die Methode statisch ist, liefern Sie null.Wenn die Methode nicht statisch ist, dann bei Aufruf müssen Sie ein gültiges MyObject-Instanz anstelle von null.

Reflexion ermöglicht Ihnen den Zugriff auf private member/Methoden einer Klasse:

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);

• Für die Inspektion von Klassen (auch Selbstbeobachtung), die Sie nicht brauchen, um den import der Reflexion-Paket (java.lang.reflect).Klasse Metadaten zugegriffen werden kann durch java.lang.Class.

Reflexion ist eine sehr leistungsstarke API, aber es kann verlangsamen die Anwendung verwendet, wenn im übermaß, als es löst alle die Typen zur Laufzeit.

Answer 8

Beispiel :
Nehmen Sie zum Beispiel eine remote-Anwendung gibt Ihrer Anwendung ein Objekt, das Sie erhalten über Ihre API-Methoden .Jetzt auf der Basis des Objekt möglicherweise müssen Sie irgendeine Art von Berechnung .
Der Anbieter gewährleistet, dass die Objekt kann 3 Arten und wir müssen, führen Sie die Berechnung basiert auf dem, was Art von Objekt .
So könnten wir implementieren in 3 Klassen, mit jeweils einer unterschiedlichen Logik .Offensichtlich ist die Objekt-Informationen ist verfügbar in runtime, so dass Sie nicht statisch-code ausführen Berechnung daher ist die Reflexion instanziiert das Objekt der Klasse, die Sie benötigen, um führen Sie die Berechnung auf der Basis des Objekt erhalten vom Anbieter .

Answer 9

Java-Reflektion ist sehr mächtig und kann sehr nützlich sein.Java Reflexion macht es möglich prüfen Klassen, Schnittstellen, Felder und Methoden zur Laufzeit ohne zu wissen, die Namen von Klassen, Methoden usw..zur compile-Zeit.Es ist auch möglich, instanziieren Sie neue Objekte, Methoden aufgerufen werden, und get/set-Feld-Werte mithilfe von reflektion.

Eine schnelle Java-Reflexion Beispiel, Ihnen zu zeigen, was mit der spiegelung aussieht:

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

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

In diesem Beispiel erhält das Class-Objekt von der Klasse " MyObject.Mit dem class-Objekt das Beispiel wird eine Liste mit den Methoden in dieser Klasse, iteriert die Methoden und drucken Sie Ihre Namen.

Wie genau all das funktioniert, wird hier erklärt

Bearbeiten:Nach fast 1 Jahr bin ich Bearbeite diese Antwort als beim Lesen über Reflexion bekam ich einige weitere Verwendungen der Reflexion.

• Spring verwendet bean-Konfiguration wie:

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

Wenn der Frühling Rahmen dieser Prozesse < bean > - element verwenden, wird Klasse.forName(String) mit dem argument "com.Beispiel."Foo" zu instanziieren Sie diese Klasse.

Es wird dann wieder reflektion verwenden, um die entsprechenden setter für die < property > - element, und legen Sie dessen Wert auf den angegebenen Wert.

• Junit verwendet Reflektion, vor allem für die Prüfung von Privaten/Geschützten Methoden.

Für Private Methoden,

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

Für private Felder,

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

Answer 10

Wie pro mein Verständnis:

Reflexion ermöglicht Programmierer Zugriff auf Entitäten im Programm dynamisch.d.h.während der Codierung einer Anwendung, wenn die Programmierer ist nicht bewusst darüber, eine Klasse oder Methoden, kann er diese Klasse dynamisch (zur Laufzeit) mit Reflexion.

Es wird Häufig in Szenarien verwendet, in denen der name einer Klasse ändert sich Häufig.Wenn eine solche situation Eintritt, dann ist es kompliziert für den Programmierer zu schreiben die Anwendung, und ändern den Namen der Klasse wieder und wieder.

Stattdessen mithilfe von reflektion, es ist Notwendigkeit zu sorgen über eine eventuell ändern-Klasse Namen.

Answer 11

Reflexion ist eine API, die verwendet wird, zu prüfen oder zu ändern, das Verhalten der Methoden, Klassen, Schnittstellen zur Laufzeit.

1. Benötigten Klassen für Reflexion finden Sie unter: java.lang.reflect package.
2. Reflexion gibt uns Informationen darüber, in welche Klasse ein Objekt gehört, und auch die Methoden dieser Klasse, die ausgeführt werden können, indem das Objekt.
3. Durch Reflexion können wir uns aufrufen von Methoden zur Laufzeit unabhängig von der zugriffsspezifizierer bei Ihnen eingesetzt.

Die java.lang und java.lang.reflect Pakete Klassen für java-Reflexion.

Reflexion verwendet werden können, um Informationen zu bekommen über –

1. Klasse Die getClass() Methode wird verwendet, um den Namen der Klasse, zu der ein Objekt gehört.

2. Konstruktoren Die getConstructors() Methode wird verwendet, um die öffentlichen Konstruktoren der Klasse, zu der ein Objekt gehört.

3. Methoden Die getMethods() Methode wird verwendet, um die öffentlichen Methoden der Klasse, zu der ein Objekt gehört.

Die Der Reflection-API wird hauptsächlich verwendet in:

IDE (Integrated Development Environment), z.B.Eclipse, MyEclipse, NetBeans etc.
Debugger und Test-Tools, etc.

Vorteile der Verwendung von Reflexion:

Erweiterungsmöglichkeiten: Eine Anwendung kann sich der externe benutzerdefinierte Klassen erstellen von Instanzen der Erweiterbarkeit Objekte mit Ihren vollständig qualifizierten Namen.

Debugging-und Test-tools: Debugger verwenden Sie die Eigenschaft der Reflexion zu untersuchen, private Mitglieder, die auf Klassen.

Nachteile:

Systemleistung: Reflektierende Operationen wesentlich langsamer sind als Ihre nicht-reflektierende Kollegen und sollte vermieden werden, in Abschnitte von code, die aufgerufen werden Häufig in performance-kritischen Anwendungen.

Die Exposition der Innenteile: Reflektierende code bricht Abstraktionen und daher kann die Veränderung des Verhaltens mit den upgrades der Plattform.

Ref: Java Reflexion javarevisited.blogspot.in

Answer 12

Reflexion ist eine Sammlung von Funktionen, die ermöglicht den Zugriff auf die runtime-Informationen zu Ihrem Programm, und ändern Sie das Verhalten (mit einigen Einschränkungen).

Es ist nützlich, weil es ermöglicht Sie zu ändern die Laufzeit behaivour je nach meta-Informationen zu Ihrem Programm, dass ist, Sie können überprüfen die return-Typ einer Funktion und die Art und Weise ändern Sie die situation im Griff.

In C# zum Beispiel können Sie laden Sie eine assembly (eine .dll) in runtime ein untersuchen es, die Navigation durch die Klassen und der Durchführung von Maßnahmen nach dem, was Sie gefunden haben.Darüber hinaus können Sie erstellen eine Instanz von einer Klasse zur Laufzeit, rufen Sie seine Methode, etc.

Wo kann es nützlich sein?Ist nicht hilfreich, jedes mal, aber für konkrete Situationen.Für Beispiel, Sie können es verwenden, um den Namen der Klasse, die für Login-Zwecke, dinamically erstellen Sie Ereignishandler für die Ereignisse nach, was ist angegeben auf eine Konfigurationsdatei und so weiter...

Answer 13

einfaches Beispiel für die Reflexion.In einem Schach-Spiel, Sie wissen nicht, was verschoben werden, indem der Benutzer zur Laufzeit.Reflexion genutzt werden kann, um Methoden aufzurufen, die bereits zur Laufzeit implementiert.

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);
    }

}

Answer 14

Reflexion ist es, dass Objekt zu sehen, Ihre Erscheinung.Dieses argument scheint nichts zu tun mit Reflexion.In der Tat, dies ist ein "sich-identifizieren" - Fähigkeit.

Die Reflexion selbst ist ein Begriff für solche Sprachen, die nicht über die Fähigkeit der selbst-Erkenntnis und selbst-sensing-wie Java und C#.Weil Sie nicht die Fähigkeit der Selbsterkenntnis, wenn wir wollen, zu beobachten, wie es aussieht, müssen wir eine andere Sache, darüber nachzudenken, wie es aussieht.Ausgezeichnete dynamische Sprachen wie Ruby und Python wahrnehmen kann, die Reflexion der eigenen ohne die Hilfe von anderen Personen.Wir können sagen, dass das Objekt von Java kann nicht wahrnehmen, wie es aussieht, ohne einen Spiegel, der ein Objekt der Reflexion-Klasse, sondern ein Objekt in Python können Sie wahrnehmen, ohne Spiegel.Also, warum brauchen wir Reflexion in Java.

Answer 15

Ich möchte nur hinzufügen, dass einige Punkt, um alle, die aufgelistet wurde.

Mit Der Reflection-API Sie können schreiben, universal toString() Methode für jedes Objekt.

Es ist hilfreich beim Debuggen.

Hier finden Sie einige Beispiel:

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;
   }    
}

Answer 16

Aus der java-Dokumentation Seite

java.lang.reflect Paket stellt Klassen und Schnittstellen, die für den Erhalt der reflektierenden Informationen über Klassen und Objekte.Reflexion ermöglicht den programmgesteuerten Zugriff auf Informationen über die Felder, Methoden und Konstruktoren der geladenen Klassen und die Nutzung des reflektierten Felder, Methoden und Konstruktoren zu bedienen auf Ihre zugrunde liegenden Kollegen, innerhalb von Sicherheits-Einschränkungen.

AccessibleObject ermöglicht die Unterdrückung der Zugriff prüft, ob die erforderlichen ReflectPermission verfügbar ist.

Klassen in diesem Paket zusammen mit java.lang.Class Platz für Anwendungen wie Debugger, Interpreter, Objekt Inspektoren, class-Browser, und Dienste wie Object Serialization und JavaBeans zugreifen müssen, um entweder die öffentlichen Mitglieder einer target-Objekt basierend auf seiner Laufzeit-Klasse) oder den Mitgliedern erklärt, die von einer bestimmten Klasse

Es umfasst die folgenden Funktionen.

1. Beschaffung von Class-Objekten,
2. Prüfung der Eigenschaften der Klasse (Felder, Methoden, Konstruktoren),
3. Festlegen und abrufen von Feldwerten,
4. Aufrufen von Methoden,
5. Das erstellen neuer Instanzen von Objekten.

Haben Sie einen Blick auf diese Dokumentation link für die Methoden, die Class Klasse.

Aus diesem Artikel (von Dennis Sosnoski, Präsident, Sosnoski Software-Lösungen, Inc) und das Artikel (Sicherheits-Erkundungen pdf):

Ich kann sehen, erhebliche Nachteile als verwendet der Verwendung von Reflexion

Benutzer der Reflexion:

1. Es bietet sehr vielseitige Art und Weise dynamisch Verknüpfung von Programm-Komponenten
2. Es ist nützlich für die Erstellung von Bibliotheken, die die Arbeit mit Objekten in sehr allgemeiner Weise

Nachteile der Reflexion:

1. Reflexion ist viel langsamer als direkten code, wenn Sie für die Feld-und die Methode zugreifen.
2. Es kann verschleiern, was tatsächlich in Ihrem code
3. Es umgeht den source-code erstellen können, der Wartung Probleme
4. Reflexion-code ist auch komplexer als die entsprechenden direkten code
5. Es ermöglicht Verletzung wesentlicher Java-Sicherheits-Beschränkungen als data-access-Schutz und Sicherheit geben

Allgemeine Missbrauch:

1. Laden von Klassen beschränkt,
2. Einholung von Referenzen auf Konstruktoren, Methoden, Felder oder eine bestimmte Klasse,
3. Schaffung neuer Objekt-Instanzen, Methoden-Aufruf, abrufen oder festlegen von Feldwerten einer eingeschränkten Klasse.

Haben Sie einen Blick auf diese SE Frage über den Missbrauch der Reflexion feature:

Wie lese ich ein privates Feld in Java?

Zusammenfassung:

Unsichere Nutzung Ihrer Funktionen, die von innerhalb eines Systems code kann auch leicht dazu führen, dass der Kompromiss einer Java-security-Modusl. So verwenden Sie diese Funktion sparsam

Answer 17

Wie der name selbst vermuten, es reflektiert, was es hält zum Beispiel Klasse, Methode,etc. neben der Funktion invoke-Methode erstellen Instanz dynamisch zur Laufzeit.

Es wird von vielen frameworks und-Anwendung unter der Holz-Dienste aufgerufen werden, ohne eigentlich zu wissen, die code.

Answer 18

Reflection hat viele verwendet.Die, die ich bin mehr vertraut mit, ist in der Lage zu schaffen code on the fly.

IE:dynamische Klassen, Funktionen, Konstruktoren - basierend auf Daten (xml/array/sql-Ergebnisse/hardcoded/etc..)

Answer 19

Reflexion gibt Ihnen die Möglichkeit, mehr zu schreiben generischen code.Es ermöglicht Ihnen das erstellen eines Objekts zur Laufzeit und rufen die Methode zur Laufzeit.Damit das Programm kann gemacht werden sehr parametriert werden.Es ermöglicht auch, introspecting das Objekt und Klasse, um zu erkennen, seine Variablen und Methode ausgesetzt, die die äußere Welt.

Answer 20

Ich möchte diese Frage zu beantworten, durch sein Beispiel.Erste von alle Hibernate Projekt verwendet Reflection API zu generieren CRUD Aussagen zur überbrückung der Kluft zwischen der Anwendung und dem persistenten Speicher.Wenn die Dinge ändern sich in der Domäne, die Hibernate muss wissen, über Sie zu persistieren, um die Daten zu speichern, und Umgekehrt.

Alternativ funktioniert Lombok Project.Es ist einfach spritzt code zur compile-Zeit, das Ergebnis in den code eingefügt werden in Ihrem domain-Klassen.(Ich denke, es ist OK für Getter und setter)

Hibernate wählte reflection denn es hat nur minimale Auswirkungen auf den build-Prozess für eine Anwendung.

Und von Java 7 haben wir MethodHandles, die als Reflection API.In Projekten mit zu arbeiten Holzfäller, die wir nur kopieren und fügen Sie den folgenden code:

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

Weil es schwer zu machen typo-Fehler in diesem Fall.

Answer 21

Wie finde ich am besten, um beispielsweise zu erklären und keine der Antworten scheint zu tun...

Ein praktisches Beispiel für die Verwendung von Reflexionen wäre eine Java Language Server, geschrieben in Java oder PHP-Server, geschrieben in PHP, etc.Sprache-Server gibt Ihre IDE-Fähigkeiten wie Autovervollständigung, Sprung zu definition, Kontext-Hilfe, hinting Arten und mehr.Um alle tag-Namen (Wörter, die können werden automatisch vervollständigt) zu entsprechen, wenn Sie drücken Sie, lassen Sie uns sagen, TAB und zeigen Sie alle Hinweise, die Sprache, die Server zu überprüfen alles über die Klasse, einschließlich der doc Blöcke und private Mitglieder.Dafür braucht es eine Reflexion der besagten Klasse.