Տվյալների ստացում ռեֆլեքսիայի միջոցով

Կլասը java.lang.reflect.Field

Կլասը Field տրամադրում է տեղեկատվություն և դինամիկ մուտք դեպի դասի կամ ինտերֆեյսի մեկ դաշտ: Field նույնպես թույլ է տալիս ընդլայնում փոխակերպումների ժամանակ get կամ set մուտքի աշխատանքում, բայց տեղադրում է IllegalArgumentException բացառություն, եթե տեղի է ունենում նեղացում փոխակերպման ժամանակ:

Որպեսզի ստանաք Filed կլասը, մենք կգրենք կլասը, որի հետ կաշխատենք, ինչպես նաև դրա համար ցուցիչ:

public class Person {
    private String name;
    private int age;
    
    public boolean isMale;
    
    protected String address;
    
    public static final int MAX_AGE = 120;
    public static final int MIN_AGE = 0;
}

Եվ հենց ցուցիչը:

public class Main {
    public static void main(String[] args) {
        Field[] fields = Person.class.getDeclaredFields();
        List<Field> actualFields = getFieldNames(fields);
        System.out.println(actualFields);
    }

    static List<Field> getFieldNames(Field[] fields) {
        return List.of(fields);
    }
}

Այսպիսով մենք ստանում ենք մեր դասի դաշտերի ցանկը, որոնց հետ կշարունակենք աշխատել: Արդյունքը տեսք կունենա այսպես:

Հիմա եկեք տեսնենք, թե ինչ կարող ենք անել այս տվյալների շրջանակի հետ: Խոսենք Field կլասի մեթոդների մասին:

Մեթոդներ getType(), getName(), getModifiers()

Օգտագործելով getType() մեթոդը, մենք կարող ենք ստանալ մեր դաշտի տեսակն: Եկեք գրենք մեթոդ:

static void printTypes(List<Field> fields){
      fields.forEach(e -> System.out.println(e.getType()));
  }

Եվ կստանանք այսպիսի արդյունք:

Եկեք անմիջապես մեր դասում ավելացնենք մեթոդ, որը կստացնի դաշտի անունը: Այսպես ավելի հեշտ կլինի կողմնորոշվել մեր դասի դաշտերի միջոցով:

static void printTypesAndNames(List<Field> fields){
   fields.forEach(e -> System.out.printf("Դաշտի տեսակ - %s\nԴաշտի անուն - %s\n\n", e.getType(), e.getName()));
}

Արդյունքը կդառնա ավելի հասկանալի օգտագործողի համար:

Հիանալի, եկեք նաև մեր մեթոդը ավելի մոդիֆիկացնենք: Ավելացնենք այստեղ մուտքի մոդիֆիկատորները:

static void printFieldInfo(List<Field> fields){
   fields.forEach(e -> System.out.printf("Դաշտի տեսակ - %s\nԴաշտի անուն - %s\nՄոդիֆիկատորներ - %s\n\n", e.getType(), e.getName(), Modifier.toString(e.getModifiers())));
}

Եվ եկեք քննարկենք, թե ինչ է վերադարձնում e.getModifiers(): Այս մեթոդը վերադարձնում է int թիվ, որի մեջ կարող ենք որոշել դաշտի մուտքի մոդիֆիկատորը: Modifier կլասում կան ստատիկ փոփոխականներ, որոնք պատասխանատու են կոնկրետ մոդիֆիկատորի համար:

Մեր վերադարձվելիք արժեքը կտեղավորենք Мodifier.toString() — և անմիջապես կստանանք արժեքը տեքստային տեսքով:

Եվ այսպես է դա երևում առանց Мodifier.toString():

Մեթոդներ getAnnotations(), getAnnotatedType(), getGenericType()

Եկեք մոդիֆիկացնենք Person կլասը, որպեսզի աշխատենք ընթացիկ մեթոդների հետ: Մենք կգրենք մեր սեփական անոտացիան, որը կավելացնենք մեր դաշտերին, ինչպես նաև կավելացնենք մի քանի դաշտ:

Ստեղծենք երկու անոտացիաներ: Մեկին կփոխանցենք փոփոխականի անունը ռուսերենով, իսկ երկրորդը կօգտագործենք տարրերի համար:

@Target(value=ElementType.FIELD)
@Retention(value= RetentionPolicy.RUNTIME)
public @interface Name {
    String name();
}

@Target({ ElementType.TYPE_USE })
@Retention(RetentionPolicy.RUNTIME)
public @interface Number {
}

Եվ փոփոխենք մեր հիմնական կլասը և Person: կլասը:

public class Person {
    @Name(name = "Имя")
    private String name;

    @Name(name = "Никнэймы пользователя")
    List<String> nicknames;

    private final Class<Object> type;

    private int @Number[] number;

    public Person(Class<Object> type) {
        this.type = type;
    }
}

public static void main(String[] args) {
    Field[] fields = Person.class.getDeclaredFields();
    List<Field> actualFields = getFieldNames(fields);
    
    printAdditionalInfo(actualFields);
}

