Explication détaillée du mécanisme de réflexion de la désérialisation Java avec des exemples

Cet article vous apporte des connaissances pertinentes sur Java, qui présentent principalement les problèmes liés au mécanisme de réflexion de java La fonction d'obtention dynamique d'informations sur le programme et d'appel dynamique d'objets est appelée le mécanisme de réflexion du langage Java. utile à tout le monde.

Étude recommandée : "Tutoriel Java"

Chaque fois que j'entends un grand gars parler ou regarder des forums et d'autres méthodes pour apprendre les vulnérabilités de désérialisation Java, il y aura un mot appelé mécanisme de réflexion, et le grand gars emprunte En utilisant ce mot, je vais créer une charge utile pour vous. Pour ceux d'entre nous qui viennent d'apprendre la désérialisation Java, nous pouvons être un peu confus. Quoi qu'il en soit, j'étais confus, alors j'ai rapidement appris une vague, sinon l'écart entre moi. et les grands deviendront de plus en plus grands. Cet article parle donc principalement du mécanisme de réflexion Java

Mécanisme de réflexion Java

Le mécanisme de réflexion de Java signifie que dans l'état d'exécution du programme, vous pouvez construire un objet de n'importe quelle classe, vous pouvez comprendre la classe à laquelle appartient n'importe quel objet, et vous pouvez comprendre les variables membres et les méthodes de n'importe quelle classe, et vous pouvez appeler les propriétés et les méthodes de n'importe quel objet. Cette fonction d'obtention dynamique d'informations sur le programme et d'appel dynamique d'objets est appelée mécanisme de réflexion du langage Java. La réflexion est considérée comme la clé des langages dynamiques.

Je ne suis pas très doué pour les expressions verbales, alors faisons comme indiqué sur l'image

Un exemple de non-utilisation du mécanisme de réflexion

//定义一个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();
    }}

Pour ajouter des animaux à ce moment, il vous suffit de

• ajouter un class
• Modifier zoo
• Modifier la classe animale de la fonction principale

Modifier ce qui précède en un mécanisme de réflexion

//定义一个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();
    }}

Pour ajouter des animaux à ce moment, il vous suffit de

• ajouter une classe
• Modifier l'animal classe de la fonction principale

Cela permet d'économiser une étape. Le nom de la classe entrante est contrôlable, et il semble que toutes les classes existantes Vous pouvez ajuster la

méthode du mécanisme de réflexion

Celles que nous utilisons le plus sont probablement

• forName ( call class)
• getMethod (méthode d'appel sous classe)
• invoke (execute)
• newInstance (objet instancié)

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

Ensuite, nous utilisons le mécanisme de réflexion pour faire apparaître l'ordinateur (calc) ou le bloc-notes (bloc-notes)

Comme il y a trop d'ordinateurs pour apparaître, je vais faire apparaître le bloc-notes cette fois. Bref, c'est merveilleux de pouvoir apparaître

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

Jetons un coup d'œil à la fonction getRuntime

J'ai appris que cette fonction. est le moyen pour la classe Runtime d'obtenir des objets. Personnellement, je pense qu'il est gênant de l'appeler à chaque fois. Afin de ne pas l'appeler une seule fois pour créer un objet, il est encapsulé dans une fonction

Comment obtenir la classe. objets

• Class.forName (acquisition du nom de classe)
• zoo.class (classe déjà chargée)
• obj.class (instance)
  

Initialisation de la classe

Modifier la classe zoo et ajouter une initiale bloc, bloc initial statique et constructeur

class zoo {
    //初始块
    {
        System.out.println("1  " + this.getClass());
    }

    //静态初始块
    static {
        System.out.println("2  " + zoo.class);
    }

    public zoo() {
        System.out.println("3  " + this.getClass());
    }

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

Ordre d'exécution de l'initialisation de classe : Bloc initial statique

Ordre d'exécution de l'instanciation de classe : Bloc initial statique - > Bloc initial - > sait que l'initialisation de classe et l'instanciation de classe sont différentes

Ensuite, ajoutez la classe zoo1 pour hériter de la classe zoo

class zoo1 extends zoo{
    //初始块
    {
        System.out.println("11  " + this.getClass());
    }

    //静态初始块
    static {
        System.out.println("12  " + zoo.class);
    }

    public zoo1() {
        System.out.println("13  " + this.getClass());
    }}

séquence d'initialisation de sous-classe

 : bloc d'initialisation statique de la classe parent - > séquence d'instanciation

 : Bloc d'initialisation statique de la classe parent - > Bloc d'initialisation statique de la sous-classe - > Bloc d'initialisation de la classe parent - > Bloc d'initialisation de la sous-classe - > au-dessus, lors de l'utilisation de Class.forName et que le bloc d'initialisation statique de la classe est contrôlable, n'importe quel code peut être exécuté

Appelez la classe interne
Class.forName("java.lang.Runtime") pour obtenir la classe ( java.lang.Runtime est le chemin complet de la classe Runtime)

getMethod

getMethod est utilisé pour obtenir une méthode publique spécifique de la classe par réflexion. Java prend en charge la surcharge de classe, mais une fonction ne peut pas être déterminée par un simple nom de fonction, donc lors de l'appel de getMethod, vous devez lui transmettre la liste des types de paramètres de la méthode

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

invoquer

静态和动态方法的区别

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视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!