பிரதிபலிப்பைப் பயன்படுத்தி தரவைப் பெறுதல்

java.lang.reflect.Field class

ஃபீல்ட் கிளாஸ் என்பது ஒரு கிளாஸ் அல்லது இன்டர்ஃபேஸின் ஒற்றைப் புலத்தைப் பற்றிய தகவல்களை மற்றும் டைனமிக் அணுகலை வழங்குகிறது. பெறுதல் அல்லது அமைவு அணுகல் செயல்பாட்டின் போது விரிவுபடுத்தும் வகை மாற்றத்தையும் புலம் அனுமதிக்கிறது, ஆனால் குறுகலானது ஏற்பட்டால், சட்டத்திற்குப் புறம்பாக ஆர்குமென்ட் எக்செப்சனை வீசுகிறது.

புலப் பொருளைப் பெற , முதலில் ஒரு வகுப்பை எழுதுவோம்:

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

எங்கள் வகுப்பின் புலங்களின் பட்டியலைப் பெறுவது இதுதான், நாங்கள் பின்னர் வேலை செய்வோம். இதோ முடிவு:

இப்போது இந்த தரவை என்ன செய்ய முடியும் என்பதைக் கண்டுபிடிப்போம். புல வகுப்பின் முறைகளைப் பற்றி பேசலாம் :

getType(), getName(), and 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("Field type - %s\nField name - %s\n\n", e.getType(), e.getName()));
}

இப்போது முடிவு இன்னும் புரிந்துகொள்ளத்தக்கது:

நன்று! நம் முறையை இன்னும் கொஞ்சம் மாற்றுவோம்! அணுகல் மாற்றிகளை இங்கு சேர்ப்போம்

static void printFieldInfo(List<Field> fields){
   fields.forEach(e -> System.out.printf("Field type - %s\nField name - %s\nModifiers - %s\n\n", e.getType(), e.getName(), Modifier.toString(e.getModifiers())));
}

மேலும் e.getModifiers() என்ன கொடுக்கிறது என்பதைப் பார்ப்போம் . இந்த முறை ஒரு எண்ணை வழங்குகிறது , இது எங்கள் புலத்தின் அணுகல் மாற்றிகளின் நிலையை தீர்மானிக்க உதவுகிறது. மாற்றி வகுப்பானது புலத்தின் ஒவ்வொரு குறிப்பிட்ட மாற்றிக்கும் பொறுப்பான நிலையான மாறிகளைக் கொண்டுள்ளது .

நமது வருமான மதிப்பை Modifier.toString() இல் சுருக்கி , அதன் மதிப்பை உடனடியாக உரையாகப் பெறுவோம்:

Modifier.toString() இல்லாமல் எப்படி இருக்கும் என்பது இங்கே :

getAnnotations(), getAnnotatedType(), and getGenericType() முறைகள்

இந்த முறைகளுடன் வேலை செய்ய, நபர் வகுப்பை மாற்றுவோம் . நாங்கள் எங்கள் சொந்த சிறுகுறிப்பை எழுதி அதை எங்கள் புலங்களில் பயன்படுத்துவோம். மேலும் சில துறைகளைச் சேர்ப்போம்.

இரண்டு சிறுகுறிப்புகளை உருவாக்குவோம். பிக் லத்தீன் மொழியில் மாறி பெயரை ஒன்றுக்கு அனுப்புவோம், மேலும் இரண்டாவதாக உறுப்புகளுக்குப் பயன்படுத்துவோம்:

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

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

எங்கள் முக்கிய வகுப்பையும் நபர் வகுப்பையும் மாற்றுவோம் :

public class Person {
    @Name(name = "Ame-nay")
    private String name;

    @Name(name = "User nicknames")
    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 வகுப்பு

அருமை! நாங்கள் எங்கள் வகுப்பின் துறைகளைப் பற்றி பேசினோம். இப்போது முறைகளைப் பற்றி பேச வேண்டிய நேரம் இது.

ஒரு முறை பொருளைப் பெற , நாம் getMethod முறையை அழைக்கிறோம், அதை எங்கள் முறையின் பெயரைக் கடந்து செல்கிறோம். ஒரு முறை பொருளைப் பெறுவதற்கான அடிப்படை வழி இது :

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

நாங்கள் எங்கள் வகுப்பில் தொடர்ந்து பணியாற்றுவோம். பெறுபவர்கள் மற்றும் செட்டர்கள் மற்றும் ஹாஷ்கோட், சமம் மற்றும் ஸ்ட்ரிங் முறைகளைச் சேர்ப்போம் :

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

எங்கள் முக்கிய முறை இங்கே :

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

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

எங்கள் முடிவு:

எங்களின் அனைத்து முறைகளிலும் பொது மாற்றி உள்ளது, எனவே கடைசி முறை ஒரு வரிசையை வழங்குகிறது. நாங்கள் எங்கள் குறியீட்டை மாற்றினால், எங்களுடைய மாற்றியமைப்பாளர்களையே பார்ப்போம்:

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()

ஒரு அளவுரு வகையில் மூடப்பட்ட வகையை வழங்கும் முறையை எங்கள் நபர் வகுப்பிற்கு வழங்குவோம் , மேலும் அதன் திரும்பும் மதிப்பைப் பெற முயற்சிப்போம்:

public List<String> someMethod() {
    // Very useful and important method
    return null;
}

எங்கள் முக்கிய முறையை நாங்கள் புதுப்பிப்போம்:

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

எங்கள் முறையின் முடிவு:

getParameterTypes() மற்றும் getGenericParameterTypes() முறைகள்

மேலும் இரண்டு முறைகளைச் சேர்த்து, எங்கள் நபர் வகுப்பைத் தொடர்ந்து மாற்றுகிறோம் :

public List<String> someMethod(List<String> list, String s) {
    // Very useful and important method
    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 {}
}

எங்கள் செயலி வகுப்பில் முறைகளை அழைப்போம் :

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 {
    }
}

மற்றும் முக்கிய முறையின் குறியீடு :

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

இந்த முறையின் உள்ளே, டைப்வேரியபிள்ஸ் ஆப்ஜெக்ட் கிடைத்தது , இது வகை மாறிகளுக்கான பொதுவான பெற்றோர் இடைமுகமாகும். அதன் உள்ளே, நாம் இப்போது உள் அளவுருவைப் பெறலாம், அதாவது நமது உள்ளமை விதிவிலக்கு:

getAnnotations() மற்றும் getDeclaredAnnotations() முறைகள்

இந்தப் புதிய வகுப்பைத் தொடர்ந்து பயன்படுத்துவோம், மேலும் அதில் இரண்டு சிறுகுறிப்புகளைச் சேர்ப்போம். எங்கள் சொந்த சிறுகுறிப்பு சிறுகுறிப்பை உருவாக்குவோம் :

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

எங்கள் முக்கிய முறையை செயல்படுத்துதல்:

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

இதன் விளைவாக வரும் திரை வெளியீடு:

எங்கள் முறைகளுக்குப் பயன்படுத்தப்பட்ட சிறுகுறிப்புகளை இப்படித்தான் பெறலாம், மேலும் getAnnotations முறையானது வகுப்பின் பெற்றோர் சிறுகுறிப்புகளையும் அணுக அனுமதிக்கிறது.

பிரதிபலிப்பு முறைகள் மற்றும் புலங்களுடன் எவ்வாறு செயல்பட முடியும் என்பதையும், அதனுடன் என்ன தரவைப் பெறலாம் என்பதையும் இன்று நாம் அறிந்தோம்!