What are reflection and annotations used for?

Question

Accepted Answer

**Reflection** lets a program **inspect and manipulate classes, methods, and fields at runtime** — even ones unknown at compile time. **Annotations** attach metadata to code that tools and frameworks read (often via reflection) to drive behavior. Together they power much of Java's framework "magic" (Spring, JPA, JUnit).

## Reflection — runtime inspection and 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 lets code discover and use types dynamically — instantiate classes by name, read/set fields, invoke methods — which is how frameworks operate on *your* classes without knowing them in advance.

## Annotations — metadata for tools/frameworks

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

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

## How they combine: frameworks read annotations via reflection

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

This is the core mechanism behind Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validation (`@NotNull`) — they scan your annotated code via reflection and wire up behavior accordingly.

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

## Why it matters

Reflection and annotations are the **machinery behind Java's framework ecosystem**.

Reflection enables generic, dynamic behavior — inspecting and operating on classes at runtime without compile-time knowledge — which is how dependency injection, ORMs (mapping objects to tables), serialization libraries (Jackson reading fields), and testing frameworks work on your arbitrary classes.

Annotations provide the declarative metadata these tools read (via reflection) to drive their behavior, replacing verbose configuration with simple markers (`@Entity`, `@Autowired`, `@Test`).

Understanding them demystifies how Spring, JPA, and JUnit achieve their "magic," lets you build your own framework-like tools, and clarifies the performance/safety trade-offs (slower, bypasses type checking) so you use them appropriately.

It's advanced but essential knowledge for working deeply in the Java ecosystem.