static void printAdditionalInfo(List<Field> fields) {
   System.out.println("\ngetAnnotatedType:");
   fields.forEach(e -> System.out.println(e.getAnnotatedType()));

   System.out.println("\ngetGenericType:");
   fields.forEach(e -> System.out.println(e.getGenericType()));

   System.out.println("\ngetAnnotations:");
   fields.forEach(e -> System.out.println(Arrays.toString(e.getAnnotations())));
}

Ամեն ինչ պատճաշ է ՝ հստակ տեսնենք մեր մեթոդների արդյունքը և խոսենք նրանց նշանակության մասին:

• getAnnotatedType վերադարձնում է դաշտի անոտացիան, եթե կա: Մենք ունենք դաշտի անոտացիա և մենք դա լավ տեսնում ենք:

• getGenericType թույլ է տալիս ճիշտ ցույց տալ գեներացված պարամետրերը.

• getAnnotations վերադարձնում է անոտացիաները, որոնք դրված են մեր օբյեկտի վրա:

Այսպիսով մենք հեշտությամբ կարող ենք ստանալ բոլոր տվյալները մեր դասի յուրաքանչյուր դաշտի մասին, նրա մուտքի մոդիֆիկատորների մասին, անոտացիաների և տվյալների տեսակների մասին:

Կլասը java.lang.reflect.Method

Սուպեր, մենք խոսեցինք մեր դասի դաշտերի մասին, հիմա ժամանակն է խոսել մեթոդների մասին:

Որպեսզի ստանաք Method կլասի օբյեկտ, մենք կանչում ենք getMethod և դրան փոխանցում մեր մեթոդի անունը: Սա հիմնարար մեթոդն է Method կլասի ստացման համար:

Method getNameMethod =  Person.class.getMethod("getName");

Մենք կշարունակենք աշխատել մեր դասի հետ: Ավելացնենք անդամներից և set-երները, hashCode-երը, equals և toString-ը:

public class Person {
    private String name;
    private int age;

    public boolean isMale;

    protected String address;

    public static final int MAX_AGE = 120;
    public static final int MIN_AGE = 0;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isMale() {
        return isMale;
    }

    public void setMale(boolean male) {
        isMale = male;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", isMale=" + isMale +
                ", address='" + address + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && isMale == person.isMale && Objects.equals(name, person.name) && Objects.equals(address, person.address);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, isMale, address);
    }
}

Եվ եկեք պատրաստենք մեթոդների հավաքածուն, որոնք մենք կքննարկենք Method կլասի մեջ: Ահա հիմնական մեթոդների ցուցակը:

Մեր դասի վերադարձվելիք մեթոդների զանգվածը ստանալու համար կարող ենք կանչել այսպիսի մեթոդ:

Method[] methods = Person.class.getDeclaredMethods();

Օգտագործելով այս, մենք կստանանք մեր դասից բոլոր մեթոդները:

Մեթոդներ getName() և getModifiers()

Մեր բոլոր մեթոդների անունները ստանալու համար կարող ենք օգտագործել getName:

static List<String> getMethodsName(Method[] methods) {
    return Arrays.asList(methods)
            .stream()
            .map(Method::getName)
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
}

Եվ որպեսզի ստանանք մոդիֆիկատորները, կգրենք մեթոդ getModifiers կիրառությամբ:

static List<String> getModifiers(Method[] methods) {
    return Arrays
            .stream(methods)
            .map(Method::getModifiers)
            .map(String::valueOf)
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
}

Մեր main մեթոդը:

public static void main(String[] args) {
    Method[] methods = Person.class.getDeclaredMethods();

    System.out.println(getMethodsName(methods));
    System.out.println(getModifiers(methods));
}

Մեր արդյունքը:

Մեր բոլոր մոդիֆիկատորներն ունեն public մուտք, ուստի վերջին մեթոդը մեզ վերադարձնում է միավորներ: Եթե մենք մեր կոդը փոփոխենք, ապա կտեսնենք մեր մոդիֆիկատորները:

public static void main(String[] args) {
    Method[] methods = Person.class.getDeclaredMethods();

    System.out.println(getMethodsName(methods));
    System.out.println(modifyModifiers(getModifiers(methods)));
}

getReturnedType()

Օգտագործելով այս մեթոդը, մենք կարող ենք ստանալ մեթոդի վերադարձվող տիպը:

static void getReturnedType(Method[] methods) {
    Arrays.stream(methods)
            .map(Method::getReturnType)
            .forEach(System.out::println);
}

getGenericReturnType()

Ավելացնենք մեր Person կլասի մեջ մեթոդ, որը վերադարձնում է գեներացված տիպ, և փորձենք ստանալ նրա վերադարձվող արժեքը:

public List<String> someMethod() {
    //շատ օգտակար և կարևոր մեթոդ
    return null;
}

Եվ փոփոխենք մեր հիմնական մեթոդը:

static void getGenericReturnType(Method[] methods) {
    Arrays.stream(methods)
            .map(Method::getGenericReturnType)
            .forEach(System.out::println);
}

Մեր մեթոդի արդյունքը:

