Annotations in Java

1. Introduction to Annotations

What are Annotations?

Annotations are metadata that provide data about a program but are not part of the program itself. They have no direct effect on the code they annotate.

Why Use Annotations?

Provide information to the compiler
Compile-time and deployment-time processing
Runtime processing via reflection
Code generation and boilerplate reduction
Framework configuration (Spring, Hibernate, etc.)

Built-in Annotations:

@Override, @Deprecated, @SuppressWarnings
@SafeVarargs, @FunctionalInterface
Meta-annotations: @Target, @Retention, @Documented, @Inherited, @Repeatable

2. Basic Annotations Usage

import java.util.*; // Class demonstrating built-in annotations public class BuiltInAnnotationsExample { // @Override - indicates method overriding @Override public String toString() { return "BuiltInAnnotationsExample instance"; } // @Deprecated - marks method as obsolete @Deprecated public void oldMethod() { System.out.println("This is an old method"); } // @SuppressWarnings - suppresses compiler warnings @SuppressWarnings("unchecked") public void methodWithWarnings() { List list = new ArrayList(); // Raw type warning suppressed list.add("test"); } // @SafeVarargs - suppresses heap pollution warnings @SafeVarargs public final <T> void safeMethod(T... elements) { for (T element : elements) { System.out.println(element); } } // @FunctionalInterface - ensures interface has exactly one abstract method @FunctionalInterface interface Calculator { int calculate(int a, int b); // Default methods are allowed default void description() { System.out.println("Calculator interface"); } } public static void main(String[] args) { System.out.println("=== Built-in Annotations Examples ==="); BuiltInAnnotationsExample example = new BuiltInAnnotationsExample(); // Using @Override System.out.println(example.toString()); // Using @Deprecated - compiler will warn about usage example.oldMethod(); // Using @SuppressWarnings example.methodWithWarnings(); // Using @SafeVarargs example.safeMethod(1, 2, 3); // Using @FunctionalInterface Calculator adder = (a, b) -> a + b; System.out.println("Addition: " + adder.calculate(5, 3)); // Demonstrating annotation retention demonstrateAnnotationRetention(); } public static void demonstrateAnnotationRetention() { System.out.println("\n=== Annotation Retention ==="); // Get annotations using reflection Class<BuiltInAnnotationsExample> clazz = BuiltInAnnotationsExample.class; try { java.lang.reflect.Method method = clazz.getMethod("oldMethod"); Deprecated deprecated = method.getAnnotation(Deprecated.class); if (deprecated != null) { System.out.println("oldMethod is deprecated"); } } catch (NoSuchMethodException e) { e.printStackTrace(); } } }

3. Complete Code Examples

Example 1: Creating Custom Annotations

import java.lang.annotation.*; import java.lang.reflect.*; // Custom annotation with different retention policies @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface ClassInfo { String author(); String version() default "1.0"; String description(); String[] tags() default {}; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface MethodInfo { String purpose(); String lastModified() default "N/A"; boolean tested() default false; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface FieldInfo { String description(); boolean required() default true; } @Retention(RetentionPolicy.SOURCE) // Discarded during compilation @Target(ElementType.METHOD) @interface DevelopmentNote { String note(); String developer(); } // Meta-annotation examples @Documented // Include in javadoc @Inherited // Inherited by subclasses @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface DocumentedAnnotation { String value(); } // Repeatable annotation @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface Reviews { Review[] value(); } @Repeatable(Reviews.class) @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface Review { String reviewer(); String comment(); int rating(); // 1-5 } // Using custom annotations @ClassInfo( author = "John Doe", version = "2.0", description = "User management service", tags = {"service", "user", "management"} ) @Review(reviewer = "Alice", comment = "Good implementation", rating = 4) @Review(reviewer = "Bob", comment = "Needs more validation", rating = 3) @DocumentedAnnotation("This class is documented in javadoc") class UserService { @FieldInfo(description = "User database connection", required = true) private String databaseUrl; @FieldInfo(description = "Cache enabled flag") private boolean cacheEnabled = true; public UserService(String databaseUrl) { this.databaseUrl = databaseUrl; } @MethodInfo( purpose = "Create new user account", lastModified = "2024-01-15", tested = true ) public void createUser(String username, String email) { System.out.println("Creating user: " + username); } @MethodInfo( purpose = "Validate user credentials", lastModified = "2024-01-10" ) public boolean validateUser(String username, String password) { return username != null && password != null; } @DevelopmentNote( note = "This method needs optimization", developer = "Charlie" ) public void performanceCriticalMethod() { // Performance-critical code } @SuppressWarnings("unused") private void internalMethod() { // Internal implementation } } public class CustomAnnotationsExample { public static void main(String[] args) { System.out.println("=== Custom Annotations Examples ==="); // Analyze annotations using reflection analyzeClassAnnotations(UserService.class); analyzeMethodAnnotations(UserService.class); analyzeFieldAnnotations(UserService.class); // Demonstrate annotation processing processAnnotations(new UserService("jdbc:mysql://localhost:3306/users")); } public static void analyzeClassAnnotations(Class<?> clazz) { System.out.println("\n=== Class Annotations ==="); System.out.println("Class: " + clazz.getSimpleName()); // Get class-level annotations Annotation[] annotations = clazz.getAnnotations(); for (Annotation annotation : annotations) { System.out.println(" " + annotation.annotationType().getSimpleName()); if (annotation instanceof ClassInfo) { ClassInfo classInfo = (ClassInfo) annotation; System.out.println(" Author: " + classInfo.author()); System.out.println(" Version: " + classInfo.version()); System.out.println(" Description: " + classInfo.description()); System.out.println(" Tags: " + String.join(", ", classInfo.tags())); } if (annotation instanceof Reviews) { Reviews reviews = (Reviews) annotation; for (Review review : reviews.value()) { System.out.println(" Review by " + review.reviewer() + ": " + review.comment() + " (Rating: " + review.rating() + ")"); } } } // Get repeatable annotations directly Review[] reviews = clazz.getAnnotationsByType(Review.class); if (reviews.length > 0) { System.out.println(" Direct repeatable annotations: " + reviews.length); } } public static void analyzeMethodAnnotations(Class<?> clazz) { System.out.println("\n=== Method Annotations ==="); for (Method method : clazz.getDeclaredMethods()) { MethodInfo methodInfo = method.getAnnotation(MethodInfo.class); if (methodInfo != null) { System.out.println("Method: " + method.getName()); System.out.println(" Purpose: " + methodInfo.purpose()); System.out.println(" Last Modified: " + methodInfo.lastModified()); System.out.println(" Tested: " + methodInfo.tested()); } } } public static void analyzeFieldAnnotations(Class<?> clazz) { System.out.println("\n=== Field Annotations ==="); for (Field field : clazz.getDeclaredFields()) { FieldInfo fieldInfo = field.getAnnotation(FieldInfo.class); if (fieldInfo != null) { System.out.println("Field: " + field.getName()); System.out.println(" Description: " + fieldInfo.description()); System.out.println(" Required: " + fieldInfo.required()); } } } public static void processAnnotations(UserService service) { System.out.println("\n=== Annotation Processing ==="); Class<?> clazz = service.getClass(); // Process class info ClassInfo classInfo = clazz.getAnnotation(ClassInfo.class); if (classInfo != null) { System.out.println("Processing " + classInfo.description() + " v" + classInfo.version()); } // Process method annotations for (Method method : clazz.getDeclaredMethods()) { MethodInfo methodInfo = method.getAnnotation(MethodInfo.class); if (methodInfo != null && !methodInfo.tested()) { System.out.println("WARNING: Method " + method.getName() + " is not tested!"); } } // Process field annotations for (Field field : clazz.getDeclaredFields()) { FieldInfo fieldInfo = field.getAnnotation(FieldInfo.class); if (fieldInfo != null && fieldInfo.required()) { try { field.setAccessible(true); Object value = field.get(service); if (value == null) { System.out.println("ERROR: Required field " + field.getName() + " is null!"); } } catch (IllegalAccessException e) { System.err.println("Cannot access field: " + field.getName()); } } } } }

