reflection மற்றும் annotations எதற்காகப் பயன்படுத்தப்படுகின்றன?

Question

Accepted Answer

**Reflection** ஒரு program-ஐ **runtime-இல் classes, methods, மற்றும் fields-ஐ ஆய்வு செய்து கையாள** அனுமதிக்கிறது — compile time-இல் அறியப்படாதவற்றைக் கூட. **Annotations** code-க்கு metadata-ஐ இணைக்கின்றன, அதை tools மற்றும் frameworks படிக்கின்றன (பெரும்பாலும் reflection மூலம்) behavior-ஐ இயக்க. ஒன்றாக அவை Java-வின் framework "மாயத்தின்" பெரும்பகுதியை இயக்குகின்றன (Spring, JPA, JUnit).

## Reflection — runtime ஆய்வு மற்றும் invocation

```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
```

Reflection code-ஐ types-ஐ dynamic-ஆக கண்டறிந்து பயன்படுத்த அனுமதிக்கிறது — name மூலம் classes-ஐ instantiate செய்தல், fields-ஐ படித்தல்/அமைத்தல், methods-ஐ invoke செய்தல் — frameworks உங்கள் classes-ஐ முன்கூட்டியே அறியாமல் அவற்றில் எவ்வாறு செயல்படுகின்றன என்பது இதுவே.

## Annotations — tools/frameworks-க்கான metadata

```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
```

## ஒரு custom annotation-ஐ வரையறுத்தல்

```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() { ... }
}
```

## அவை எவ்வாறு இணைகின்றன: frameworks reflection மூலம் annotations-ஐ படிக்கின்றன

```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`)-இன் பின்னணியில் உள்ள முக்கிய பொறிமுறை — அவை reflection மூலம் உங்கள் annotated code-ஐ scan செய்து behavior-ஐ அதற்கேற்ப இணைக்கின்றன.

## பரிமாற்றங்கள் (trade-offs)

```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
```

## இது ஏன் முக்கியம்

Reflection மற்றும் annotations **Java-வின் framework ecosystem-இன் பின்னணியில் உள்ள இயந்திரம்** ஆகும்.

Reflection generic, dynamic behavior-ஐ சாத்தியமாக்குகிறது — compile-time அறிவு இல்லாமல் runtime-இல் classes-ஐ ஆய்வு செய்து செயல்படுத்துதல் — dependency injection, ORMs (objects-ஐ tables-க்கு map செய்தல்), serialization libraries (Jackson fields-ஐ படித்தல்), மற்றும் testing frameworks உங்கள் தன்னிச்சையான classes-இல் எவ்வாறு செயல்படுகின்றன என்பது இதுவே.

Annotations இந்த tools படிக்கும் (reflection மூலம்) declarative metadata-ஐ வழங்குகின்றன, அவற்றின் behavior-ஐ இயக்க, விரிவான configuration-ஐ எளிய markers-ஆல் (`@Entity`, `@Autowired`, `@Test`) மாற்றுகின்றன.

அவற்றைப் புரிந்துகொள்வது Spring, JPA, மற்றும் JUnit தங்கள் "மாயத்தை" எவ்வாறு அடைகின்றன என்பதை தெளிவுபடுத்துகிறது, உங்கள் சொந்த framework-போன்ற tools-ஐ உருவாக்க உங்களை அனுமதிக்கிறது, மற்றும் செயல்திறன்/பாதுகாப்பு பரிமாற்றங்களை (மெதுவானது, type checking-ஐ தவிர்க்கிறது) தெளிவுபடுத்துகிறது, எனவே நீங்கள் அவற்றை சரியாகப் பயன்படுத்துகிறீர்கள்.

இது Java ecosystem-இல் ஆழமாக வேலை செய்வதற்கான மேம்பட்ட ஆனால் அவசியமான அறிவு.