பிரதிபலிப்பு API

பிரதிபலிப்பு API எதற்காக?

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

பிரதிபலிப்பு API ஆனது புதிய பொருட்களை உருவாக்கவும், அழைப்பு முறைகள் மற்றும் புல மதிப்புகளைப் பெறவும் அல்லது அமைக்கவும் உங்களை அனுமதிக்கிறது.

பிரதிபலிப்பைப் பயன்படுத்தி நீங்கள் செய்யக்கூடிய அனைத்தையும் பட்டியலிடுங்கள்:

• ஒரு பொருளின் வகுப்பை அடையாளம் காணவும் / தீர்மானிக்கவும்
• வகுப்பு மாற்றிகள், புலங்கள், முறைகள், மாறிலிகள், கட்டமைப்பாளர்கள் மற்றும் சூப்பர்கிளாஸ்கள் பற்றிய தகவலைப் பெறுங்கள்
• செயல்படுத்தப்பட்ட இடைமுகம்(களுக்கு) எந்த முறைகள் சேர்ந்தவை என்பதைக் கண்டறியவும்
• நிரல் செயல்படுத்தப்படும் வரை வகுப்பின் பெயர் தெரியாத ஒரு வகுப்பின் உதாரணத்தை உருவாக்கவும்
• ஒரு நிகழ்வு புலத்தின் மதிப்பை பெயரால் பெற்று அமைக்கவும்
• ஒரு நிகழ்வு முறையை பெயரால் அழைக்கவும்

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

• வலை பயன்பாடுகளை உருவாக்குவதற்கான வசந்த கட்டமைப்புகள்
• ஜூனிட் சோதனை கட்டமைப்பு

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

ஆனால் எப்போதும் நன்மை தீமைகள் உள்ளன. எனவே சில தீமைகளைக் குறிப்பிடுவோம்:

• பயன்பாட்டு பாதுகாப்பின் மீறல்கள். பிரதிபலிப்பு நாம் செய்யக்கூடாத குறியீட்டை அணுக உதவுகிறது (இணைப்பு மீறல்).
• பாதுகாப்பு கட்டுப்பாடுகள். பாதுகாப்பு மேலாளருடன் இயங்கும் கணினிகளுக்கு கிடைக்காத இயக்க நேர அனுமதிகள் பிரதிபலிப்புக்குத் தேவை.
• குறைந்த செயல்திறன். ஜாவாவில் உள்ள பிரதிபலிப்பு கிளாஸ்பாத்தை ஸ்கேன் செய்வதன் மூலம் வகைகளை மாறும் வகையில் தீர்மானிக்கிறது . இது நிரலின் செயல்திறனைக் குறைக்கிறது.
• பராமரிப்பது கடினம். பிரதிபலிப்பைப் பயன்படுத்தும் குறியீடு படிக்கவும் பிழைத்திருத்தவும் கடினமாக உள்ளது. இது குறைந்த நெகிழ்வானது மற்றும் பராமரிப்பது கடினம்.

பிரதிபலிப்பு API ஐப் பயன்படுத்தி வகுப்புகளுடன் பணிபுரிதல்

அனைத்து பிரதிபலிப்பு செயல்பாடுகளும் java.lang.Class பொருளுடன் தொடங்கும். ஒவ்வொரு வகை பொருளுக்கும், java.lang.Class இன் மாறாத நிகழ்வு உருவாக்கப்படுகிறது. இது பொருள் பண்புகளைப் பெறுவதற்கான முறைகளை வழங்குகிறது, புதிய பொருள்களை உருவாக்குகிறது மற்றும் அழைப்பு முறைகள்.

java.lang.Class உடன் வேலை செய்வதற்கான அடிப்படை முறைகளின் பட்டியலைப் பார்ப்போம் :

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

இப்போது நாம் java.lang.Class ஐ பெறுவது பற்றி பேசுவோம் . இதற்கு மூன்று வழிகள் உள்ளன.

1. Class.forName ஐப் பயன்படுத்துதல்

இயங்கும் பயன்பாட்டில், நீங்கள் ஒரு வகுப்பைப் பெற forName(String className) முறையைப் பயன்படுத்த வேண்டும்.

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

package com.company;

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

எங்கள் உதாரணத்தின் இரண்டாவது பகுதி பிரதிபலிப்பைப் பயன்படுத்தும் குறியீடு:

