રિફ્લેક્શન અને એનોટેશન્સ શું માટે વાપરવામાં આવે છે?

Question

Accepted Answer

**રિફ્લેક્શન** એક પ્રોગ્રામને **રનટાઇમ સમયે ક્લાસ, મેથોડ્સ, અને ફીલ્ડ્સને ઇન્સ્પેક્ટ અને મેનીપુલેટ કરવા** દે છે — તેમ છતાં કમ્પાઇલ ટાઇમ સમયે અજ્ઞાત હોય તોપણ. **એનોટેશન્સ** કોડને મેટાડેટા જોડે છે જે ટૂલ્સ અને ફ્રેમવર્ક્સ વાંચે છે (ઘણીવાર રિફ્લેક્શન દ્વારા) તેમનું વર્તન ચલાવવા માટે. એક સાથે તેઓ Java ના ફ્રેમવર્ક "મેજિક" ના મોટા ભાગનો ચાલક છે (Spring, JPA, JUnit).)

## રિફ્લેક્શન — રનટાઇમ ઇન્સ્પેક્શન અને ઇનવોકેશન

```java
// examine a class's structure at runtime, without knowing it at compile time
Class<?> clazz = Class.forName("com.example.User");

for (Field field : clazz.getDeclaredFields()) {
    System.out.println(field.getName() + ": " + field.getType());
}
for (Method method : clazz.getDeclaredMethods()) {
    System.out.println(method.getName());
}

// create instances and invoke methods dynamically
Object instance = clazz.getDeclaredConstructor().newInstance();
Method m = clazz.getMethod("setName", String.class);
m.invoke(instance, "Ann");        // call setName("Ann") reflectively

// even access private members (frameworks use this for DI)
Field f = clazz.getDeclaredField("secret");
f.setAccessible(true);             // bypass private access
```

રિફ્લેક્શન કોડને ગતિશીલરીતે પ્રકારો શોધવા અને વાપરવા દે છે — નામ દ્વારા ક્લાસ્સ ઇન્સ્ટાન્શિયેટ કરો, ફીલ્ડ્સ વાંચો/સેટ કરો, મેથોડ્સ ઇનવોક કરો — આ જ રીતે ફ્રેમવર્ક્સ તમારી *ક્લાસ્સ* પર કાર્ય કરે છે તેમ માપ્યા વિના.

## એનોટેશન્સ — ટૂલ્સ/ફ્રેમવર્ક્સ માટે મેટાડેટા

```java
// built-in and framework annotations attach metadata
@Override               // compiler check
@Deprecated             // marks outdated API
@Entity                 // JPA: this class maps to a DB table
@Autowired              // Spring: inject a dependency here
@Test                   // JUnit: this method is a test
```

## કસ્ટમ એનોટેશન વ્યાખ્યાયિત કરવું

```java
@Retention(RetentionPolicy.RUNTIME)   // available at runtime (readable via reflection)
@Target(ElementType.METHOD)
public @interface Loggable {
    String value() default "";
}

// using it
class Service {
    @Loggable("audit")
    void process() { ... }
}
```

## કેવી રીતે તેઓ એક્સ-બીજાને જોડે છે: ફ્રેમવર્ક્સ રિફ્લેક્શન દ્વારા એનોટેશન્સ વાંચે છે

```java
// a framework scans methods, finds the annotation, and acts on it
for (Method m : clazz.getDeclaredMethods()) {
    if (m.isAnnotationPresent(Loggable.class)) {
        Loggable l = m.getAnnotation(Loggable.class);
        // wrap/log/intercept the method based on the metadata
    }
}
```

યો Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validation (`@NotNull`) પર્યા જ કોર મેકેનિઝમ છે — તેઓ તમારી એનોટેટેડ કોડ સ્કેન કરે છે રિફ્લેક્શન દ્વારા અને વર્તન વાયર કરે છે તે અનુસાર.

## ટ્રેડ-ઑફ્સ

```text
✗ Reflection is SLOWER than direct calls (runtime lookup), bypasses compile-time
  type checking, and can break encapsulation (setAccessible) → use judiciously
✓ But it's essential for generic frameworks, DI, serialization, testing tools
```

## તે શું મહત્વપૂર્ણ છે

રિફ્લેક્શન અને એનોટેશન્સ **Java ના ફ્રેમવર્ક ઇકોસિસ્ટમ પર્યા મશીનરી** છે.

રિફ્લેક્શન જેનેરિક, ગતિશીલ વર્તન સક્ષમ કરે છે — રનટાઇમ સમયે ક્લાસ્સને ઇન્સ્પેક્ટ કરો અને ચલાવો કમ્પાઇલ-ટાઇમ જ્ઞાન વિના — આ જ રીતે ડિપેન્ડેન્સી ઇનજેક્શન, ORMs (ઑબ્જેક્ટ્સને ટેબલમાં મેપ કરવું), સીરીયલાઇઝેશન લાઇબ્રેરીઝ (Jackson ફીલ્ડ્સ વાંચી), અને ટેસ્ટિંગ ફ્રેમવર્ક્સ તમારી મનસ્વીય ક્લાસ્સ પર કાર્ય કરે છે.

એનોટેશન્સ આ ટૂલ્સ વાંચે તે ડીક્લેરેટીવ મેટાડેટા આપે છે (રિફ્લેક્શન દ્વારા) તેમનું વર્તન ચલાવવા, સરસ્વરૂપ કોન્ફિગરેશનને સરળ માર્કર્સ જે જગ્યાએ બદલી નાખે છે (`@Entity`, `@Autowired`, `@Test`).

તેમને સમજવું Spring, JPA, અને JUnit પર્યા "મેજિક" કેવી રીતે કાર્ય કરે છે તે સ્પષ્ટ કરે છે, તમને તમારા પોતાના ફ્રેમવર્ક-જેવા ટૂલ્સ બનાવવા દે છે, અને કામગીરી/સુરક્ષા ટ્રેડ-ઑફ્સ સ્પષ્ટ કરે છે (ધીમું, ટાઇપ ચેકિંગ બાયપાસ કરે છે) તેથી તમે તેમને યોગ્ય રીતે વાપરો.

તે એડવાંસ્ડ પણ Java ઇકોસિસ્ટમમાં ઊંડું કામ કરવા માટે આવશ્યક જ્ઞાન છે.