Reflexionsmechanismus in JAVA

Reflexion, ich habe sie oft sagen hören, dass ich einige Informationen gelesen und sie möglicherweise in Entwurfsmustern verwendet habe, aber ich habe das Gefühl, dass ich kein tiefes Verständnis dafür habe. Ich habe sie dieses Mal noch einmal studiert und es fühlt sich in Ordnung an !

Schauen wir uns zunächst das Konzept der Reflexion an:

Bezieht sich hauptsächlich auf die Fähigkeit eines Programms, auf seinen eigenen Status zuzugreifen, ihn zu erkennen und zu ändern oder Verhalten und kann den Status und die zugehörige Semantik des von der Anwendung beschriebenen Verhaltens basierend auf dem Status und den Ergebnissen ihres eigenen Verhaltens anpassen oder ändern.

Reflection ist ein leistungsstarkes Tool in Java, mit dem wir auf einfache Weise flexiblen Code erstellen können, der zur Laufzeit zusammengestellt werden kann, ohne dass Quellcode zwischen Komponenten verknüpft wird. Doch der unsachgemäße Einsatz von Reflexion kann sehr kostspielig sein!

Wenn Sie das Konzept verwirrt, lesen Sie weiter.

2. Die Rolle des Reflexionsmechanismus:

1. Dekompilieren: .class-->.java

2. Zugriff über die Reflexionsmechanismus Eigenschaften, Methoden, Konstruktionsmethoden usw. von Java-Objekten

Dies scheint einfacher zu verstehen zu sein.

Drittens werfen wir einen Blick auf die Klassen, die uns Sun im Reflexionsmechanismus zur Verfügung stellt:

java.lang.Class; 🎜>java. lang.reflect.Constructor; java.lang.reflect.Field; 🎜>

Vierte, spezifische Funktionsimplementierung:

erhalten

2. Erstellen Sie ein Objekt: Nachdem wir die Klasse erhalten haben, erstellen wir ihr Objekt mit newInstance:

3. Attribute abrufen: unterteilt in alle Attribute und angegebene Attribute:

a, schauen Sie sich zunächst an, wie Sie alle Attribute erhalten:

//第一种方式：  
Classc1 = Class.forName("Employee");  
//第二种方式：  
//java中每个类型都有class 属性.  
Classc2 = Employee.class;  
   
//第三种方式：  
//java语言中任何一个java对象都有getClass 方法  
Employeee = new Employee();  
Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee)

Erhalten Sie bestimmte Attribute, lernen Sie durch Vergleich mit herkömmlichen Methoden:

[java] view plain copy
 print?
Class c =Class.forName("Employee");  
  
//创建此Class 对象所表示的类的一个新实例  
Objecto = c.newInstance(); //调用了Employee的无参数构造方法.

4. Holen Sie sich Methoden, und Strukturen Die Methode wird nicht im Detail beschrieben, schauen Sie sich einfach die Schlüsselwörter an:

//获取整个类  
            Class c = Class.forName("java.lang.Integer");  
              //获取所有的属性?  
            Field[] fs = c.getDeclaredFields();  
       
                   //定义可变长的字符串，用来存储属性  
            StringBuffer sb = new StringBuffer();  
            //通过追加的方法，将每个属性拼接到此字符串中  
            //最外边的public定义  
            sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");  
            //里边的每一个属性  
            for(Field field:fs){  
                sb.append("\t");//空格  
                sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符，例如public，static等等  
                sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字  
                sb.append(field.getName()+";\n");//属性的名字+回车  
            }  
      
            sb.append("}");  
      
            System.out.println(sb);

Auf diese Weise können wir verschiedene Inhalte der Klasse erhalten und sie dekompilieren. Bei einer Sprache wie JAVA, die zuerst kompiliert und dann ausgeführt wird, kann der Reflexionsmechanismus den Code flexibler machen und die objektorientierte Implementierung einfacher machen.

public static void main(String[] args) throws Exception{  
              
<span style="white-space:pre">  </span>//以前的方式：  
    /* 
    User u = new User(); 
    u.age = 12; //set 
    System.out.println(u.age); //get 
    */  
              
    //获取类  
    Class c = Class.forName("User");  
    //获取id属性  
    Field idF = c.getDeclaredField("id");  
    //实例化这个类赋给o  
    Object o = c.newInstance();  
    //打破封装  
    idF.setAccessible(true); //使用反射机制可以打破封装性，导致了java对象的属性不安全。  
    //给o对象的id属性赋值"110"  
    idF.set(o, "110"); //set  
    //get  
    System.out.println(idF.get(o));  
}

Fünftens machen Reflexions- und Konfigurationsdateien unser Programm flexibler:

Beim Erlernen von Entwurfsmustern und beim Erlernen abstrakter Fabriken war Reflexion mehr üblich Es ist praktisch, Datenbankverbindungszeichenfolgen usw. zu lesen. Da ich es damals noch nicht ganz verstand, habe ich es einfach kopiert. Schauen Sie sich die Verwendung von Reflection + Konfigurationsdateien in .NET an:

Die damals verwendete Konfigurationsdatei war die Datei app.config, der Inhalt war im XML-Format und der Inhalt der verknüpften Datenbank war ausgefüllt:

Dieser Vorteil besteht darin, dass wir die Datenbank sehr einfach ändern können, wenn wir beispielsweise die Systemdatenbank aktualisieren Von SQL Server zu Oracle schreiben wir dann zwei D-Schichten und konfigurieren sie. Ändern Sie einfach den Inhalt der Datei oder fügen Sie Bedingungen hinzu, um sie auszuwählen, was großen Komfort bringt.

<<>

      <configuration>  
lt;appSettings>  
<add     key=""  value=""/>  
lt;/appSettings>  
        </configuration>

assembly.load("当前程序集的名称").CreateInstance("当前命名空间名称".要实例化的类名);

Zusammenfassend lässt sich sagen, dass das Neulernen der JAVA-Reflexion und ihre flexible Verwendung unseren Code flexibler machen können, aber es hat auch seine Nachteile, das heißt, die Verwendung verringert die Leistung unserer Software und erhöht die Komplexität, sodass wir sie auch verwenden müssen es sorgfältig.