Example 2: Validation Framework with Annotations

import java.lang.annotation.*; import java.lang.reflect.*; import java.util.*; // Validation annotations @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface NotNull { String message() default "Field cannot be null"; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface Size { int min() default 0; int max() default Integer.MAX_VALUE; String message() default "Size constraint violated"; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface Email { String message() default "Invalid email format"; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface Pattern { String regex(); String message() default "Pattern constraint violated"; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface Range { double min() default Double.MIN_VALUE; double max() default Double.MAX_VALUE; String message() default "Value out of range"; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface CustomValidation { Class<? extends FieldValidator> validator(); String message() default "Custom validation failed"; } // Validation result class ValidationResult { private final boolean valid; private final List<String> errors; public ValidationResult(boolean valid, List<String> errors) { this.valid = valid; this.errors = errors; } public boolean isValid() { return valid; } public List<String> getErrors() { return errors; } public static ValidationResult valid() { return new ValidationResult(true, Collections.emptyList()); } public static ValidationResult invalid(String... errors) { return new ValidationResult(false, Arrays.asList(errors)); } } // Validator interface interface FieldValidator { ValidationResult validate(Object value, Field field); } // Custom validators class AgeValidator implements FieldValidator { @Override public ValidationResult validate(Object value, Field field) { if (value == null) return ValidationResult.valid(); // Let @NotNull handle null if (value instanceof Integer) { int age = (Integer) value; if (age < 0 || age > 150) { return ValidationResult.invalid("Age must be between 0 and 150"); } } return ValidationResult.valid(); } } class PasswordValidator implements FieldValidator { @Override public ValidationResult validate(Object value, Field field) { if (value == null) return ValidationResult.valid(); if (value instanceof String) { String password = (String) value; if (password.length() < 8) { return ValidationResult.invalid("Password must be at least 8 characters long"); } if (!password.matches(".*[A-Z].*")) { return ValidationResult.invalid("Password must contain at least one uppercase letter"); } if (!password.matches(".*[a-z].*")) { return ValidationResult.invalid("Password must contain at least one lowercase letter"); } if (!password.matches(".*\\d.*")) { return ValidationResult.invalid("Password must contain at least one digit"); } } return ValidationResult.valid(); } } // Validation engine class Validator { public static ValidationResult validate(Object object) { List<String> errors = new ArrayList<>(); Class<?> clazz = object.getClass(); for (Field field : clazz.getDeclaredFields()) { try { field.setAccessible(true); Object value = field.get(object); // Check @NotNull NotNull notNull = field.getAnnotation(NotNull.class); if (notNull != null && value == null) { errors.add(field.getName() + ": " + notNull.message()); continue; // Skip further validation for null values } // Check @Size Size size = field.getAnnotation(Size.class); if (size != null && value != null) { if (value instanceof String) { String str = (String) value; if (str.length() < size.min() || str.length() > size.max()) { errors.add(field.getName() + ": " + size.message() + " (min: " + size.min() + ", max: " + size.max() + ")"); } } else if (value instanceof Collection) { Collection<?> collection = (Collection<?>) value; if (collection.size() < size.min() || collection.size() > size.max()) { errors.add(field.getName() + ": " + size.message() + " (min: " + size.min() + ", max: " + size.max() + ")"); } } } // Check @Email Email email = field.getAnnotation(Email.class); if (email != null && value != null && value instanceof String) { String emailStr = (String) value; if (!emailStr.matches("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$")) { errors.add(field.getName() + ": " + email.message()); } } // Check @Pattern Pattern pattern = field.getAnnotation(Pattern.class); if (pattern != null && value != null && value instanceof String) { String str = (String) value; if (!str.matches(pattern.regex())) { errors.add(field.getName() + ": " + pattern.message()); } } // Check @Range Range range = field.getAnnotation(Range.class); if (range != null && value != null) { if (value instanceof Number) { double num = ((Number) value).doubleValue(); if (num < range.min() || num > range.max()) { errors.add(field.getName() + ": " + range.message() + " (min: " + range.min() + ", max: " + range.max() + ")"); } } } // Check @CustomValidation CustomValidation custom = field.getAnnotation(CustomValidation.class); if (custom != null) { try { FieldValidator validator = custom.validator().getDeclaredConstructor().newInstance(); ValidationResult result = validator.validate(value, field); if (!result.isValid()) { errors.addAll(result.getErrors()); } } catch (Exception e) { errors.add(field.getName() + ": Failed to perform custom validation - " + e.getMessage()); } } } catch (IllegalAccessException e) { errors.add("Cannot access field: " + field.getName()); } } return errors.isEmpty() ? ValidationResult.valid() : ValidationResult.invalid( errors.toArray(new String[0]) ); } } // Example entity with validation annotations class User { @NotNull(message = "Username is required") @Size(min = 3, max = 20, message = "Username must be between 3 and 20 characters") private String username; @NotNull @Email(message = "Invalid email address") private String email; @NotNull @CustomValidation(validator = PasswordValidator.class, message = "Password does not meet requirements") private String password; @Range(min = 18, max = 100, message = "Age must be between 18 and 100") @CustomValidation(validator = AgeValidator.class) private Integer age; @Pattern(regexp = "^[A-Z]{2}\\d{7}$", message = "ID must match pattern: AB1234567") private String idNumber; @Size(min = 1, max = 5, message = "User can have 1-5 roles") private List<String> roles; public User(String username, String email, String password, Integer age, String idNumber, List<String> roles) { this.username = username; this.email = email; this.password = password; this.age = age; this.idNumber = idNumber; this.roles = roles; } // Getters and setters public String getUsername() { return username; } public String getEmail() { return email; } public String getPassword() { return password; } public Integer getAge() { return age; } public String getIdNumber() { return idNumber; } public List<String> getRoles() { return roles; } } class Product { @NotNull @Size(min = 1, max = 100) private String name; @Range(min = 0.01, max = 10000.0) private Double price; @Size(min = 10, max = 1000) private String description; public Product(String name, Double price, String description) { this.name = name; this.price = price; this.description = description; } } public class ValidationFrameworkExample { public static void main(String[] args) { System.out.println("=== Validation Framework with Annotations ==="); // Test valid user System.out.println("\n1. Testing Valid User:"); User validUser = new User( "john_doe", "[email protected]", "SecurePass123", 25, "AB1234567", Arrays.asList("USER", "EDITOR") ); testValidation(validUser); // Test invalid user System.out.println("\n2. Testing Invalid User:"); User invalidUser = new User( "jo", // Too short "invalid-email", // Invalid email "weak", // Weak password 15, // Underage "invalid", // Invalid ID pattern Arrays.asList() // No roles ); testValidation(invalidUser); // Test null values System.out.println("\n3. Testing User with Null Values:"); User nullUser = new User(null, null, null, null, null, null); testValidation(nullUser); // Test product validation System.out.println("\n4. Testing Product Validation:"); Product invalidProduct = new Product("", -10.0, "Short"); testValidation(invalidProduct); // Performance test System.out.println("\n5. Performance Test:"); performanceTest(); } public static void testValidation(Object object) { System.out.println("Validating: " + object.getClass().getSimpleName()); ValidationResult result = Validator.validate(object); if (result.isValid()) { System.out.println("✅ Validation PASSED"); } else { System.out.println("❌ Validation FAILED"); result.getErrors().forEach(error -> System.out.println(" - " + error)); } } public static void performanceTest() { User user = new User("test", "[email protected]", "Password123", 25, "AB1234567", Arrays.asList("USER")); long startTime = System.nanoTime(); int iterations = 1000; for (int i = 0; i < iterations; i++) { Validator.validate(user); } long endTime = System.nanoTime(); double avgTime = (endTime - startTime) / 1_000_000.0 / iterations; System.out.printf("Average validation time: %.3f ms%n", avgTime); } }

