Comment utiliser les annotations et la réflexion en Java

1. Annotation

1.1 Qu'est-ce qu'une annotation

Les annotations ne sont pas le programme lui-même et peuvent être lues pendant la compilation du programme, le chargement de la classe et l'exécution. Obtenez-le et effectuez les tâches correspondantes. traitement. Le format de l'annotation est "@annotation name (valeur du paramètre)", qui peut être attaché aux packages, classes, méthodes et champs, et l'annotation est accessible via le mécanisme de réflexion.

1.2 Annotation intégrée

@Override : Restreindre la méthode de remplacement de sous-classe

Cette annotation indique que le remplacement is Méthodes de sa classe parent Lorsqu'une sous-classe remplace une méthode de la classe parent, assurez-vous que la sous-classe remplace réellement la méthode de la classe parent pour éviter les erreurs de bas niveau

/**
 * 该注解标识覆盖的是其父类的方法，当子类重写父类方法时，确保子类确实重写了父类的方法，避免出现低级错误
 * @return
 */
@Override
public String toString() {
    return super.toString();
}

@ Obsolète : marqué comme obsolète

Cette annotation indique qu'une propriété, une méthode ou une classe est obsolète (un élément de programme qu'il est déconseillé aux programmeurs d'utiliser, généralement parce qu'il est dangereux ou parce qu'il est meilleur existe une méthode alternative), le compilateur donnera un avertissement (barré) lorsque d'autres programmes utilisent des propriétés, des méthodes ou des classes obsolètes.

/**
 * 该注解表示此方法已过时，存在危险，不推荐使用，其有代替方法，如果继续使用会通过删除线进行标识
 */
@Deprecated
public static void test() {
    System.out.println("标记已过时");
}

@SuppressWarnings(parameter): Supprimer les avertissements du compilateur

Les classes, méthodes et propriétés affectées par cette annotation supprimeront l'affichage du compilateur avertissements , ses paramètres sont principalement destinés aux instructions d'avertissement et à l'annulation (non cochée), etc.

@SuppressWarnings("取消此类的所有警告")
public class BuiltAnnotation {
    
    @SuppressWarnings("取消此属性的警告")
    private String username;

    @SuppressWarnings("取消此方法的警告")
    public static void main(String[] args) {
        // ...
    }
}

1.3 Méta-annotation

Le rôle de la méta-annotation est d'annoter d'autres annotations Java définit 4 types de méta-annotations standard, qui sont utilisés. Fournit des descriptions de la portée. et les types d'autres annotations, et d'autres annotations peuvent être personnalisées via des méta-annotations.

@Target : Décrire le champ d'utilisation des annotations

Par exemple, @Target(ElementType.METHOD) signifie agir sur une méthode, @Target(ElementType .TYPE) indique qu'il agit sur une classe ou une interface, etc.

/**
 * @Target注解：描述注解的使用范围
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * 类或接口：ElementType.TYPE；
     * 字段：ElementType.FIELD；
     * 方法：ElementType.METHOD；
     * 构造方法：ElementType.CONSTRUCTOR；
     * 方法参数：ElementType.PARAMETER；
     * ...
     */
    ElementType[] value();
}

@Rétention : Indique à quel niveau les informations d'annotation doivent être enregistrées, utilisées pour décrire le cycle de vie de l'annotation#🎜 🎜#

Habituellement, les annotations personnalisées utilisent @Retention(RetentionPolicy.RUNTIME), qui est l'effet d'exécution.

/**
 * @Retention：表示需要在什么级别保存该注解信息，用于描述注解的生命周期
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    /**
     * RetentionPolicy.SOURCE：仅编译期，注解将被编译器丢弃。
     * RetentionPolicy.CLASS：仅class文件，注释将由编译器记录在类文件中，但VM不需要在运行时保留，如果不指定则默认为class。
     * RetentionPolicy.RUNTIME：运行期，注释将由编译器记录在类文件中，并由VM在运行时保留，因此可以反射读取。通常自定义的注解都是RUNTIME。
     * 范围：RUNTIME>CLASS>SOURCE
     */
    RetentionPolicy value();
}

@Document : Indique que cette note sera incluse dans le javadoc

@Iherited : Définit si les sous-classes sont héritables Annotations définies par la classe parent.

@Inherited n'est utile que pour les annotations de type @Target(ElementType.TYPE), et ne peut être qu'un héritage de classe, pas un héritage d'interface :

1.4 Annotation personnalisée

Annotation de définition