Մեթոդներ getParameterTypes() և getGenericParameterTypes()

Շարունակենք փոփոխել մեր Person կլասի մեթոդը և ավելացնենք ևս երկու մեթոդներ:

public List<String> someMethod(List<String> list, String s) {
    //շատ օգտակար և կարևոր մեթոդ
    return null;
}

Գեներացված պարամետրերը նույնպես ցույց կտան։

static void getParameterTypes(Method[] methods) {
    Class<?>[] types = method.getParameterTypes();
        for (Class<?> type : types) {
            System.out.println(type);
        }
}

static void getGenericParameterTypes(Method[] methods) {
   Type[] types = method.getGenericParameterTypes();
        for (Type type : types) {
            System.out.println(type);
        }
}

Աշխատանք կատարելու համար կդիմենք միայն մեկ մեր մեթոդներից մեկին: Որպեսզի դիմենք մեթոդին անունով, մենք կանչում ենք getMethod և դրան փոխանցում ենք անունը և մեր պահանջվող մեթոդի պարամետրերը:

public static void main(String[] args) throws NoSuchMethodException {
    Method currentMethod = Person.class.getMethod("someMethod", List.class, String.class);

    getParameterTypes(currentMethod);
    System.out.println();
    getGenericParameterTypes(currentMethod);
}

Եվ մեր կոդի արդյունքներում մենք կտեսնենք տարբերությունները և արդյունքները, որոնք հենց նրանք վերադարձնում են:

Մեթոդներ getExceptionTypes() և getGenericExceptionTypes()

Օգտագործելով այս մեթոդները մենք կարող ենք ստանալ բացառությունների զանգված, որոնք կարող է արտանետել մեր մեթոդը, ինչպես նաև գեներացված պարամետրերով (եթե այդպիսիք կան) բացառություններ: Մենք վերցնենք մի նոր օրինակ՝ թաքնված ստատիկ դասով:

private static class Processor {
    private void init() {}

    private void process() throws IOException {}
}

Կմտնենք այն մեթոդներից մեկի մեջ, ահա այսպես՝ Process:

public static void main(String... args) throws NoSuchMethodException {
    Method method = Processor.class.getDeclaredMethod("process");
    Type[] type = method.getExceptionTypes();
    System.out.println(Arrays.toString(type));
}

Հիանալի, այսպես տեսնում ենք մեր բացառությունը:

Հիմա մեր բոլորի մոտ դնում է նորով `կակա կոնակը. Մենք այն տեղադրում ենք մեր հիմնական դասում:

private static class Processor<E extends IOException> {

    private void process() throws E {
    }
}

Եվ Main: միջաշինքի կոդզ՝ այստեղ արդեն առկա է փոփոխություն:

public static void main(String... args) throws NoSuchMethodException {
    Method m = Processor.class.getDeclaredMethod("process");
    Type[] t = m.getGenericExceptionTypes();
    System.out.println(Arrays.toString(t));

    for (Type type : t) {
        if (type instanceof TypeVariable) {
            for (Type type1 : ((TypeVariable) type).getBounds()) {
                System.out.println(type1);
            }
        }
    }
}

Մեր մեթոդի ներսում մենք ստացանք TypeVariables — դա ընդհանուր սուպեր ինտերֆեյս է տիպի փոփոխականների համար: Եվ դրա ներսում կարող ենք ստանալ ներքին պարամետրը, հենց մեր ներքին արտադրական բացառումից:

Մեթոդներ getAnnotations() և getDeclaredAnnotations()

Շարունակե՛նք աշխատել մեր նոր դասի հետ և ավելացնենք երկու անոտացիաներ: Ստեղծենք մեր սեփական Annotation անոտացիան:

@Retention(RetentionPolicy.RUNTIME)
@interface Annotation {

    public String key();
    public String value();
}

Եվ ավելացնենք այն մեր մեթոդի մեջ.

@Annotation(key = "key", value = "value")
private void process() throws E{

}

Եվ իհարկե, ստեղծեք մեթոդ, որը ցուցադրում է մեր բոլոր անոտացիաները:

static void getMethodAnnotations(Class<?> clazz) {
    Method[] methods = clazz.getDeclaredMethods();
    for (Method method : methods) {
        System.out.println(method.getName());
        System.out.println(Arrays.toString(method.getAnnotations()));
        System.out.println();
    }
}

Մեր դասի՝ Main:

public static void main(String... args) {
    Class clazz = Processor.class;
    getMethodAnnotations(clazz);
}

Արդյունքում կստանանք այսպիսի արդյունք պատուհանի վրա:

Այսպիսով մենք կարող ենք ստանալ մեր մեթոդների անոտացիաները, իսկ getAnnotations մեթոդի միջոցով մենք ստանում ենք հասանելիություն նաև ծնողական դասի անոտացիաներին:

Այսօր մենք ծանոթացանք մեթոդների և դաշտերի հետ ռեֆլեքսիայի միջոցով և տեսանք, թե ինչ տվյալներ կարող ենք ստանալ նրանց միջոցով: