Detaillierte Erläuterung des Reflexionsmechanismus der Java-Deserialisierung anhand von Beispielen

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java und stellt hauptsächlich Probleme im Zusammenhang mit dem Reflexionsmechanismus von Java vor. Die Funktion des dynamischen Abrufens von Programminformationen und des dynamischen Aufrufs von Objekten wird hoffentlich als Reflexionsmechanismus bezeichnet nützlich für alle.

Empfohlene Studie: „

Java-Tutorial“

Jedes Mal, wenn ich einen großen Kerl reden oder Foren und andere Methoden zum Erlernen von Java-Deserialisierungsschwachstellen anschauen höre, wird es ein Wort namens Reflexionsmechanismus geben, und der große Kerl leiht sich etwas aus Mit diesem Wort werde ich eine Nutzlast für Sie erstellen. Für diejenigen von uns, die gerade Java-Deserialisierung gelernt haben, war ich vielleicht etwas verwirrt, also habe ich schnell eine Welle gelernt und die Großen werden immer größer. In diesem Artikel geht es also hauptsächlich um den Java-Reflexionsmechanismus

Java-Reflexionsmechanismus

Der Java-Reflexionsmechanismus bedeutet, dass Sie im laufenden Zustand des Programms ein Objekt jeder Klasse erstellen und die Klasse verstehen können, zu der jedes Objekt gehört. und Sie können die Mitgliedsvariablen und -methoden jeder Klasse verstehen und die Eigenschaften und Methoden jedes Objekts aufrufen. Diese Funktion zum dynamischen Abrufen von Programminformationen und zum dynamischen Aufrufen von Objekten wird als Reflexionsmechanismus der Java-Sprache bezeichnet. Reflexion gilt als Schlüssel zu dynamischen Sprachen.

Ich bin nicht sehr gut in verbalen Ausdrücken, also mache ich es einfach im Bild oben

ein Beispiel dafür, dass der Reflexionsmechanismus nicht verwendet wird

//定义一个animals接口interface animals {
    public abstract void print();}//定义类来实现animals接口的抽象方法class Dog implements animals {
    public void print() {
        System.out.println("Dog");
    }}class Cat implements animals {
    public void print() {
        System.out.println("Cat");
    }}// 构造一个zoo类// 之后如果我们在添加其他的实例的时候只需要修改zoo类class zoo {

    public static animals getInstance(String animalsName) {
        animals a = null;
        if ("Dog".equals(animalsName)) {
            a = new Dog();
        }
        if ("Cat".equals(animalsName)) {
            a = new Cat();
        }
        return a;
    }}public class reflection {
    public static void main(String[] args) {
        //借助zoo类寻找对应的类来实现接口
        animals a=zoo.getInstance("Cat");
        if(a!=null)
            a.print();
    }}

Um zu diesem Zeitpunkt Tiere hinzuzufügen, müssen Sie nur

hinzufügen eine Klasse
• Zoo ändern
• Die Tierklasse der Hauptfunktion ändern

Ändern Sie das Obige in einen Reflexionsmechanismus

//定义一个animals接口interface animals {
    public abstract void print();}//定义类来实现animals接口的抽象方法class Dog implements animals {
    public void print() {
        System.out.println("Dog");
    }}class Cat implements animals {
    public void print() {
        System.out.println("Cat");
    }}// 构造一个zoo类// 之后如果我们在添加其他的实例的时候只需要修改zoo类class zoo {

    public static animals getInstance(String className) {
        animals a = null;
        try {
            //借助Class.forName寻找类名，并用newInstance实例化类似于new
            a = (animals) Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return a;
    }}public class reflection {
    public static void main(String[] args) {
        //借助zoo类寻找对应的类来实现接口(classname为当前包名加类名)
        animals a = zoo.getInstance("com.cc1.Dog");
        if (a != null)
            a.print();
    }}

Zu diesem Zeitpunkt ist zum Hinzufügen von Tieren nur

Eine Klasse hinzufügen
• Ändern der Tierklasse von erforderlich die Hauptfunktion

Es spart einen Schritt, der eingehende Klassenname ist steuerbar und es scheint, dass alle vorhandenen Klassen Sie können die

Reflexionsmechanismus-Methode anpassen

Die, die wir am häufigsten verwenden, sind wahrscheinlich

forName (Klasse aufrufen). )
• getMethod (Methode unter Klasse aufrufen)
• invoke (ausführen)
• newInstance (Objekt instanziieren)

Class.forName(className).getMethod(methodName).invoke(Class.forName(className).newInstance());

Als nächstes verwenden wir den Reflexionsmechanismus, um den Computer (Berechnung) oder den Notizblock (Notepad) aufzurufen

Seitdem Es gibt zu viele Computer, um aufzutauchen. Diesmal werde ich den Notizblock aufklappen. Kurz gesagt, es ist wunderbar, auftauchen zu können Ich persönlich habe das Gefühl, dass es mühsam ist, sie jedes Mal aufzurufen, um ein Objekt zu erstellen. So erhalten Sie Klassenobjekte

Class.forName (Erfassung des Klassennamens)
zoo.class (bereits geladene Klasse)
obj.class (Instanz)

Klasseninitialisierung

• Ändern Sie die Zoo-Klasse und fügen Sie einen Anfangsblock hinzu. Statischer Anfangsblock und Konstruktor

• Runtime.getRuntime().exec("notepad");

• Ausführungsreihenfolge der Klasseninitialisierung
  

Ausführungsreihenfolge der Klasseninstanziierung

: Statischer Anfangsblock - > Anfangsblock - > Konstruktor

So ist bekannt Klasseninitialisierung und Klasseninstanziierung sind unterschiedlich. Fügen Sie als Nächstes die Klasse zoo1 hinzu, um die Zoo-Klasse zu erben

: Statischer Initialisierungsblock der übergeordneten Klasse – > Initialisierungsblock der übergeordneten Klasse – > Wenn Class.forName verwendet wird und der statische Initialisierungsblock der Klasse steuerbar ist, kann jeder Code ausgeführt werden.

Rufen Sie die interne Klasse auf. lang.Runtime ist der vollständige Pfad der Runtime-Klasse)
getMethod

getMethod wird verwendet, um eine bestimmte öffentliche Methode der Klasse durch Reflektion zu erhalten. Java unterstützt Klassenüberladung, aber eine Funktion kann nicht nur durch einen Funktionsnamen bestimmt werden. Wenn Sie also getMethod aufrufen, müssen Sie ihr die Parametertypliste der Methode übergeben

Class.forName("java.lang.Runtime").getMethod (" exec", String.class)

invoke

静态和动态方法的区别

invoke方法在getMethod类下，作用时传递参数，执行方法
public Object invoke(Object obj, Object… args)
第一个参数是getMethod获取的方法的类对象（如果方法是静态方法则传类）
获取exec函数的类对象
Class.forName(“java.lang.Runtime”).getMethod(“getRuntime”).invoke(Class.forName(“java.lang.Runtime”))
由于getRuntime是静态方法，所以传类
invoke(Class.forName(“java.lang.Runtime”).getMethod(“getRuntime”).invoke(Class.forName(“java.lang.Runtime”))，“calc.exe”)

最后我们合并一下

Class.forName("java.lang.Runtime").
                getMethod("exec", String.class).
                invoke(Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime")), "notepad");

指定构造方法生成实例

String str="notepad";ProcessBuilder pb = new ProcessBuilder(str);pb.start();

getConsturctor(函数可以选定指定接口格式的构造函数(由于构造函数也可以根据参数来进行重载)
选定后我们可以通过newInstance(),并传入构造函数的参数执行构造函数

ProcessBuilder类有两个构造函数

• public ProcessBuilder(String… command)（String…变长的字符串数组String[].class）
• public ProcessBuilder(List command)

分别使用构造方法

• Class.forName(“java.lang.ProcessBuilder”).getConstructor(String[].class).newInstance(new String[][]{{“notepad”}})
• Class.forName(“java.lang.ProcessBuilder”).getConstructor(List.class).newInstance(Arrays.asList(“notepad”))

执行完构造方法实例后，在进行强制转化使用start函数即可

( (ProcessBuilder) Class.forName(“java.lang.ProcessBuilder”).getConstructor(List.class).newInstance(Arrays.asList(“notepad”))).start();

实际中，肯定用不了，哪有这么好的事，还是接着反射把

Class.forName(“java.lang.ProcessBuilder”).getMethod(“start”).invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList(“notepad”)));

这里可能有人会好奇我写的里那的另一个构造函数，String…command这个传参为什么用new String[][]{{“notepad”}}，不应该是new String[]{“notepad”},现在用应该的

((ProcessBuilder) Class.forName(“java.lang.ProcessBuilder”).getConstructor(String[].class).newInstance(new String[]{“notepad”})).start();

在这行打断点调试

我们传的是一个字符串数组到了实例化的时候变成了一个字符串，再看看另一个构造函数（List）

( (ProcessBuilder) Class.forName(“java.lang.ProcessBuilder”).getConstructor(List.class).newInstance(Arrays.asList(“notepad”))).start();

依旧还是这行打断点

由此可知，List传入时会被当作Object的第一项，而String[]会被当做Object，所以多加一层[]{}

执行私有方法

通过函数getDeclaredConstructor获取私有方法，再利用setAccessible(true)打破私有方法限制

Class cls = Class.forName("java.lang.Runtime"); 
Constructor m = cls.getDeclaredConstructor();
 m.setAccessible(true); 
 cls.getMethod("exec", String.class).invoke(m.newInstance(), "notepad");

 推荐学习：《java视频教程》

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des Reflexionsmechanismus der Java-Deserialisierung anhand von Beispielen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!