/**
 * 1. 使用@interface定义注解；
 * 3. 通过元注解配置该注解，配置注解的使用范围和生命周期等
 * @author Loner
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Report{
    /**
     * 2. 添加参数、默认值，如果没有默认值，就必须给参数赋值，一般把最常用的参数定义为value()，推荐所有参数都尽量设置默认值
     * 形式为：参数类型 参数名()；
     */
    int type() default 0;
    String value() default "LonerMJ";
}

Utiliser l'annotation

@Report(type = 1, value = "test")
public class CustomerAnnotation {
    @Report(type = 1, value = "test")
    public void testCustomerAnnotation() {
        System.out.println("测试自定义注解");
    }
}

2. Réflexion

2.1 Réflexion et mécanisme de réflexion

Réflexion

Réflexion (réflexion) fait référence au programme peut obtenir tout informations sur un objet pendant l'exécution.

Mécanisme de réflexion

Le mécanisme de réflexion signifie que lorsque le programme est en cours d'exécution, il obtient les informations de contenu de n'importe quelle classe via l'API Reflection, et peut exploiter directement toutes les propriétés et méthodes internes de l'objet.

2.2 Comment obtenir la classe Class et les méthodes communes

java.lang.Class class, la classe principale qui implémente la réflexion, une fois le chargement de la classe terminé, dans la méthode zone de la mémoire tas Un objet Class sera généré (une classe n'a qu'un seul objet Class). Cet objet contient les informations structurelles complètes de la classe. Vous pouvez voir la structure de la classe à travers cet objet.

Comment obtenir la classe Class

public class InstantiationClass {
    public static void main(String[] args) throws ClassNotFoundException {
        Teacher teacher = new Teacher("张三", "123456");

        // 方式一：调用Class类的静态方法forName(String className)
        Class<?> c1 = Class.forName("com.loner.mj.reflection.Teacher");

        // 方式二：已知某个类的实例，调用该实例的getClass()方法，getClass是Object类中的方法。
        Class<? extends Teacher> c2 = teacher.getClass();

        // 方式三：已知具体类，通过类的class属性获取，该方法最安全可靠，程序性能最高
        Class<Teacher> c3 = Teacher.class;

        // 方式四：通过基本内置类型的包装类的TYPE属性获得CLass实例
        Class<Integer> c4 = Integer.TYPE;

        // 方式五：通过当前子类的Class对象获得父类的Class对象
        Class<?> c5 = c1.getSuperclass();
    }
}

Méthodes courantes de la classe Class#🎜🎜 #

Nom de la méthodeClasse statique pourNom(Nom de la chaîne)#🎜 🎜#Renvoyer l'objet Class du nom de classe spécifiéObiect newInstance()Appelez le constructeur sans paramètre et renvoyez le Objet de classe Une instance de String getName()Renvoie l'entité (classe, interface, classe tableau ou vide) représentée par cette classe object Name Class getSuperclass()Renvoie l'objet Class de la classe parent de l'objet Class actuel Class[] getinterfaces()Renvoie l'interface de l'objet Class actuelClassLoader getClassLoader( ) Obtenez la méthode dont le nom de la méthode correspond à la liste de paramètresMethod[] getDeclareMethods()Obtenez tous les non- méthodes héritéesMethod[] getMethods()Field getDeclareField(String name)Field[] getDeclareFields()#🎜 🎜 #Obtenir tous les attributsObtenir toutes les propriétés non privéesConstructor getConstructor(Class< ;?>... ParameterTypesObtenir la méthode constructeur correspondant à la liste de paramètres Constructeur getConstructors()#🎜 🎜#Renvoyer l'annotation spécifiéeAnnotation[] getDeclaredAnnotations()

public class ReflectionMethods {
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
        Class<Worker> workerClass = Worker.class;

        /**
         * 类
         */
        System.out.println(workerClass.getName());
        System.out.println(workerClass.getSimpleName());
        System.out.println(workerClass.getSuperclass());
        System.out.println(workerClass.getPackage());
        Class<?>[] interfaces = workerClass.getInterfaces();
        for (Class<?> i : interfaces) {
            System.out.println(i);
        }

        /**
         * 属性
         */
        // 获取所有的属性
        Field[] declaredFields = workerClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        // 获取指定属性
        System.out.println(workerClass.getDeclaredField("username"));
        // 获取所有公共属性
        Field[] fields = workerClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        /**
         * 构造方法
         */
        // 获取所有构造方法
        Constructor<?>[] declaredConstructors = workerClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        // 获取指定的构造方法
        System.out.println(workerClass.getDeclaredConstructor(String.class, String.class));

        /**
         * 方法
         */
        // 获取所有的方法
        Method[] declaredMethods = workerClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        // 获取指定方法
        System.out.println(workerClass.getDeclaredMethod("getUsername", null));
        // 获取所有功能方法
        Method[] methods = workerClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
    }
}

