Explication détaillée des exemples de mécanismes de réflexion en Java

Cet article présente principalement des informations pertinentes sur l'explication détaillée du mécanisme de réflexion en Java. Les amis qui en ont besoin peuvent se référer à

Explication détaillée du mécanisme de réflexion en Java

.

Réflexion, je les ai souvent entendus dire que j'avais lu certaines informations et que je les avais peut-être utilisées dans Design Pattern, mais j'avais l'impression de ne pas les comprendre en profondeur, je les ai étudiées. encore cette fois et j'ai senti que tout allait bien au bar !

Tout d'abord, jetons un coup d'œil au concept de réflexion :

Désigne principalement la capacité d'un programme à accéder, détecter et modifier son propre statut ou comportement, et peut L'état et les résultats de son propre comportement, en ajustant ou en modifiant l'état et la sémantique associée du comportement décrit par l'application.

Reflection est un outil puissant en Java qui nous permet de créer facilement du code flexible qui peut être assemblé au moment de l'exécution sans avoir besoin de relier le code source entre les composants. Mais une mauvaise utilisation de la réflexion peut coûter très cher !

Si le concept vous déroute, continuez à lire.

2. Le rôle du mécanisme de réflexion :

1.Décompiler : .class-->.java

2. mécanisme de réflexion Attributs d'objet Java, méthodes, méthodes de construction , etc.;

semble être plus facile à comprendre. Voyons comment implémenter ces fonctions en détail.

Troisièmement, jetons un coup d'œil aux classes que le soleil nous offre dans le mécanisme de réflexion :

java.lang.Class;        

java.lang.reflect.Constructor; java.lang.reflect.Field;    

java.lang.reflect.Method;

java.lang.reflect.Modifier;

De nombreuses méthodes, attributs, etc. fonctionnent dans la réflexion sur nous Vous pouvez interroger ces quatre catégories. Ou devrions-nous apprendre à interroger constamment l’API, c’est notre meilleur professeur.

Quatre. Implémentation de fonctions spécifiques :

1. Le mécanisme de réflexion a trois façons d'obtenir la classe. Obtenons le type d'employé

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

<🎜. >2.

Créer un objet : Après avoir obtenu la classe, nous créons son objet, utilisons newInstance :

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

3, obtenons les attributs : divisés en tous les attributs et attributs spécifiés :

a, regardez d'abord comment obtenir tous les attributs :

//获取整个类
  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);

b, obtenez des attributs spécifiques, apprenez en comparant avec les méthodes traditionnelles :

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

4, obtenez la méthode, et les méthodes de construction ne seront pas décrites en détail, il suffit de regarder les mots-clés :

De cette façon, nous pouvons obtenir différents contenus de la classe et la décompiler. Pour un langage comme JAVA qui compile d'abord puis s'exécute, le mécanisme de réflexion peut rendre le code plus flexible et plus facile à implémenter

orienté objet.

Cinquièmement, la réflexion plus fichier de configuration rend notre programme plus flexible :

Lors de l'apprentissage des modèles de conception, lors de l'apprentissage de l'usine abstraite, la réflexion a été utilisée pour plus lire facilement les chaînes de connexion à la base de données, etc. Je ne l'ai pas bien compris à l'époque, alors je l'ai simplement copié. Jetez un œil à l'utilisation des fichiers de configuration réflexion + dans .NET :

Le fichier de configuration utilisé à cette époque était le fichier app.config, le contenu était au format XML et le contenu de la base de données de liens était rempli :

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

Comment rédiger une réflexion :

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

L'avantage de ceci est qu'il nous est très facile de changer la base de données. Par exemple, si nous mettons à jour la base de données. base de données système de SQL Server à Oracle, puis nous écrivons deux copies de la couche D, dans la configuration, il suffit de modifier le contenu du fichier ou d'ajouter des conditions pour le sélectionner, ce qui apporte une grande commodité.

Bien sûr, la même chose est vraie en JAVA, sauf que le fichier de configuration ici est .properties, qui est appelé fichier de propriétés. Lisez le contenu à l’intérieur par réflexion. De cette façon, le code est fixe, mais nous pouvons modifier le contenu du fichier de configuration, ce qui rend notre code beaucoup plus flexible !

Pour résumer, réapprendre la réflexion JAVA et l'utiliser de manière flexible peut rendre notre code plus flexible, mais il a aussi ses inconvénients, c'est-à-dire que son utilisation réduira l'augmentation des performances et de la complexité de notre logiciel, donc. nous devons l'utiliser avec précaution.

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!