[Java] Annotation

Annotation

• Types tels que les interfaces de classe et les marques qui peuvent être attribuées aux membres
• ** Vous pouvez ajouter à votre code des informations accessoires qui ne sont pas directement liées à la logique d'origine de l'application **
• Décrit au début de la déclaration cible

@Override

• Annotations fournies par la bibliothèque standard
• Déclarez que la méthode cible ** remplace la méthode de classe de base **
• Le compilateur vous avertira même si vous ne pouvez pas le remplacer en raison d'une erreur d'argument.

public class Person {
  private String firstName;
  private String lastName;

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return String.format("Nom est,%s %s.",
        this.lastName, this.firstName);
  }

  public String getLastName() {
    return this.lastName;
  }

  public String getFirstName() {
    return this.firstName;
  }
}

@WebServlet

• Qu'est-ce qu'un servlet ** Un type de technologie de base pour exécuter des applications Java dans un environnement serveur **
• Informations de configuration de base du servlet
• ** urlPatterns **: URL pour appeler le servlet
• ** initParams **: informations sur les paramètres disponibles dans le servlet

Point d'annotation

• ** Les annotations peuvent être imbriquées **
• ** S'il y a un élément, {...} du tableau peut être omis **
  • urlPatterns = "/init-param"
• ** Les valeurs de nom d'attribut peuvent être omises **
  • @WebServlet (values="init-param")
  • @WebServlet ("init-param")
• ** Peut être omis s'il n'y a pas d'attribut **
• Annotation de marqueur (@Override, etc.)

Annotation standard

• @Override: déclare que vous écrasez une méthode dans la classe de base
• @Deprecated: déclare que les classes, les membres, etc. sont obsolètes
• @SuppressWarnings: supprimer les avertissements du compilateur
• @SafeVarargs: déclare la sécurité de type pour les arguments de longueur variable
• @FunctionalInterface: déclare définir l'interface comme une interface fonctionnelle

@Deprecated

• Déclaration que les classes, méthodes, etc. sont ** obsolètes **
• Le constructeur d'entiers est obsolète dans Java 9 et supérieur (since =" 9 ")
• Egalement décrit dans la documentation
• La compilation réussit mais un avertissement apparaît

Integer.java

/**
 *Omission
 * @deprecated
 * It is rarely appropriate to use this constructor. The static factory
 * {@link #valueOf(int)} is generally a better choice, as it is
 * likely to yield significantly better space and time performance.
 */

@Deprecated(since="9")
public Integer(int value) {
    this.value = value;
}

@SuppressWarnings

• ** Masquer les avertissements spécifiques du compilateur de plage / type **
• Empêche la surveillance d'autres avertissements qui doivent être confirmés
• Indication que vous utilisez intentionnellement le code pour être averti

public class AnnotationBasic {

  public static Integer process() {
   @SuppressWarnings("deprecation")
    var i = new Integer(108);
   return i;
  }

  public static void main(String[] args) {
    System.out.println(process());
  }
}

@SafeVarargs

• ** Déclare la sécurité de type pour les arguments de longueur variable et aucun avertissement n'est affiché **
• Un avertissement apparaît lorsque le type générique est défini comme argument de longueur variable
• Déclaration que le développeur est conscient qu'il est de type sécurisé

Annotation personnalisée

• Les annotations peuvent être créées par vous-même, contrairement aux modificateurs
• ** L'annotation est définie par l'instruction @interface **
• ** Déclarez les attributs pouvant être utilisés dans les annotations sous @interface **
• Dans le @ClassInfo suivant, spécifiez l'attribut version avec l'attribut version et l'attribut value.
• @ ClassInfo (version =" 2.1 ", description =" test d'annotation ") * @ClassInfo(version="2.1")
• ** Décrivez la méta-annotation qui déclare les informations de configuration d'annotation **
• @Documented: reflète les informations d'annotation dans javadoc
• @Target: Décidez à quel élément appliquer l'annotation
• @Inherited: les annotations sont héritées par les classes dérivées
• @Retention: combien de temps conserver les informations d'annotation

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//Déclaration des informations de configuration
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
//@Définition d'annotation avec la commande d'interface
public @interface ClassInfo {
  //Déclarer les attributs pouvant être utilisés dans les annotations
  String value() default "";
  String version() default "";
  String description() default "";
}

Utilisez des annotations pour la réflexion

• ** Réflexion **: Obtenez et manipulez les informations de type pendant l'exécution du code
• Dans ce qui suit, les informations de type spécifiées par la méthode ** Class.forName ** sont acquises par la classe Class.
• Annotation du marqueur: je suis intéressé par l'existence de l'annotation elle-même, pas par l'information (attribut) détenue par l'annotation **
• ** Méthode isAnnotationPresent ** pour vérifier les annotations

package mypackage;

