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
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
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
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
Celles que nous utilisons le plus sont probablement
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
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 zooclass zoo1 extends zoo{
//初始块
{
System.out.println("11 " + this.getClass());
}
//静态初始块
static {
System.out.println("12 " + zoo.class);
}
public zoo1() {
System.out.println("13 " + this.getClass());
}}
: 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类下,作用时传递参数,执行方法 最后我们合并一下 getConsturctor(函数可以选定指定接口格式的构造函数(由于构造函数也可以根据参数来进行重载) ProcessBuilder类有两个构造函数 分别使用构造方法 执行完构造方法实例后,在进行强制转化使用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”))); ((ProcessBuilder) Class.forName(“java.lang.ProcessBuilder”).getConstructor(String[].class).newInstance(new String[]{“notepad”})).start(); 在这行打断点调试 ( (ProcessBuilder) Class.forName(“java.lang.ProcessBuilder”).getConstructor(List.class).newInstance(Arrays.asList(“notepad”))).start(); 依旧还是这行打断点 通过函数getDeclaredConstructor获取私有方法,再利用setAccessible(true)打破私有方法限制 推荐学习:《java视频教程》
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();
选定后我们可以通过newInstance(),并传入构造函数的参数执行构造函数
这里可能有人会好奇我写的里那的另一个构造函数,String…command这个传参为什么用new String[][]{{“notepad”}},不应该是new String[]{“notepad”},现在用应该的
我们传的是一个字符串数组到了实例化的时候变成了一个字符串,再看看另一个构造函数(List)
由此可知,List传入时会被当作Object的第一项,而String[]会被当做Object,所以多加一层[]{}执行私有方法
Class cls = Class.forName("java.lang.Runtime");
Constructor m = cls.getDeclaredConstructor();
m.setAccessible(true);
cls.getMethod("exec", String.class).invoke(m.newInstance(), "notepad");
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!