ప్రతిబింబాన్ని ఉపయోగించి డేటాను పొందడం

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.మెథడ్ క్లాస్

సూపర్! మేము మా తరగతి ఫీల్డ్‌ల గురించి మాట్లాడాము. ఇప్పుడు పద్ధతుల గురించి మాట్లాడే సమయం వచ్చింది.

మెథడ్ ఆబ్జెక్ట్‌ని పొందడానికి , మేము 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 పద్ధతి తరగతి యొక్క పేరెంట్ ఉల్లేఖనాలను కూడా యాక్సెస్ చేయడానికి అనుమతిస్తుంది.

పద్ధతులు మరియు ఫీల్డ్‌లతో ప్రతిబింబం ఎలా పని చేస్తుందో మరియు దానితో మనం ఎలాంటి డేటాను పొందగలమో ఈ రోజు మనం తెలుసుకున్నాము!