哪些类型具有Class对象

public class InstantiationClass {
    public static void main(String[] args) throws ClassNotFoundException {
        // 类（外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类。）
        Class<Object> objectClass = Object.class;
        // 接口
        Class<Comparable> comparableClass = Comparable.class;
        // 数组
        Class<String[]> stringClass = String[].class;
        Class<int[][]> intClass = int[][].class;
        // 枚举
        Class<ElementType> elementTypeClass = ElementType.class;
        // 注解
        Class<Override> overrideClass = Override.class;
        // 基本数据类型
        Class<Integer> integerClass = Integer.class;
        // void
        Class<Void> voidClass = void.class;
        // Class
        Class<Class> classClass = Class.class;
    }
}

2.3 反射的使用

反射操作对象

public class UseClass {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class<User> userClass = User.class;

        /**
         * 通过构造器实例化对象：不使用构造器，默认通过无参构造进行对象创建
         */
        Constructor<User> declaredConstructor = userClass.getDeclaredConstructor(String.class, String.class);
        User user = declaredConstructor.newInstance("张三", "123456");
        System.out.println(user);

        /**
         * 调用方法并执行相关操作
         */
        Method setUsername = userClass.getDeclaredMethod("setUsername", String.class);
        // invoke(Object, 参数)：激活，即执行相关操作为该对象
        setUsername.invoke(user, "李四");
        Method setPassword = userClass.getDeclaredMethod("setPassword", String.class);
        setPassword.invoke(user, "123456");
        System.out.println(user);

        /**
         * 操作属性：通过反射直接操作私有属性会报错，需要通过setAccessible(ture)关闭访问安全检查，此方法属性、方法和构造都具有，会影响效率
         */
        Field username = userClass.getDeclaredField("username");
        username.setAccessible(true);
        username.set(user, "用户名");
        System.out.println(user);
    }
}

反射操作泛型

Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题。但是，一旦编译完成，所有和泛型有关的类型全部擦除。

为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。

ParameterizedType：表示一种参数化类型，比如Collection

GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型

TypeVariable：是各种类型变量的公共父接口

WildcardType：代表一种通配符类型表达式

public class ClassOperateGenerics {
    public Map<String, String> list() {
        System.out.println("返回值是泛型");
        return new HashMap<>();
    }

    public void test(Map<String, User> map, List<Integer> list) {
        System.out.println("参数是泛型");
    }

    public static void main(String[] args) throws NoSuchMethodException {
        /**
         * 获取方法参数的泛型
         */
        Method method = ClassOperateGenerics.class.getMethod("test", Map.class, List.class);
        // 获取所有方法参数的泛型
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            // java.util.Map<java.lang.String, com.loner.mj.reflection.User>
            System.out.println(genericParameterType);
            if (genericParameterType instanceof ParameterizedType) {
                // 获取所有泛型的真实参数
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    // String, User, Integer
                    System.out.println(actualTypeArgument);
                }
            }
        }

        /**
         * 获取方法返回值的泛型
         */
        Method list = ClassOperateGenerics.class.getMethod("list", null);
        // 获取方法返回值的泛型
        Type genericReturnType = list.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType) {
            // 获取所有泛型的真实参数
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

反射操作注解

public class ClassOperateAnnotation {
    public static void main(String[] args) throws NoSuchFieldException {
        Class<People> peopleClass = People.class;

        // 获取类的所有注解
        Annotation[] declaredAnnotations = peopleClass.getDeclaredAnnotations();
        for (Annotation declaredAnnotation : declaredAnnotations) {
            System.out.println(declaredAnnotation);
        }
        // 获取类的注解的值
        Table declaredAnnotation = peopleClass.getDeclaredAnnotation(Table.class);
        System.out.println(declaredAnnotation.value());

        // 获取属性的注解
        Field name = peopleClass.getDeclaredField("name");
        Fields annotation = name.getAnnotation(Fields.class);
        System.out.println(annotation.name());
    }
}

Fonction de la méthode
#🎜🎜 ##🎜🎜 #
	# 🎜🎜#Renvoyer le chargeur de classe de cette classe
Method getDeclareMethod(String name, Class6b3d0130bba23ae47fe2b8e8cddf0195 ... ParameterTypes)#🎜 🎜#
	#🎜 🎜#
Obtenir toutes les méthodes non privées
Obtenir les attributs spécifiés
# 🎜🎜#	Field[] getFields()
#🎜 🎜#
	#🎜🎜 #Obtenir tous les constructeurs de la classe
A getAnnotation(Class6b3d0130bba23ae47fe2b8e8cddf0195 annotationClass)	#🎜 🎜#
Renvoyer toutes les annotations	#🎜🎜 #

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!