//Spécification d'annotation ClassInfo
@ClassInfo(version = "2.1", description = "Test d'opération d'annotation")
// @ClassInfo("2.1")
public class AnnotationClient {
  public static void main(String[] args) throws ClassNotFoundException {
    //Obtenir des membres subordonnés via l'objet de classe
    var clazz = Class.forName("mypackage.AnnotationClient");
    //Obtenir les annotations données à la classe par la méthode getAnnotation
    var info = (ClassInfo)
 clazz.getAnnotation(ClassInfo.class);
    System.out.println("version:" +
        (info.value().equals("") ? info.version() : info.value()));
    System.out.println("Explication:" + info.description());
  }
}

Méthode de réflexion

Création d'objets

• Génération d'instance via le constructeur
• Générer un constructeur à appeler avec la ** méthode getConstructor ** de la classe Class
• ** Créez un objet en l'appelant avec la méthode newInstance **
• ** Méthode Array.newInstance ** pour générer un tableau
• ** Set method ** pour définir les éléments du tableau

import java.io.File;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;

public class ReflectInstance {

  public static void main(String[] args) {
    try {
      //Obtenir la classe File
      var clazz = File.class;

      //Créer un objet File via le constructeur
      var c = clazz.getConstructor(String.class);
      var fl = c.newInstance("./data/data.txt");
      System.out.println(fl);

      //Génération de baies de taille 2
      var list = (File[]) Array.newInstance(File.class, 2);
      Array.set(list, 0, fl);
      System.out.println(Arrays.toString(list));
    } catch (InstantiationException | IllegalAccessException |
        IllegalArgumentException | InvocationTargetException
        | NoSuchMethodException | SecurityException e) {
      e.printStackTrace();
    }
  }
}

Obtenez toutes les méthodes

• ** Énumération de méthode publique de la classe File avec la méthode getMethods **
• Renvoie une méthode publique sous forme de tableau d'objets Method
• Si vous voulez prendre autre chose que public, récupérez toutes les méthodes avec la ** méthode getDeclaredMethods **

import java.io.File;

public class ReflectMethods {

  public static void main(String[] args) {
    //Obtenir la classe File
    var str = File.class;
    //Répertoriez les méthodes publiques sous la classe File avec getName
    for (var m : str.getMethods()) {
      System.out.println(m.getName());
    }
  }
}

Exécution de la méthode

• ** Exécuter via l'objet Method **
• ** Méthode GetMethod ** pour obtenir une méthode individuelle et ** invoquer une méthode ** pour exécuter

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

public class ReflectInvoke {

  public static void main(String[] args) {
    try {
      //Obtenir la classe File
      var clazz = File.class;
      //Création d'objet fichier
      var f1 = clazz.getConstructor(String.class).newInstance("./data/data.txt");
      var f2 = clazz.getConstructor(String.class).newInstance("./data/sample.txt");
      //Récupérer et exécuter la méthode renameTo
      Method m = clazz.getMethod("renameTo", File.class);
      System.out.println(m.invoke(f1, f2));
    } catch (NoSuchMethodException | SecurityException |
        InstantiationException | IllegalAccessException
        | IllegalArgumentException | InvocationTargetException e) {
      e.printStackTrace();
    }
  }
}

Acquisition de champ, réglage

• le champ public est obtenu par la ** méthode getField **
• D'autres champs peuvent être obtenus avec la ** méthode getDeclaredFiled **
• L'argument spécifie le nom du champ que vous souhaitez obtenir
• Après avoir obtenu l'objet Field, récupérez / définissez la valeur du champ avec la ** méthode get / set **
• Les champs privés ne sont pas accessibles tels quels, autorisez donc explicitement l'accès avec la ** méthode setAccessible **
• Remarque: la réflexion est ** lente **

//Obtient le champ lastName de la classe Person

import java.lang.reflect.InvocationTargetException;
import example.Person;

public class ReflectField {

  public static void main(String[] args) {
    try {
      var clazz = Person.class;
      var con = clazz.getConstructor(String.class, String.class);
      var p = con.newInstance("Taro", "Yamada");
      //Acquisition sur le terrain
      var last = clazz.getDeclaredField("lastName");
      //Autoriser explicitement l'accès aux champs privés
      last.setAccessible(true);
      //get/Obtenir la valeur du champ avec la méthode set/Configuration
      last.set(p, "Suzuki");
      System.out.println(last.get(p)); //Suzuki
    } catch (NoSuchMethodException | SecurityException |
        InstantiationException | IllegalAccessException
        | IllegalArgumentException | InvocationTargetException |
        NoSuchFieldException e) {
      e.printStackTrace();
    }
  }
}

package example;
public class Person {
  private String firstName;
  private String lastName;
  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  @Override
  public String toString() {
    return String.format("Nom est,%s %s.",
        this.lastName, this.firstName);
  }
  public String getLastName() {
    return this.lastName;
  }
  public String getFirstName() {
    return this.firstName;
  }
}