Example 3: Dependency Injection Framework

import java.lang.annotation.*; import java.lang.reflect.*; import java.util.*; // DI Framework Annotations @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Component @interface Service { String value() default ""; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Component @interface Repository { String value() default ""; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Component @interface Controller { String value() default ""; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface Component { // Marker annotation } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface Autowired { String value() default ""; boolean required() default true; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface Configuration { } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface Bean { String value() default ""; } // Simple DI Container class ApplicationContext { private final Map<String, Object> beans = new HashMap<>(); private final Map<Class<?>, String> beanNames = new HashMap<>(); public ApplicationContext(String... basePackages) { scanAndRegisterComponents(basePackages); performDependencyInjection(); initializeBeans(); } private void scanAndRegisterComponents(String[] basePackages) { // Simplified scanning - in real implementation, use proper classpath scanning System.out.println("Scanning packages: " + Arrays.toString(basePackages)); // Manually register classes for demonstration registerBean("userService", new UserService()); registerBean("userRepository", new UserRepository()); registerBean("emailService", new EmailService()); registerBean("appConfig", new AppConfig()); } public void registerBean(String name, Object bean) { beans.put(name, bean); beanNames.put(bean.getClass(), name); System.out.println("Registered bean: " + name + " (" + bean.getClass().getSimpleName() + ")"); } @SuppressWarnings("unchecked") public <T> T getBean(Class<T> type) { String beanName = beanNames.get(type); if (beanName != null) { return (T) beans.get(beanName); } // Search by assignable type for (Object bean : beans.values()) { if (type.isInstance(bean)) { return (T) bean; } } throw new RuntimeException("No bean found for type: " + type.getName()); } public <T> T getBean(String name, Class<T> type) { Object bean = beans.get(name); if (bean != null && type.isInstance(bean)) { return type.cast(bean); } throw new RuntimeException("No bean found with name: " + name); } private void performDependencyInjection() { for (Object bean : beans.values()) { injectDependencies(bean); } } private void injectDependencies(Object bean) { Class<?> clazz = bean.getClass(); for (Field field : clazz.getDeclaredFields()) { Autowired autowired = field.getAnnotation(Autowired.class); if (autowired != null) { try { field.setAccessible(true); Object dependency; if (!autowired.value().isEmpty()) { // Get by name dependency = getBean(autowired.value(), field.getType()); } else { // Get by type dependency = getBean(field.getType()); } if (dependency == null && autowired.required()) { throw new RuntimeException("Required dependency not found for field: " + field.getName()); } field.set(bean, dependency); System.out.println("Injected " + field.getType().getSimpleName() + " into " + clazz.getSimpleName() + "." + field.getName()); } catch (IllegalAccessException e) { throw new RuntimeException("Failed to inject dependency into " + field.getName(), e); } } } } private void initializeBeans() { for (Object bean : beans.values()) { initializeBean(bean); } } private void initializeBean(Object bean) { // Call @PostConstruct methods for (Method method : bean.getClass().getDeclaredMethods()) { if (method.isAnnotationPresent(PostConstruct.class)) { try { method.setAccessible(true); method.invoke(bean); System.out.println("Called @PostConstruct on " + bean.getClass().getSimpleName() + "." + method.getName()); } catch (Exception e) { throw new RuntimeException("Failed to call @PostConstruct method", e); } } } } } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface PostConstruct { } // Example components @Service class UserService { @Autowired private UserRepository userRepository; @Autowired(required = false) // Optional dependency private EmailService emailService; @PostConstruct public void init() { System.out.println("UserService initialized"); } public void createUser(String username) { userRepository.save(username); if (emailService != null) { emailService.sendWelcomeEmail(username); } System.out.println("User created: " + username); } public List<String> getUsers() { return userRepository.findAll(); } } @Repository class UserRepository { private final List<String> users = new ArrayList<>(); @PostConstruct public void init() { System.out.println("UserRepository initialized"); users.add("admin"); // Default user } public void save(String username) { users.add(username); } public List<String> findAll() { return new ArrayList<>(users); } } @Service class EmailService { @PostConstruct public void init() { System.out.println("EmailService initialized"); } public void sendWelcomeEmail(String username) { System.out.println("Sending welcome email to: " + username); } public void sendNotification(String username, String message) { System.out.println("Notification to " + username + ": " + message); } } @Configuration class AppConfig { @Bean public String appName() { return "My Application"; } @Bean public Integer maxUsers() { return 1000; } } @Controller class UserController { @Autowired private UserService userService; @PostConstruct public void init() { System.out.println("UserController initialized"); } public void displayUsers() { System.out.println("Users: " + userService.getUsers()); } } public class DependencyInjectionExample { public static void main(String[] args) { System.out.println("=== Dependency Injection Framework ==="); // Create application context ApplicationContext context = new ApplicationContext("com.example"); // Get beans and use them UserController controller = context.getBean(UserController.class); UserService userService = context.getBean(UserService.class); System.out.println("\n=== Using Injected Dependencies ==="); // Use the controller controller.displayUsers(); // Create new users userService.createUser("john_doe"); userService.createUser("alice_smith"); controller.displayUsers(); // Demonstrate getting beans by different methods System.out.println("\n=== Bean Retrieval Methods ==="); // By type UserService serviceByType = context.getBean(UserService.class); System.out.println("Retrieved by type: " + (serviceByType == userService)); // By name and type EmailService emailService = context.getBean("emailService", EmailService.class); emailService.sendNotification("john_doe", "Test notification"); // Demonstrate reflection analysis System.out.println("\n=== Reflection Analysis ==="); analyzeBean(UserService.class, context); } public static void analyzeBean(Class<?> beanClass, ApplicationContext context) { System.out.println("Analyzing bean: " + beanClass.getSimpleName()); Object bean = context.getBean(beanClass); // Check annotations Component component = beanClass.getAnnotation(Component.class); Service service = beanClass.getAnnotation(Service.class); Repository repository = beanClass.getAnnotation(Repository.class); Controller controller = beanClass.getAnnotation(Controller.class); if (service != null) System.out.println(" Type: Service"); if (repository != null) System.out.println(" Type: Repository"); if (controller != null) System.out.println(" Type: Controller"); // Check autowired fields for (Field field : beanClass.getDeclaredFields()) { Autowired autowired = field.getAnnotation(Autowired.class); if (autowired != null) { System.out.println(" Injected: " + field.getType().getSimpleName() + " " + field.getName() + (autowired.required() ? " (required)" : " (optional)")); } } // Check post construct methods for (Method method : beanClass.getDeclaredMethods()) { if (method.isAnnotationPresent(PostConstruct.class)) { System.out.println(" Initializer: " + method.getName()); } } } }