public class TestReflection {
    public static void main(String[] args) {
        try {
            Class<?> aClass = Class.forName("com.company.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

வகுப்பின் முழுப் பெயர் தெரிந்தால் இந்த அணுகுமுறை சாத்தியமாகும். பின்னர் நிலையான Class.forName() முறையைப் பயன்படுத்தி தொடர்புடைய வகுப்பைப் பெறலாம் . பழமையான வகைகளுக்கு இந்த முறையைப் பயன்படுத்த முடியாது.

2. .class ஐப் பயன்படுத்துதல்

ஒரு வகை கிடைக்கப்பெற்றாலும், அதற்கான உதாரணம் இல்லை என்றால், வகைப் பெயருடன் .class ஐச் சேர்ப்பதன் மூலம் வகுப்பைப் பெறலாம் . பழமையான வகையின் வகுப்பைப் பெற இது எளிதான வழியாகும்.

Class aClass = Person.class;

3. .getClass() ஐப் பயன்படுத்துதல்

ஒரு பொருள் இருந்தால், ஒரு வகுப்பைப் பெறுவதற்கான எளிதான வழி object.getClass() ஐ அழைப்பதாகும் .

Person person = new Person();
Class aClass = person.getClass();

கடைசி இரண்டு அணுகுமுறைகளுக்கு என்ன வித்தியாசம்?

குறியீட்டு நேரத்தில் எந்த வகுப்பில் நீங்கள் ஆர்வமாக உள்ளீர்கள் என்பது உங்களுக்குத் தெரிந்தால் A.class ஐப் பயன்படுத்தவும் . எந்த நிகழ்வும் இல்லை என்றால், நீங்கள் .class ஐப் பயன்படுத்த வேண்டும் .

ஒரு வகுப்பின் முறைகளைப் பெறுதல்

எங்கள் வகுப்பின் முறைகளை வழங்கும் முறைகளைப் பார்ப்போம்: getDeclaredMethods() மற்றும் getMethods() .

getDeclaredMethods() பொது, தனியார், இயல்புநிலை மற்றும் பாதுகாக்கப்பட்ட முறைகள் உட்பட, வகுப்புப் பொருளால் குறிப்பிடப்படும் வகுப்பு அல்லது இடைமுகத்தின் அனைத்து அறிவிக்கப்பட்ட முறைகளுக்கான முறைப் பொருள்களைக் கொண்ட ஒரு வரிசையை வழங்குகிறது, ஆனால் மரபுரிமை முறைகள் அல்ல .

getMethods() ஆனது கிளாஸ் ஆப்ஜெக்ட்டால் குறிப்பிடப்படும் வகுப்பு அல்லது இடைமுகத்தின் அனைத்து பொது முறைகளுக்கான மெத்தட் ஆப்ஜெக்ட்களைக் கொண்ட ஒரு வரிசையை வழங்குகிறது - கிளாஸ் அல்லது இடைமுகத்தால் அறிவிக்கப்பட்டவை, அத்துடன் சூப்பர் கிளாஸ்கள் மற்றும் சூப்பர் இன்டர்ஃபேஸ்களில் இருந்து பெறப்பட்டவை .

அவை ஒவ்வொன்றும் எவ்வாறு செயல்படுகின்றன என்பதைப் பார்ப்போம்.

getDeclaredMethods() உடன் ஆரம்பிக்கலாம் . இரண்டு முறைகளுக்கு இடையிலான வேறுபாட்டைப் புரிந்துகொள்ள மீண்டும் எங்களுக்கு உதவ, கீழே நாம் சுருக்க எண்கள் வகுப்பில் வேலை செய்வோம். ஒரு நிலையான முறையை எழுதுவோம், அது நமது முறை வரிசையை லிஸ்ட்<ஸ்ட்ரிங்> ஆக மாற்றும் :

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TestReflection {
    public static void main(String[] args) {
        final Method[] declaredMethods = Number.class.getDeclaredMethods();
        List<String> actualMethodNames = getMethodNames(declaredMethods);
        actualMethodNames.forEach(System.out::println);
    }

    private static List<String> getMethodNames(Method[] methods) {
        return Arrays.stream(methods)
                .map(Method::getName)
                .collect(Collectors.toList());
    }
}

இந்தக் குறியீட்டை இயக்கியதன் முடிவு இதோ:

எண் வகுப்பிற்குள் அறிவிக்கப்பட்ட முறைகள் இவை . GetMethods() என்ன திரும்பும்? எடுத்துக்காட்டில் இரண்டு வரிகளை மாற்றுவோம்:

final Method[] methods = Number.class.getMethods();
List<String> actualMethodNames = getMethodNames(methods);

இதைச் செய்வதன் மூலம், பின்வரும் முறைகளின் தொகுப்பைப் பார்ப்போம்:

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

ஒரு வகுப்பின் புலங்களைப் பெறுதல்

ஒரு வகுப்பின் புலங்களைப் பெற getFields மற்றும் getDeclaredFields முறைகள் பயன்படுத்தப்படுகின்றன. உதாரணமாக, LocalDateTime வகுப்பைப் பார்ப்போம் . எங்கள் குறியீட்டை மீண்டும் எழுதுவோம்:

import java.lang.reflect.Field;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TestReflection {
    public static void main(String[] args) {
        final Field[] declaredFields = LocalDateTime.class.getDeclaredFields();
        List<String> actualFieldNames = getFieldNames(declaredFields);
        actualFieldNames.forEach(System.out::println);
    }

    private static List<String> getFieldNames(Field[] fields) {
        return Arrays.stream(fields)
                .map(Field::getName)
                .collect(Collectors.toList());
    }
}

இந்தக் குறியீட்டை இயக்குவதன் விளைவாக, LocalDateTime வகுப்பில் உள்ள புலங்களின் தொகுப்பைப் பெறுகிறோம்.

எங்கள் முந்தைய முறைகளின் ஆய்வுடன் ஒப்புமை மூலம், குறியீட்டை சிறிது மாற்றினால் என்ன நடக்கும் என்று பார்ப்போம்:

final Field[] fields = LocalDateTime.class.getFields();
List<String> actualFieldNames = getFieldNames(fields);

வெளியீடு:

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

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

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

இப்போது LocalDateTime க்குள் பார்க்கலாம் .

வகுப்பின்MINமற்றும்அதிகபட்சம்புலங்கள் பொதுவில் உள்ளன, அதாவது அவை getFields முறை மூலம் தெரியும் . மாறாக, திதேதி,நேரம்,serialVersionUIDமுறைகள் தனிப்பட்ட மாற்றியைக் கொண்டுள்ளன , அதாவது அவை getFields முறை மூலம் பார்க்கப்படாது , ஆனால் அவற்றை getDeclaredFields ஐப் பயன்படுத்திப் பெறலாம் . இப்படித்தான் நாம் தனிப்பட்ட துறைகளுக்கான புலப் பொருட்களை அணுகலாம்.

பிற முறைகளின் விளக்கம்

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

getModifiers()

ஒரு பயன்படுத்தி மாற்றிகளை அணுகலாம்வர்க்கம்பொருள்.

மாற்றிகள் என்பது பொது , நிலையான , இடைமுகம் போன்ற முக்கிய வார்த்தைகள் . getModifiers() முறையைப் பயன்படுத்தி மாற்றிகளைப் பெறுகிறோம் :

Class<Person> personClass = Person.class;
int classModifiers = personClass.getModifiers();

இந்த குறியீடு ஒரு இன் மதிப்பை அமைக்கிறதுமுழு எண்ணாகஒரு பிட் புலம் மாறி. ஒவ்வொரு அணுகல் மாற்றியும் தொடர்புடைய பிட்டை அமைப்பதன் மூலம் அல்லது அழிப்பதன் மூலம் இயக்கலாம் அல்லது முடக்கலாம். java.lang.reflect.Modifier வகுப்பில் உள்ள முறைகளைப் பயன்படுத்தி மாற்றிகளை நாம் சரிபார்க்கலாம் :

import com.company.Person;
import java.lang.reflect.Modifier;

public class TestReflection {
    public static void main(String[] args) {
        Class<Person> personClass = Person.class;
        int classModifiers = personClass.getModifiers();

        boolean isPublic = Modifier.isPublic(classModifiers);
        boolean isStatic = Modifier.isStatic(classModifiers);
        boolean isFinal = Modifier.isFinal(classModifiers);
        boolean isAbstract = Modifier.isAbstract(classModifiers);
        boolean isInterface = Modifier.isInterface(classModifiers);

        System.out.printf("Class modifiers: %d%n", classModifiers);
        System.out.printf("Is public: %b%n", isPublic);
        System.out.printf("Is static: %b%n", isStatic);
        System.out.printf("Is final: %b%n", isFinal);
        System.out.printf("Is abstract: %b%n", isAbstract);
        System.out.printf("Is interface: %b%n", isInterface);
    }
}

எங்கள் நபரின் அறிவிப்பு எப்படி இருக்கும் என்பதை நினைவில் கொள்க:

public class Person {
   …
}

பின்வரும் வெளியீட்டைப் பெறுகிறோம்:

எங்கள் வகுப்பை சுருக்கமாக மாற்றினால், பின்வருபவை:

public abstract class Person { … }

மற்றும் இந்த வெளியீடு:

அணுகல் மாற்றியை மாற்றியுள்ளோம், அதாவது மாற்றி வகுப்பின் நிலையான முறைகள் மூலம் தரவை மாற்றியுள்ளோம் .

getPackage()

ஒரு வகுப்பை மட்டுமே அறிந்தால், அதன் தொகுப்பு பற்றிய தகவலைப் பெறலாம்:

Class<Person> personClass = Person.class;
final Package aPackage = personClass.getPackage();
System.out.println(aPackage.getName());

சூப்பர் கிளாஸ் ()

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

public static void main(String[] args) {
    Class<Person> personClass = Person.class;
    final Class<? super Person> superclass = personClass.getSuperclass();
    System.out.println(superclass);
}

நாங்கள் நன்கு அறியப்பட்ட பொருள் வகுப்பைப் பெறுகிறோம்:

class java.lang.Object

ஆனால் எங்கள் வகுப்பில் மற்றொரு பெற்றோர் வகுப்பு இருந்தால், அதற்குப் பதிலாக அதைப் பார்ப்போம்:

package com.company;

class Human {
    // Some info
}

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

    // Some info
}

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

class com.company.Human

getInterfaces()

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

public static void main(String[] args) {
    Class<Person> personClass = Person.class;
    final Class<?>[] interfaces = personClass.getInterfaces();
    System.out.println(Arrays.toString(interfaces));
}

எங்கள் நபர் வகுப்பை மாற்ற மறக்க வேண்டாம் :

public class Person implements Serializable { … }

வெளியீடு:

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

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

getName() & getSimpleName() & getCanonicalName()

ஒரு பழமையான, உள்ளமைக்கப்பட்ட வகுப்பு, அநாமதேய வகுப்பு மற்றும் சரம் வகுப்பு ஆகியவற்றை உள்ளடக்கிய ஒரு உதாரணத்தை எழுதுவோம் :

public class TestReflection {
    public static void main(String[] args) {
        printNamesForClass(int.class, "int class (primitive)");
        printNamesForClass(String.class, "String.class (ordinary class)");
        printNamesForClass(java.util.HashMap.SimpleEntry.class,
                "java.util.HashMap.SimpleEntry.class (nested class)");
        printNamesForClass(new java.io.Serializable() {
                }.getClass(),
                "new java.io.Serializable(){}.getClass() (anonymous inner class)");
    }

    private static void printNamesForClass(final Class<?> clazz, final String label) {
        System.out.printf("%s:%n", label);
        System.out.printf("\tgetName()):\t%s%n", clazz.getName());
        System.out.printf("\tgetCanonicalName()):\t%s%n", clazz.getCanonicalName());
        System.out.printf("\tgetSimpleName()):\t%s%n", clazz.getSimpleName());
        System.out.printf("\tgetTypeName():\t%s%n%n", clazz.getTypeName());
    }
}

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

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

• getName() என்பது பொருளின் பெயரை வழங்கும்.

• getCanonicalName() ஜாவா மொழி விவரக்குறிப்பால் வரையறுக்கப்பட்ட அடிப்படை வகுப்பின் நியமனப் பெயரை வழங்குகிறது. அடிப்படை வகுப்பில் நியமனப் பெயர் இல்லை என்றால் (அதாவது, உள்ளூர் அல்லது அநாமதேய வகுப்பாக இருந்தால் அல்லது உறுப்பு வகைக்கு நியமனப் பெயர் இல்லாத அணியாக இருந்தால்) பூஜ்யமாகத் திரும்பும்.

• getSimpleName() ஆனது மூலக் குறியீட்டில் குறிப்பிடப்பட்டுள்ள அடிப்படை வகுப்பின் எளிய பெயரை வழங்குகிறது. அடிப்படை வகுப்பு அநாமதேயமாக இருந்தால் வெற்று சரத்தை வழங்கும்.

• getTypeName() இந்த வகையின் பெயருக்கான தகவல் சரத்தை வழங்குகிறது.