Comment utiliser la réflexion et l'analyse d'exemples Java

Réflexion

Définition de réflexion

Un objet peut obtenir sa classe par réflexion, et une classe peut obtenir toutes les méthodes (y compris privées) par réflexion. Les fichiers de bytecode peuvent être exploités et lus via le mécanisme de réflexion dans le langage Java. .Et modifiez le fichier de bytecode

Utilisation de base de la réflexion

1. Obtenez l'objet de classe

une méthode forName()

Vous avez seulement besoin de connaître le nom de la classe, et l'exemple de code sera utilisé lors du chargement de JDBC

.

public class test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class name = Class.forName("java.lang.Runtime");
        System.out.println(name);
    }
}

b. Obtenez directement

Utilisez .class pour obtenir l'objet .class去获取对于的对象

public class test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> name = Runtime.class;
        System.out.println(name);
    }
}

c. getClass()方法

getClass来获取字节码对象，必须要明确具体的类，然后创建对象

public class test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Runtime rt = Runtime.getRuntime();
        Class<?> name = rt.getClass();
        System.out.println(name);
    }
}

d. getSystemClassLoader().loadClass()方法

这个方法和forName类似，只要有类名就可以了，但是区别在于，forName的静态JVM会装载类，并执行static()中的代码

public class getSystemClassLoader {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> name = ClassLoader.getSystemClassLoader().loadClass("java.lang.Runtime");
        System.out.println(name);
    }
}

2. 获取类方法

a. getDeclaredMethods

返回类或接口声明的所有方法，包括public、protected、private和默认方法，但是不包括继承的方法

import java.lang.reflect.Method;

public class getDeclaredMethods {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> name = Class.forName("java.lang.Runtime");
        System.out.println(name);
        Method[] m = name.getDeclaredMethods();
        for(Method x:m)
            System.out.println(x);
    }
}

b. getDeclaredMethod

获取特定的方法，第一个参数是方法名，第二个参数是该方法的参数对应的class对象，例如这里Runtime的exec方法参数为一个String，所以这里的第二个参数是String.class

import java.lang.reflect.Method;

public class getDeclaredMethod {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class<?> name = Class.forName("java.lang.Runtime");
        Method m = name.getDeclaredMethod("exec",String.class);
        System.out.println(m);
    }
}

c. getMethods

返回某个类所有的public方法，包括继承类的public方法

d. getMethod

参数同理getDeclaredMethod

3. 获取成员变量

同理Method的那几个方法

a. getDeclaredFields

获取类的成员的所有变量数组，但是不包括父类的

b. getDeclaredField(String name)

获取特定的，参数是想要的方法的名称

c. getFields()

同理，只能获得public的，但是包括了父类的

d. getField(String name)

同理，参数是想要的方法的名称

4. 获取构造函数Constructor

Constructor>[] getConstructors() ：只返回public构造函数

Constructor>[] getDeclaredConstructors() ：返回所有构造函数

Constructor getConstructor(类>... parameterTypes) : 匹配和参数配型相符的public构造函数

Constructor getDeclaredConstructor(类>... parameterTypes) ： 匹配和参数配型相符的构造函数

后面两个方法的参数是对于方法的参数的类型的class对象，和Method的那个类似，例如String.class

5. 反射创建类对象

newInstance

可以通过反射来生成实例化对象，一般我们使用Class对象的newInstance()方法来进行创建类对象

创建的方法就是：只需要通过forname方法获取到的class对象中进行newInstance方法创建即可

Class c = Class.forName("com.reflect.MethodTest"); // 创建Class对象
Object m1 =  c.newInstance(); // 创建类对象

invoke

invoke方法位于java.lang.reflect.Method类中，用于执行某个的对象的目标方法,一般会和getMethod方法配合进行调用。

使用用法：

public Object invoke(Object obj, Object... args)

第一个参数为类的实例，第二个参数为相应函数中的参数

obj：从中调用底层方法的对象，必须是实例化对象

args： 用于方法的调用，是一个object的数组，参数有可能是多个

但需要注意的是，invoke方法第一个参数并不是固定的：

• 如果调用这个方法是普通方法，第一个参数就是类对象；

• 如果调用这个方法是静态方法，第一个参数就是类；

通过一个例子去理解

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Invoke {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class c = Class.forName("Invoke");
        Object o = c.newInstance();
        Method m = c.getMethod("test");
        m.invoke(o);
    }
    public void test(){
        System.out.println("测试成功");
    }
}

简单来说就是这样

方法.invoke(类或类对象)

先forName拿到Class，再newInstance获取类对象，再getMethod获取方法，然后调用

Runtime的rce例子（访问限制突破）

Runtime类里面有一个exec方法，可以执行命令

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Exec {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class c = Class.forName("java.lang.Runtime");
        Object o = c.newInstance();
        Method m = c.getMethod("exec",String.class);
        m.invoke(o,"/System/Applications/Calculator.app/Contents/MacOS/Calculator");
    }
}

但是发现报错了

出现这个问题的原因：

• 使用的类没有无参构造函数

• 使用的类构造函数是私有的

那么解决方案就是setAccessible(true);

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Exec {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        Class c = Class.forName("java.lang.Runtime");
        Constructor con = c.getDeclaredConstructor();
        con.setAccessible(true);
        Method m = c.getMethod("exec",String.class);
        m.invoke(con.newInstance(),"/System/Applications/Calculator.app/Contents/MacOS/Calculator");
    }
}

c méthode getClass() 🎜🎜getClass pour obtenir l'objet bytecode, vous devez spécifier la classe spécifique, puis créez l'objet 🎜

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Exec {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        Class c = Class.forName("java.lang.Runtime");
        Constructor con = c.getDeclaredConstructor();
        con.setAccessible(true);
        Object o = con.newInstance();
        Method m = c.getMethod("exec",String.class);
        m.invoke(o,"/System/Applications/Calculator.app/Contents/MacOS/Calculator");
    }
}

🎜d. Méthode getSystemClassLoader().loadClass()🎜🎜Cette méthode est similaire à forName, tant qu'il y a un nom de classe, mais la différence est que la JVM statique de forName chargera la classe. et exécutez le code dans static()🎜 rrreee🎜2. Obtenez les méthodes de classe🎜🎜a. getDeclaredMethods🎜🎜Renvoie toutes les méthodes déclarées par la classe ou l'interface, y compris les méthodes publiques, protégées, privées et par défaut, mais n'inclut pas les méthodes héritées🎜. rrreee🎜🎜🎜b. getDeclaredMethod🎜🎜Obtenez la méthode spécifique, le premier paramètre est le nom de la méthode et le deuxième paramètre est l'objet de classe correspondant au paramètre de la méthode Par exemple, le paramètre de la méthode exec du Runtime est ici une chaîne, donc le deuxième paramètre. voici String.class🎜rrreee🎜c. getMethods🎜🎜 renvoie un certain Toutes les méthodes publiques d'une classe, y compris les méthodes publiques des classes héritées 🎜🎜d getMethod 🎜🎜 les paramètres sont les mêmes que getDeclaredMethod 🎜🎜 3. Obtenez les variables membres 🎜. 🎜 sont identiques à la méthode 🎜🎜a. getDeclaredFields 🎜🎜 récupère la classe Tous les tableaux de variables de membres, mais à l'exclusion de ceux de la classe parent 🎜🎜b getDeclaredField(String name)🎜🎜Get un paramètre spécifique est le nom du. méthode souhaitée 🎜🎜c.getFields()🎜🎜De même, il ne peut que devenir public, mais inclure le 🎜🎜d getField(String name)🎜🎜De même, le paramètre est le nom de la méthode souhaitée🎜🎜4. Obtenez le constructeur Constructor🎜

🎜Constructor> [] getConstructors() : renvoie uniquement les constructeurs publics🎜🎜Constructor>[] getDeclaredConstructors() : renvoie tous les constructeurs🎜🎜Constructor ?>... ParameterTypes) : correspond au constructeur public qui correspond au type de paramètre🎜🎜Constructor getDeclaredConstructor(class>... ParameterTypes) : correspond au constructeur qui correspond au type de paramètre🎜

🎜Les paramètres des deux dernières méthodes sont Le type d'objet de classe pour les paramètres de méthode est similaire à celui de Method, tel que String.class🎜🎜5 La réflexion crée des objets de classe🎜🎜newInstance🎜🎜Vous. peut générer des objets instanciés par réflexion, généralement Nous utilisons la méthode newInstance() de l'objet Class pour créer l'objet de classe🎜🎜La méthode de création est la suivante : créez simplement la méthode newInstance dans l'objet de classe obtenu via la méthode forname🎜rrreee🎜invoke🎜 🎜La méthode d'invocation se trouve dans la classe java.lang.reflect.Method et est utilisée pour exécuter la méthode cible d'un certain objet. Elle est généralement appelée en conjonction avec la méthode getMethod. 🎜🎜Utilisation : 🎜rrreee🎜Le premier paramètre est l'instance de la classe, le deuxième paramètre est le paramètre dans la fonction correspondante🎜🎜obj : l'objet à partir duquel la méthode sous-jacente est appelée doit être un objet instancié🎜🎜args : utilisé pour les méthodes L'appel est un tableau d'objets, et les paramètres peuvent être multiples 🎜🎜Mais il faut noter que le premier paramètre de la méthode Invocation n'est pas fixe : 🎜

🎜Si l'appel de cette méthode est une méthode normale, le premier paramètre est l'objet de classe ; 🎜
• 🎜Si l'appel de cette méthode est une méthode statique, le premier paramètre est la classe ; 🎜🎜Passez un exemple pour comprendre🎜rrreee🎜🎜🎜 Pour faire simple, ça y est🎜

  🎜Method.invoke (classe ou objet de classe)🎜

  🎜Obtenez d'abord la classe forName, puis obtenez l'objet de classe avec newInstance, puis obtenez la méthode avec getMethod, puis appelez l'exemple rce de 🎜🎜Runtime (Percée des restrictions d'accès) 🎜🎜 Il existe une méthode exec dans la classe Runtime, qui peut exécuter des commandes 🎜rrreee🎜 Mais j'ai trouvé une erreur 🎜🎜🎜🎜La raison de ce problème : 🎜
• 🎜La classe utilisée n'a pas de paramètres Constructeur🎜
• 🎜Le constructeur de classe utilisé est privé🎜
🎜🎜Ensuite, la solution est setAccessible(true);, utilisez-le pour briser les restrictions d'accès🎜

Java.lang.reflect.AccessibleObject类是Field，Method和Constructor类对象的基类，可以提供将反射对象标记为使用它抑制摸人Java访问控制检查的功能，同时上述的反射类中的Field，Method和Constructor继承自AccessibleObject。所以我们在这些类方法基础上调用setAccessible()方法，既可对这些私有字段进行操作

简单来说，私有的属性、方法、构造方法，可以通过这个去突破限制，xxx.setAccessible(true) 可以看到Runtime的构造方法是private的



那么这里我们就可以这么去突破限制 先获取构造方法，然后setAccessible获取访问权限 然后再最后invoke里面，第一个参数写成con.newInstance()

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Exec {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        Class c = Class.forName("java.lang.Runtime");
        Constructor con = c.getDeclaredConstructor();
        con.setAccessible(true);
        Method m = c.getMethod("exec",String.class);
        m.invoke(con.newInstance(),"/System/Applications/Calculator.app/Contents/MacOS/Calculator");
    }
}



这里有一个疑问，如果把con.newInstance单独提取出来，他打开计算器不会显示出来，但是后台的确是启动了，不知道啥原因

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Exec {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        Class c = Class.forName("java.lang.Runtime");
        Constructor con = c.getDeclaredConstructor();
        con.setAccessible(true);
        Object o = con.newInstance();
        Method m = c.getMethod("exec",String.class);
        m.invoke(o,"/System/Applications/Calculator.app/Contents/MacOS/Calculator");
    }
}

后记

反射中常用的几个重要方法：

• 获取类的⽅法： forName

• 实例化类对象的⽅法： newInstance

• 获取函数的⽅法： getMethod

• 执⾏函数的⽅法： invoke

• 限制突破方法：setAccessible

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!