Example 4: ORM Framework with Annotations

import java.lang.annotation.*; import java.lang.reflect.*; import java.util.*; import java.sql.*; import java.time.*; // ORM Annotations @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Entity @interface Table { String name(); } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface Column { String name() default ""; boolean nullable() default true; boolean unique() default false; int length() default 255; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface Id { String strategy() default "AUTO"; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface GeneratedValue { String strategy() default "AUTO"; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface OneToMany { String mappedBy() default ""; CascadeType[] cascade() default {}; FetchType fetch() default FetchType.LAZY; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface ManyToOne { CascadeType[] cascade() default {}; FetchType fetch() default FetchType.EAGER; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface Transient { } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Entity @interface Entity { } enum CascadeType { ALL, PERSIST, MERGE, REMOVE, REFRESH, DETACH } enum FetchType { EAGER, LAZY } // Simple ORM Framework class SimpleORM { private Connection connection; public SimpleORM(String url, String username, String password) throws SQLException { this.connection = DriverManager.getConnection(url, username, password); } public <T> void createTable(Class<T> entityClass) throws SQLException { Table table = entityClass.getAnnotation(Table.class); if (table == null) { throw new IllegalArgumentException("Class is not an entity: " + entityClass.getName()); } String tableName = table.name(); List<String> columns = new ArrayList<>(); for (Field field : entityClass.getDeclaredFields()) { if (field.isAnnotationPresent(Transient.class)) { continue; } Column column = field.getAnnotation(Column.class); Id id = field.getAnnotation(Id.class); String columnName = getColumnName(field); String columnType = getSqlType(field.getType()); List<String> constraints = new ArrayList<>(); if (id != null) { constraints.add("PRIMARY KEY"); if ("AUTO".equals(id.strategy())) { constraints.add("AUTO_INCREMENT"); } } if (column != null) { if (!column.nullable()) { constraints.add("NOT NULL"); } if (column.unique()) { constraints.add("UNIQUE"); } if (column.length() > 0 && field.getType() == String.class) { columnType = "VARCHAR(" + column.length() + ")"; } } String columnDefinition = columnName + " " + columnType + " " + String.join(" ", constraints); columns.add(columnDefinition.trim()); } String sql = String.format("CREATE TABLE IF NOT EXISTS %s (%s)", tableName, String.join(", ", columns)); try (Statement stmt = connection.createStatement()) { stmt.execute(sql); System.out.println("Created table: " + tableName); } } public <T> void save(T entity) throws SQLException, IllegalAccessException { Class<?> entityClass = entity.getClass(); Table table = entityClass.getAnnotation(Table.class); if (table == null) { throw new IllegalArgumentException("Class is not an entity: " + entityClass.getName()); } String tableName = table.name(); List<String> columnNames = new ArrayList<>(); List<String> placeholders = new ArrayList<>(); List<Object> values = new ArrayList<>(); Field idField = null; Object idValue = null; for (Field field : entityClass.getDeclaredFields()) { if (field.isAnnotationPresent(Transient.class)) { continue; } field.setAccessible(true); Object value = field.get(entity); if (field.isAnnotationPresent(Id.class)) { idField = field; idValue = value; } Column column = field.getAnnotation(Column.class); String columnName = getColumnName(field); columnNames.add(columnName); placeholders.add("?"); values.add(value); } String sql; if (idValue == null) { // INSERT sql = String.format("INSERT INTO %s (%s) VALUES (%s)", tableName, String.join(", ", columnNames), String.join(", ", placeholders)); } else { // UPDATE List<String> updates = new ArrayList<>(); for (int i = 0; i < columnNames.size(); i++) { updates.add(columnNames.get(i) + " = ?"); } sql = String.format("UPDATE %s SET %s WHERE %s = ?", tableName, String.join(", ", updates), getColumnName(idField)); values.add(idValue); // Add ID for WHERE clause } try (PreparedStatement stmt = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) { for (int i = 0; i < values.size(); i++) { stmt.setObject(i + 1, values.get(i)); } int affectedRows = stmt.executeUpdate(); if (idValue == null) { // Get generated ID try (ResultSet generatedKeys = stmt.getGeneratedKeys()) { if (generatedKeys.next()) { idField.set(entity, generatedKeys.getObject(1)); } } } System.out.println((idValue == null ? "Inserted" : "Updated") + " entity in " + tableName + " (" + affectedRows + " rows)"); } } public <T> T findById(Class<T> entityClass, Object id) throws SQLException, IllegalAccessException, InstantiationException { Table table = entityClass.getAnnotation(Table.class); if (table == null) { throw new IllegalArgumentException("Class is not an entity: " + entityClass.getName()); } String tableName = table.name(); Field idField = null; String idColumn = null; for (Field field : entityClass.getDeclaredFields()) { if (field.isAnnotationPresent(Id.class)) { idField = field; idColumn = getColumnName(field); break; } } if (idField == null) { throw new IllegalArgumentException("Entity has no @Id field: " + entityClass.getName()); } String sql = String.format("SELECT * FROM %s WHERE %s = ?", tableName, idColumn); try (PreparedStatement stmt = connection.prepareStatement(sql)) { stmt.setObject(1, id); try (ResultSet rs = stmt.executeQuery()) { if (rs.next()) { return mapResultSetToEntity(rs, entityClass); } } } return null; } public <T> List<T> findAll(Class<T> entityClass) throws SQLException, IllegalAccessException, InstantiationException { Table table = entityClass.getAnnotation(Table.class); if (table == null) { throw new IllegalArgumentException("Class is not an entity: " + entityClass.getName()); } String tableName = table.name(); String sql = "SELECT * FROM " + tableName; List<T> results = new ArrayList<>(); try (Statement stmt = connection.createStatement(); ResultSet rs = stmt.executeQuery(sql)) { while (rs.next()) { results.add(mapResultSetToEntity(rs, entityClass)); } } return results; } private <T> T mapResultSetToEntity(ResultSet rs, Class<T> entityClass) throws SQLException, IllegalAccessException, InstantiationException { T entity = entityClass.getDeclaredConstructor().newInstance(); for (Field field : entityClass.getDeclaredFields()) { if (field.isAnnotationPresent(Transient.class)) { continue; } field.setAccessible(true); String columnName = getColumnName(field); Object value = rs.getObject(columnName); // Handle type conversion if (value != null) { if (field.getType() == LocalDate.class && value instanceof java.sql.Date) { value = ((java.sql.Date) value).toLocalDate(); } else if (field.getType() == LocalDateTime.class && value instanceof java.sql.Timestamp) { value = ((java.sql.Timestamp) value).toLocalDateTime(); } } field.set(entity, value); } return entity; } private String getColumnName(Field field) { Column column = field.getAnnotation(Column.class); if (column != null && !column.name().isEmpty()) { return column.name(); } return field.getName(); } private String getSqlType(Class<?> type) { if (type == String.class) return "VARCHAR(255)"; if (type == Integer.class || type == int.class) return "INT"; if (type == Long.class || type == long.class) return "BIGINT"; if (type == Double.class || type == double.class) return "DOUBLE"; if (type == Boolean.class || type == boolean.class) return "BOOLEAN"; if (type == LocalDate.class) return "DATE"; if (type == LocalDateTime.class) return "TIMESTAMP"; return "VARCHAR(255)"; } public void close() throws SQLException { if (connection != null) { connection.close(); } } } // Example Entities @Table(name = "users") class User { @Id @GeneratedValue private Long id; @Column(name = "username", nullable = false, unique = true, length = 50) private String username; @Column(name = "email", nullable = false, unique = true) private String email; @Column(name = "created_at") private LocalDateTime createdAt; @Transient private String temporaryData; // Constructors public User() {} public User(String username, String email) { this.username = username; this.email = email; this.createdAt = LocalDateTime.now(); } // Getters and setters public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public LocalDateTime getCreatedAt() { return createdAt; } public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; } public String getTemporaryData() { return temporaryData; } public void setTemporaryData(String temporaryData) { this.temporaryData = temporaryData; } @Override public String toString() { return String.format("User{id=%d, username='%s', email='%s', createdAt=%s}", id, username, email, createdAt); } } @Table(name = "products") class Product { @Id @GeneratedValue private Long id; @Column(name = "name", nullable = false, length = 100) private String name; @Column(name = "price", nullable = false) private Double price; @Column(name = "in_stock") private Boolean inStock; @Column(name = "created_date") private LocalDate createdDate; public Product() {} public Product(String name, Double price, Boolean inStock) { this.name = name; this.price = price; this.inStock = inStock; this.createdDate = LocalDate.now(); } // Getters and setters public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Double getPrice() { return price; } public void setPrice(Double price) { this.price = price; } public Boolean getInStock() { return inStock; } public void setInStock(Boolean inStock) { this.inStock = inStock; } public LocalDate getCreatedDate() { return createdDate; } public void setCreatedDate(LocalDate createdDate) { this.createdDate = createdDate; } @Override public String toString() { return String.format("Product{id=%d, name='%s', price=%.2f, inStock=%s, createdDate=%s}", id, name, price, inStock, createdDate); } } public class ORMExample { public static void main(String[] args) { System.out.println("=== ORM Framework with Annotations ==="); // Use in-memory H2 database for demonstration String url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1"; String username = "sa"; String password = ""; try (SimpleORM orm = new SimpleORM(url, username, password)) { // Create tables orm.createTable(User.class); orm.createTable(Product.class); // Save entities System.out.println("\n=== Saving Entities ==="); User user1 = new User("john_doe", "[email protected]"); User user2 = new User("alice_smith", "[email protected]"); orm.save(user1); orm.save(user2); Product product1 = new Product("Laptop", 999.99, true); Product product2 = new Product("Mouse", 25.50, false); orm.save(product1); orm.save(product2); // Find by ID System.out.println("\n=== Finding by ID ==="); User foundUser = orm.findById(User.class, user1.getId()); System.out.println("Found user: " + foundUser); Product foundProduct = orm.findById(Product.class, product1.getId()); System.out.println("Found product: " + foundProduct); // Find all System.out.println("\n=== Finding All Entities ==="); List<User> allUsers = orm.findAll(User.class); System.out.println("All users:"); allUsers.forEach(System.out::println); List<Product> allProducts = orm.findAll(Product.class); System.out.println("All products:"); allProducts.forEach(System.out::println); // Update entity System.out.println("\n=== Updating Entity ==="); user1.setEmail("[email protected]"); orm.save(user1); User updatedUser = orm.findById(User.class, user1.getId()); System.out.println("Updated user: " + updatedUser); // Demonstrate annotation analysis System.out.println("\n=== Entity Analysis ==="); analyzeEntity(User.class); analyzeEntity(Product.class); } catch (Exception e) { e.printStackTrace(); } } public static void analyzeEntity(Class<?> entityClass) { System.out.println("Analyzing entity: " + entityClass.getSimpleName()); Table table = entityClass.getAnnotation(Table.class); if (table != null) { System.out.println(" Table: " + table.name()); } for (Field field : entityClass.getDeclaredFields()) { System.out.println(" Field: " + field.getName() + " (" + field.getType().getSimpleName() + ")"); if (field.isAnnotationPresent(Id.class)) { System.out.println(" @Id"); } if (field.isAnnotationPresent(Column.class)) { Column column = field.getAnnotation(Column.class); System.out.println(" @Column(name=\"" + column.name() + "\", " + "nullable=" + column.nullable() + ", " + "unique=" + column.unique() + ", " + "length=" + column.length() + ")"); } if (field.isAnnotationPresent(Transient.class)) { System.out.println(" @Transient"); } } } }

Example 5: Advanced Annotation Processing

import java.lang.annotation.*; import java.lang.reflect.*; import java.util.*; import java.util.stream.*; // Advanced annotation examples @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) @interface ValidationGroup { Class<?>[] value() default {}; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) @interface ConditionalValidation { String dependsOn(); String condition(); String message() default "Conditional validation failed"; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface Cacheable { String key() default ""; long ttl() default 3600; // Time to live in seconds CacheStrategy strategy() default CacheStrategy.LRU; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface Retryable { int maxAttempts() default 3; long delay() default 1000; // milliseconds Class<? extends Throwable>[] retryOn() default {Exception.class}; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface Loggable { LogLevel level() default LogLevel.INFO; boolean logParameters() default true; boolean logResult() default false; boolean logExecutionTime() default true; } @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface Secure { String[] roles() default {}; String permission() default ""; boolean requireAuthentication() default true; } enum CacheStrategy { LRU, FIFO, LFU } enum LogLevel { DEBUG, INFO, WARN, ERROR } // Annotation processor class AnnotationProcessor { public static void processAnnotations(Object target) { Class<?> clazz = target.getClass(); // Process class-level annotations processClassAnnotations(clazz); // Process method annotations for (Method method : clazz.getDeclaredMethods()) { processMethodAnnotations(method, target); } // Process field annotations for (Field field : clazz.getDeclaredFields()) { processFieldAnnotations(field, target); } } private static void processClassAnnotations(Class<?> clazz) { System.out.println("Processing class: " + clazz.getSimpleName()); // Add class-level annotation processing here } private static void processMethodAnnotations(Method method, Object target) { method.setAccessible(true); // @Loggable processing Loggable loggable = method.getAnnotation(Loggable.class); if (loggable != null) { wrapWithLogging(method, target, loggable); } // @Cacheable processing Cacheable cacheable = method.getAnnotation(Cacheable.class); if (cacheable != null) { wrapWithCaching(method, target, cacheable); } // @Retryable processing Retryable retryable = method.getAnnotation(Retryable.class); if (retryable != null) { wrapWithRetry(method, target, retryable); } // @Secure processing Secure secure = method.getAnnotation(Secure.class); if (secure != null) { wrapWithSecurity(method, target, secure); } } private static void processFieldAnnotations(Field field, Object target) { field.setAccessible(true); // Process field-level annotations ConditionalValidation conditional = field.getAnnotation(ConditionalValidation.class); if (conditional != null) { validateConditionally(field, target, conditional); } } private static void wrapWithLogging(Method method, Object target, Loggable loggable) { System.out.println("Wrapping " + method.getName() + " with logging (level: " + loggable.level() + ")"); // In a real implementation, this would use AOP or dynamic proxies } private static void wrapWithCaching(Method method, Object target, Cacheable cacheable) { System.out.println("Wrapping " + method.getName() + " with caching (TTL: " + cacheable.ttl() + "s)"); // In a real implementation, this would integrate with a cache system } private static void wrapWithRetry(Method method, Object target, Retryable retryable) { System.out.println("Wrapping " + method.getName() + " with retry (max attempts: " + retryable.maxAttempts() + ")"); // In a real implementation, this would implement retry logic } private static void wrapWithSecurity(Method method, Object target, Secure secure) { System.out.println("Wrapping " + method.getName() + " with security (roles: " + Arrays.toString(secure.roles()) + ")"); // In a real implementation, this would check authentication and authorization } private static void validateConditionally(Field field, Object target, ConditionalValidation conditional) { try { Object value = field.get(target); // Implement conditional validation logic System.out.println("Conditional validation for field: " + field.getName()); } catch (IllegalAccessException e) { System.err.println("Cannot access field: " + field.getName()); } } } // Example service with advanced annotations class AdvancedService { @Cacheable(key = "user_{0}", ttl = 3600, strategy = CacheStrategy.LRU) @Loggable(level = LogLevel.INFO, logParameters = true, logExecutionTime = true) @Retryable(maxAttempts = 3, delay = 1000, retryOn = {RuntimeException.class}) public String getUserData(String userId) { System.out.println("Fetching user data for: " + userId); // Simulate database call if (Math.random() < 0.3) { throw new RuntimeException("Database temporarily unavailable"); } return "User data for " + userId; } @Secure(roles = {"ADMIN", "MANAGER"}, permission = "USER_DELETE") @Loggable(level = LogLevel.WARN, logParameters = true, logResult = false) public void deleteUser(String userId) { System.out.println("Deleting user: " + userId); } @Cacheable(key = "products", ttl = 1800) @Loggable(level = LogLevel.DEBUG, logExecutionTime = true) public List<String> getProducts() { System.out.println("Fetching products"); return Arrays.asList("Product1", "Product2", "Product3"); } @ConditionalValidation(dependsOn = "age", condition = "value > 18", message = "Must be adult") private String driversLicense; public void setDriversLicense(String license) { this.driversLicense = license; } } // Custom annotation-based framework class Framework { private Map<String, Object> cache = new HashMap<>(); private int callCount = 0; public Object invokeMethod(Object target, Method method, Object[] args) throws Exception { callCount++; // Check @Secure Secure secure = method.getAnnotation(Secure.class); if (secure != null) { checkSecurity(secure); } // Check @Cacheable Cacheable cacheable = method.getAnnotation(Cacheable.class); if (cacheable != null) { String cacheKey = generateCacheKey(method, args, cacheable); if (cache.containsKey(cacheKey)) { System.out.println("Cache hit for key: " + cacheKey); return cache.get(cacheKey); } } // Execute with @Retryable Retryable retryable = method.getAnnotation(Retryable.class); if (retryable != null) { return executeWithRetry(target, method, args, retryable); } // Execute normally return method.invoke(target, args); } private void checkSecurity(Secure secure) { System.out.println("Checking security: roles=" + Arrays.toString(secure.roles()) + ", auth=" + secure.requireAuthentication()); // In real implementation, check user permissions } private String generateCacheKey(Method method, Object[] args, Cacheable cacheable) { if (!cacheable.key().isEmpty()) { // Replace placeholders with actual values String key = cacheable.key(); for (int i = 0; i < args.length; i++) { key = key.replace("{" + i + "}", String.valueOf(args[i])); } return key; } return method.getName() + "_" + Arrays.hashCode(args); } private Object executeWithRetry(Object target, Method method, Object[] args, Retryable retryable) throws Exception { int attempts = 0; while (attempts < retryable.maxAttempts()) { try { attempts++; System.out.println("Attempt " + attempts + " of " + retryable.maxAttempts()); return method.invoke(target, args); } catch (InvocationTargetException e) { Throwable cause = e.getCause(); boolean shouldRetry = Arrays.stream(retryable.retryOn()) .anyMatch(exceptionClass -> exceptionClass.isInstance(cause)); if (!shouldRetry || attempts == retryable.maxAttempts()) { throw e; } System.out.println("Retryable exception caught, waiting " + retryable.delay() + "ms"); Thread.sleep(retryable.delay()); } } throw new IllegalStateException("Should not reach here"); } public int getCallCount() { return callCount; } } public class AdvancedAnnotationProcessing { public static void main(String[] args) throws Exception { System.out.println("=== Advanced Annotation Processing ==="); AdvancedService service = new AdvancedService(); // Process annotations System.out.println("1. Annotation Processing:"); AnnotationProcessor.processAnnotations(service); // Test framework with annotations System.out.println("\n2. Framework Execution:"); Framework framework = new Framework(); // Test cached method with retry System.out.println("\nTesting getUserData (cached, retryable):"); for (int i = 0; i < 3; i++) { try { Method method = AdvancedService.class.getMethod("getUserData", String.class); String result = (String) framework.invokeMethod(service, method, new Object[]{"user123"}); System.out.println("Result: " + result); } catch (Exception e) { System.err.println("Error: " + e.getCause().getMessage()); } } // Test secure method System.out.println("\nTesting deleteUser (secure):"); try { Method method = AdvancedService.class.getMethod("deleteUser", String.class); framework.invokeMethod(service, method, new Object[]{"user456"}); } catch (Exception e) { e.printStackTrace(); } // Test products method System.out.println("\nTesting getProducts (cached):"); try { Method method = AdvancedService.class.getMethod("getProducts"); List<String> products = (List<String>) framework.invokeMethod(service, method, new Object[]{}); System.out.println("Products: " + products); } catch (Exception e) { e.printStackTrace(); } System.out.println("\nTotal method calls: " + framework.getCallCount()); // Demonstrate annotation inheritance System.out.println("\n3. Annotation Inheritance:"); demonstrateAnnotationInheritance(); // Demonstrate meta-annotations System.out.println("\n4. Meta-annotations:"); demonstrateMetaAnnotations(); } public static void demonstrateAnnotationInheritance() { @Retention(RetentionPolicy.RUNTIME) @Inherited @Target(ElementType.TYPE) @interface InheritedAnnotation { String value(); } @InheritedAnnotation("parent") class ParentClass {} class ChildClass extends ParentClass {} // Check if annotation is inherited InheritedAnnotation parentAnnotation = ParentClass.class.getAnnotation(InheritedAnnotation.class); InheritedAnnotation childAnnotation = ChildClass.class.getAnnotation(InheritedAnnotation.class); System.out.println("Parent annotation: " + (parentAnnotation != null ? parentAnnotation.value() : "null")); System.out.println("Child annotation: " + (childAnnotation != null ? childAnnotation.value() : "null")); System.out.println("Annotation inherited: " + (childAnnotation != null)); } public static void demonstrateMetaAnnotations() { // Analyze meta-annotations on built-in annotations Class<?>[] annotationClasses = { Override.class, Deprecated.class, SuppressWarnings.class, Target.class, Retention.class, Documented.class, Inherited.class }; System.out.println("Meta-annotations analysis:"); for (Class<?> annotationClass : annotationClasses) { System.out.println("\n" + annotationClass.getSimpleName() + ":"); Retention retention = annotationClass.getAnnotation(Retention.class); Target target = annotationClass.getAnnotation(Target.class); Documented documented = annotationClass.getAnnotation(Documented.class); Inherited inherited = annotationClass.getAnnotation(Inherited.class); if (retention != null) { System.out.println(" @Retention(" + retention.value() + ")"); } if (target != null) { System.out.println(" @Target(" + Arrays.toString(target.value()) + ")"); } if (documented != null) { System.out.println(" @Documented"); } if (inherited != null) { System.out.println(" @Inherited"); } } } }

9. Conclusion

Key Takeaways:

Built-in Annotations: @Override, @Deprecated, @SuppressWarnings, etc.
Meta-annotations: @Target, @Retention, @Documented, @Inherited, @Repeatable
Custom Annotations: Create your own with @interface
Runtime Processing: Use reflection to process annotations at runtime
Compile-time Processing: Use annotation processors for code generation

Annotation Retention Policies:

SOURCE: Discarded during compilation
CLASS: Recorded in class file but not retained at runtime
RUNTIME: Recorded in class file and available at runtime

Common Use Cases:

Configuration: Spring, Hibernate configuration
Validation: Bean validation frameworks
Code Generation: Lombok, MapStruct
Dependency Injection: Spring, Guice
Testing: JUnit, TestNG
Documentation: Swagger/OpenAPI

Best Practices:

✅ Use meaningful annotation names
✅ Provide default values for annotation elements
✅ Document your custom annotations
✅ Consider performance when using runtime annotations
✅ Use appropriate retention policies

Advanced Features:

Repeatable Annotations: Java 8+ feature for multiple annotations of same type
Type Annotations: Java 8+ feature for annotating types
Annotation Processors: Compile-time processing for code generation

Performance Considerations:

Reflection-based annotation processing can be slow
Compile-time processing has no runtime overhead
Cache annotation lookups when possible
Consider AOP for cross-cutting concerns

Final Thoughts:

Annotations have revolutionized Java development by enabling:

Declarative programming styles
Reduced boilerplate code
Framework integration without invasive code
Compile-time safety and verification

Master annotations to write more expressive, maintainable, and framework-compatible Java code!