Warum sollte ich Reflektion verwenden?

Ich bin neu in Java. Während meines Studiums habe ich gelesen, dass Reflexion verwendet wird, um Klassen und Methoden aufzurufen und um zu wissen, welche Methoden implementiert sind oder nicht.

Wann sollte ich Reflection verwenden, und was ist der Unterschied zwischen der Verwendung von Reflection und der Instanziierung von Objekten und dem herkömmlichen Aufrufen von Methoden?

• Reflexion ist viel langsamer als nur das Aufrufen von Methoden mit ihrem Namen, da die Metadaten im Bytecode überprüft werden müssen, anstatt nur vorkompilierte Adressen und Konstanten zu verwenden.

• Reflexion ist auch leistungsfähiger: Sie ist die Definition eines abrufen kann protectedoder finalMitglied, entfernen Sie den Schutz und manipulieren, als ob es wandelbar erklärt worden war! Offensichtlich untergräbt dies viele der Garantien, die die Sprache normalerweise für Ihre Programme bietet, und kann sehr, sehr gefährlich sein.

Und das erklärt ziemlich genau, wann man es benutzt. Normalerweise nicht. Wenn Sie eine Methode aufrufen möchten, rufen Sie sie einfach auf. Wenn Sie ein Mitglied mutieren möchten, deklarieren Sie es einfach als mutierbar, anstatt hinter den Rücken des Compilers zu gehen.

Eine nützliche Anwendung der Reflexion in der Praxis ist das Schreiben eines Frameworks, das mit benutzerdefinierten Klassen zusammenarbeiten muss, wobei der Framework-Autor nicht weiß, was die Mitglieder (oder sogar die Klassen) sein werden. Reflexion ermöglicht es ihnen, mit jeder Klasse umzugehen, ohne es vorher zu wissen. Ich glaube zum Beispiel nicht, dass es möglich wäre, eine komplexe aspektorientierte Bibliothek ohne Reflexion zu schreiben.

Als weiteres Beispiel verwendete JUnit ein triviales Spiegelbild: Es listet alle Methoden in Ihrer Klasse auf, nimmt an, dass alle aufgerufenen testXXXMethoden Testmethoden sind, und führt nur diese aus. Dies kann jetzt jedoch besser mit Anmerkungen geschehen, und tatsächlich wurde JUnit 4 größtenteils auf Anmerkungen umgestellt.

Ich war wie du einmal, ich wusste nicht viel über Reflexion - weiß es immer noch nicht - aber ich habe es einmal benutzt.

Ich hatte eine Klasse mit zwei inneren Klassen und jede Klasse hatte viele Methoden.

Ich musste alle Methoden in der inneren Klasse aufrufen, und das manuelle Aufrufen wäre zu aufwendig gewesen.

Mit Reflection konnte ich alle diese Methoden in nur 2-3 Codezeilen anstelle der Anzahl der Methoden selbst aufrufen.

Ich würde die Verwendung von Reflexion in drei Gruppen einteilen:

1. Instanziieren beliebiger Klassen. Beispielsweise deklarieren Sie in einem Abhängigkeitsinjektionsframework wahrscheinlich, dass die Schnittstelle ThingDoer von der Klasse NetworkThingDoer implementiert wird. Das Framework findet dann den Konstruktor von NetworkThingDoer und instanziiert ihn.
2. Marshalling und Unmarshalling in ein anderes Format. Beispiel: Mapping eines Objekts mit Gettern und Einstellungen, die der Bean-Konvention entsprechen, auf JSON und wieder zurück. Der Code kennt weder die Namen der Felder noch die Methoden, sondern untersucht nur die Klasse.
3. Eine Klasse in eine Umleitungsebene einschließen (möglicherweise ist diese Liste nicht geladen, sondern nur ein Zeiger auf etwas, das weiß, wie man sie aus der Datenbank abruft) oder eine Klasse vollständig fälschen (jMock erstellt eine synthetische Klasse, die eine Schnittstelle implementiert zu Testzwecken).

Reflection ermöglicht es einem Programm, mit Code zu arbeiten, der möglicherweise nicht vorhanden ist, und dies auf zuverlässige Weise.

"Normaler Code" hat Snippets, URLConnection c = nulldie durch ihr Vorhandensein dazu führen, dass der Klassenlader die URLConnection-Klasse als Teil des Ladens dieser Klasse lädt, eine ClassNotFound-Ausnahme auslöst und beendet.

Mit Reflection können Sie Klassen basierend auf ihren Namen in Zeichenfolgenform laden und auf verschiedene Eigenschaften testen (nützlich für mehrere Versionen außerhalb Ihres Steuerelements), bevor Sie tatsächliche Klassen starten, die von ihnen abhängen. Ein typisches Beispiel ist der OS X-spezifische Code, der verwendet wird, um Java-Programme unter OS X nativ erscheinen zu lassen, die auf anderen Plattformen nicht vorhanden sind.

Reflektion bedeutet grundsätzlich, den Code Ihres Programms als Daten zu verwenden.

Daher ist die Verwendung von Reflection möglicherweise eine gute Idee, wenn der Code Ihres Programms eine nützliche Datenquelle ist. (Aber es gibt Kompromisse, daher ist es möglicherweise nicht immer eine gute Idee.)

Stellen Sie sich zum Beispiel eine einfache Klasse vor:

public class Foo {
  public int value;
  public string anotherValue;
}

und Sie möchten XML daraus generieren. Sie könnten Code schreiben, um das XML zu generieren:

public XmlNode generateXml(Foo foo) {
  XmlElement root = new XmlElement("Foo");
  XmlElement valueElement = new XmlElement("value");
  valueElement.add(new XmlText(Integer.toString(foo.value)));
  root.add(valueElement);
  XmlElement anotherValueElement = new XmlElement("anotherValue");
  anotherValueElement.add(new XmlText(foo.anotherValue));
  root.add(anotherValueElement);
  return root;
}

Dies ist jedoch eine Menge Boilerplate-Code, und jedes Mal, wenn Sie die Klasse ändern, müssen Sie den Code aktualisieren. Wirklich, Sie könnten beschreiben, wie dieser Code funktioniert

• Erstellen Sie ein XML-Element mit dem Namen der Klasse
• für jede Eigenschaft der Klasse
  • Erstellen Sie ein XML-Element mit dem Namen der Eigenschaft
  • Fügen Sie den Wert der Eigenschaft in das XML-Element ein
  • Fügen Sie das XML-Element zum Stammverzeichnis hinzu

Dies ist ein Algorithmus, und die Eingabe des Algorithmus ist die Klasse: Wir benötigen seinen Namen und die Namen, Typen und Werte seiner Eigenschaften. Hier kommt die Reflexion ins Spiel: Sie verschafft Ihnen Zugang zu diesen Informationen. Mit Java können Sie Typen mit den Methoden der ClassKlasse untersuchen.

Einige weitere Anwendungsfälle:

• Definieren Sie URLs in einem Webserver basierend auf den Methodennamen einer Klasse und URL-Parameter basierend auf den Methodenargumenten
• Konvertieren Sie die Struktur einer Klasse in eine GraphQL-Typdefinition
• Rufen Sie jede Methode einer Klasse auf, deren Name mit "test" als Unit-Testfall beginnt

Vollständige Reflexion bedeutet jedoch nicht nur, vorhandenen Code (der an sich als "Introspektion" bezeichnet wird) zu betrachten, sondern auch Code zu ändern oder zu generieren. Hierfür gibt es in Java zwei wichtige Anwendungsfälle: Proxies und Mocks.

Angenommen, Sie haben eine Schnittstelle:

public interface Froobnicator {
  void froobnicateFruits(List<Fruit> fruits);
  void froobnicateFuel(Fuel fuel);
  // lots of other things to froobnicate
}

und Sie haben eine Implementierung, die etwas Interessantes bewirkt:

public class PowerFroobnicator implements Froobnicator {
  // awesome implementations
}

Und tatsächlich haben Sie auch eine zweite Implementierung:

public class EnergySaverFroobnicator implements Froobnicator {
  // efficient implementations
}

Jetzt möchten Sie auch eine Protokollausgabe; Sie möchten einfach eine Protokollnachricht, wenn eine Methode aufgerufen wird. Sie könnten jeder Methode explizit eine Protokollausgabe hinzufügen, aber das wäre ärgerlich, und Sie müssten es zweimal tun. einmal für jede Implementierung. (Umso mehr, wenn Sie weitere Implementierungen hinzufügen.)

Stattdessen können Sie einen Proxy schreiben:

public class LoggingFroobnicator implements Froobnicator {
  private Logger logger;
  private Froobnicator inner;

  // constructor that sets those two

  public void froobnicateFruits(List<Fruit> fruits) {
    logger.logDebug("froobnicateFruits called");
    inner.froobnicateFruits(fruits);
  }

  public void froobnicateFuel(Fuel fuel) {
    logger.logDebug("froobnicateFuel( called");
    inner.froobnicateFuel(fuel);
  }
  // lots of other things to froobnicate
}

Wieder gibt es jedoch ein sich wiederholendes Muster, das durch einen Algorithmus beschrieben werden kann:

• Ein Logger-Proxy ist eine Klasse, die eine Schnittstelle implementiert
• Es hat einen Konstruktor, der eine andere Implementierung der Schnittstelle übernimmt, und einen Logger
• für jede Methode in der Schnittstelle
  • Die Implementierung protokolliert die Meldung "$ methodname called".
  • und ruft dann dieselbe Methode auf der inneren Schnittstelle auf, wobei alle Argumente übergeben werden

und die Eingabe dieses Algorithmus ist die Schnittstellendefinition.

Mit Reflection können Sie mit diesem Algorithmus eine neue Klasse definieren. Mit Java können Sie dies mit den Methoden der java.lang.reflect.ProxyKlasse tun , und es gibt Bibliotheken, die Ihnen noch mehr Leistung bieten.

Was sind die Nachteile der Reflexion?

• Ihr Code wird schwerer zu verstehen. Sie sind eine Abstraktionsebene, die weiter von den konkreten Auswirkungen Ihres Codes entfernt ist.
• Ihr Code ist schwerer zu debuggen. Insbesondere bei Code-generierenden Bibliotheken ist der ausgeführte Code möglicherweise nicht der von Ihnen geschriebene Code, aber der von Ihnen generierte Code, und der Debugger kann Ihnen diesen Code möglicherweise nicht anzeigen (oder Sie können Haltepunkte setzen).
• Ihr Code wird langsamer. Das dynamische Lesen von Typinformationen und der Zugriff auf Felder über ihre Laufzeit-Handles anstelle eines hartcodierten Zugriffs ist langsamer. Die dynamische Codegenerierung kann diesen Effekt abschwächen, was das Debuggen noch schwieriger macht.
• Ihr Code wird möglicherweise anfälliger. Der dynamische Reflection-Zugriff wird vom Compiler nicht typgeprüft, sondern löst zur Laufzeit Fehler aus.

Mit Reflection können Teile Ihres Programms automatisch synchronisiert werden. Bisher mussten Sie Ihr Programm manuell aktualisieren, um die neuen Benutzeroberflächen zu verwenden.