Java에서 주석과 리플렉션을 사용하는 방법

1. Annotation

1.1 Annotation이란

Annotation은 프로그램 자체가 아니며, 프로그램 컴파일, 클래스 로딩, 런타임 중에 읽을 수 있으며 그에 따른 처리를 수행할 수 있습니다. 어노테이션의 형식은 "@annotation 이름(매개변수 값)"으로 패키지, 클래스, 메소드, 필드에 첨부할 수 있으며 리플렉션 메커니즘을 통해 어노테이션에 액세스할 수 있습니다.

1.2 내장 주석

@Override: 메서드를 재정의하도록 하위 클래스를 제한합니다.

이 주석은 하위 클래스가 상위 클래스 메서드를 재정의할 때 하위 클래스가 실제로 해당 메서드를 재정의한다는 것을 나타냅니다. 하위 수준 오류를 방지하기 위한 클래스 메서드

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

@Deprecated: 더 이상 사용되지 않음으로 표시

이 주석은 속성, 메서드 또는 클래스가 더 이상 사용되지 않음을 나타냅니다(일반적으로 프로그래머가 사용하지 않는 프로그램 요소는 다음과 같습니다. 위험하거나 더 나은 대안이 존재하기 때문에) 다른 프로그램이 사용되지 않는 속성, 메서드 또는 클래스를 사용할 때 컴파일러는 경고(취소선)를 표시합니다.

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

@SuppressWarnings(매개변수): 컴파일러 경고 표시를 억제합니다

이 주석의 영향을 받는 클래스, 메서드 및 속성은 주로 경고 설명 및 취소(선택 해제)용입니다.

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

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

1.3 메타 주석(meta-annotation)

메타 주석의 역할은 다른 주석에 주석을 다는 것입니다. Java는 4가지 표준 메타 주석 유형을 정의하여 다른 주석의 범위와 유형을 설명하는 데 사용됩니다. 다른 주석은 메타 주석을 통해 사용자 정의할 수 있습니다.

@Target: 주석 사용 범위 설명

예를 들어 @Target(ElementType.METHOD)은 메서드에 대한 작업을 의미하고, @Target(ElementType.TYPE)은 클래스 또는 인터페이스에 대한 작업을 의미합니다.

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

@Retention: 주석 정보를 어느 수준에 저장해야 하는지 나타내며, 주석의 수명 주기를 설명하는 데 사용됩니다. 일반적으로 사용자 정의 주석은 런타임 효과인 @Retention(RetentionPolicy.RUNTIME)을 사용합니다.

/**
 * @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: 이 주석이 javadoc에 포함될 것임을 나타냅니다.

@Iherited: 하위 클래스가 상위 클래스의 정의를 상속할 수 있는지 여부를 정의하는 주석입니다.

@Inherited는 @Target(ElementType.TYPE) 유형 주석에만 유용하며 인터페이스 상속이 아닌 클래스 상속만 가능합니다.

1.4 사용자 정의 주석

주석 정의

/**
 * 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";
}

참고 사용

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

2. 반사

2.1 반사 및 반사 메커니즘

Reflection

반사(reflection)는 프로그램이 런타임 중에 객체에 대해 얻을 수 있는 모든 정보를 말합니다.

리플렉션 메커니즘

리플렉션 메커니즘은 프로그램이 실행될 때 Reflection API를 통해 모든 클래스의 콘텐츠 정보를 얻고, 모든 객체의 내부 속성과 메서드를 직접 조작할 수 있다는 의미입니다.

2.2 Class 클래스 및 공통 메소드 획득 방법

reflection을 구현하는 핵심 클래스인 java.lang.Class 클래스 클래스 로딩이 완료되면 힙의 메소드 영역에 Class 객체가 생성됩니다. 메모리(클래스에는 하나의 클래스 객체만 있음), 이 객체에는 클래스의 전체 구조 정보가 포함되어 있으며 이 객체를 통해 클래스의 구조를 볼 수 있습니다. class 클래스 클래스를 얻는 방법 클래스 클래스 클래스의 메소드 메드 메드 이름 method method functative forname (문자열 이름) 지정된 클래스 이름

Obiect newInstance()

매개변수 없는 생성자를 호출하고 클래스 객체의 인스턴스를 반환합니다.

String getName()

표현된 엔터티(클래스, 인터페이스, 배열 클래스 또는 void)를 반환합니다. 이 클래스 객체에 따라 get get get get alfield [] getFields () 커널러 GetConstructor (class & lt;? & gt; ... ParameterTypes Constructor getConstructors ()A getAnnotation(Class6b3d0130bba23ae47fe2b8e8cddf0195 annotationClass)Annotation [] 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());
    }
}

Class getSuperclass()의 이름	현재 Class 객체의 상위 클래스의 Class 객체를 반환합니다.
Class[] getinterfaces()	현재 Class 객체의 인터페이스를 반환합니다.
ClassLoader getClassLoader()	이 클래스의 클래스 로더를 반환합니다
Method getDeclareMethod(String name, Class6b3d0130bba23ae47fe2b8e8cddf0195 ...parameterTypes)	메서드 이름과 매개변수 목록이 일치하는 메소드를 가져옵니다
Method[] getDeclareMethods()	상속되지 않은 모든 메소드 가져오기
Method[] getMethods()	모든 비공개 메소드 가져오기
Field getDeclareField(문자열 이름)	지정된 항목 가져오기 Attributedfield [] getDeclareFields ()
모든 비 프리브레이트 속성
매개변수 목록이 일치하는 생성자를 가져옵니다.
클래스의 모든 생성자 가져오기
지정된 주석 반환
모든 주석 반환

위 내용은 Java에서 주석과 리플렉션을 사용하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!