Java Reflection stands as a powerful mechanism for inspecting and manipulating classes, methods, and fields at runtime. I’ve extensively used reflection in framework development, and here are seven advanced patterns that prove invaluable.

Annotation-Based Configuration

This pattern allows frameworks to process custom annotations and configure objects dynamically. I’ve implemented this in several enterprise applications to enable declarative configuration.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Config {
    String value();
}

public class ConfigurationProcessor {
    public void process(Object bean) {
        Arrays.stream(bean.getClass().getDeclaredFields())
            .filter(field -> field.isAnnotationPresent(Config.class))
            .forEach(field -> {
                Config config = field.getAnnotation(Config.class);
                setFieldValue(field, bean, loadConfig(config.value()));
            });
    }

    private void setFieldValue(Field field, Object target, Object value) {
        try {
            field.setAccessible(true);
            field.set(target, value);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

Method Interception

Method interception enables adding behavior before or after method execution. This pattern is fundamental for implementing aspects, logging, and performance monitoring.

public class MethodInterceptor {
    public Object intercept(Method method, Object target, Object[] args) {
        before(method, args);
        Object result = method.invoke(target, args);
        after(method, result);
        return result;
    }

    private void before(Method method, Object[] args) {
        System.out.printf("Executing %s with args %s%n", 
            method.getName(), Arrays.toString(args));
    }

    private void after(Method method, Object result) {
        System.out.printf("Method %s returned %s%n", 
            method.getName(), result);
    }
}

Dynamic Bean Creation

This pattern creates and configures objects dynamically, essential for dependency injection containers and object factories.

public class BeanFactory {
    private final Map<Class<?>, Object> singletons = new HashMap<>();

    public <T> T createBean(Class<T> clazz) {
        try {
            Constructor<T> constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(true);
            T instance = constructor.newInstance();
            injectDependencies(instance);
            return instance;
        } catch (Exception e) {
            throw new RuntimeException("Failed to create bean", e);
        }
    }

    private void injectDependencies(Object instance) {
        Arrays.stream(instance.getClass().getDeclaredFields())
            .filter(field -> field.isAnnotationPresent(Inject.class))
            .forEach(field -> injectField(instance, field));
    }
}

Property Access

Flexible property access enables frameworks to read and write object properties dynamically, crucial for data binding and serialization.

public class PropertyAccessor {
    public Object getProperty(Object target, String propertyName) {
        try {
            String methodName = "get" + capitalize(propertyName);
            Method getter = target.getClass().getMethod(methodName);
            return getter.invoke(target);
        } catch (Exception e) {
            throw new RuntimeException("Property access failed", e);
        }
    }

    public void setProperty(Object target, String propertyName, Object value) {
        try {
            String methodName = "set" + capitalize(propertyName);
            Method setter = findSetter(target.getClass(), methodName, value);
            setter.invoke(target, value);
        } catch (Exception e) {
            throw new RuntimeException("Property setting failed", e);
        }
    }
}

Type Resolution

Advanced type resolution helps frameworks work with generic types and complex type hierarchies.

public class TypeResolver {
    public Type[] resolveTypeParameters(Class<?> clazz) {
        Type superclass = clazz.getGenericSuperclass();
        if (superclass instanceof ParameterizedType) {
            return ((ParameterizedType) superclass).getActualTypeArguments();
        }
        return new Type[0];
    }

    public Class<?> resolveGenericParameter(Field field) {
        Type genericType = field.getGenericType();
        if (genericType instanceof ParameterizedType) {
            return (Class<?>) ((ParameterizedType) genericType)
                .getActualTypeArguments()[0];
        }
        return null;
    }
}

Method Parameter Analysis

This pattern examines method parameters for type information and annotations, essential for request mapping and parameter binding.

public class ParameterAnalyzer {
    public List<ParameterInfo> analyzeParameters(Method method) {
        return Arrays.stream(method.getParameters())
            .map(param -> new ParameterInfo(
                param.getName(),
                param.getType(),
                Arrays.asList(param.getAnnotations())
            ))
            .collect(Collectors.toList());
    }

    public static class ParameterInfo {
        private final String name;
        private final Class<?> type;
        private final List<Annotation> annotations;
        
        // Constructor and getters
    }
}

Class Loading and Modification

Dynamic class loading and modification enables frameworks to generate and load classes at runtime.

public class ClassModifier {
    public Class<?> loadModifiedClass(String className, byte[] classBytes) {
        ClassLoader loader = new CustomClassLoader();
        return loader.defineClass(className, classBytes);
    }

    private static class CustomClassLoader extends ClassLoader {
        public Class<?> defineClass(String name, byte[] bytes) {
            return defineClass(name, bytes, 0, bytes.length);
        }
    }

    public byte[] modifyClassBytes(byte[] original) {
        // Use ASM or Javassist to modify class bytes
        return modified;
    }
}

These patterns form the foundation of many Java frameworks. I’ve successfully applied them in building dependency injection containers, web frameworks, and ORM solutions. The key is understanding when and how to use reflection effectively while considering performance implications.

Performance optimization is crucial when using reflection. I recommend caching reflection metadata and using method handles for frequently accessed members. Always consider security implications and use AccessController when needed.

Remember to handle exceptions properly and provide meaningful error messages. Reflection errors can be cryptic, so good error handling improves developer experience significantly.

These patterns shine in framework development but use them judiciously in application code. Direct method calls are generally preferable for normal business logic.