Marker Interfaces vs Annotations

// The Serializable marker interface — literally empty
public interface Serializable {
    // no methods — just a tag
}

// Inside ObjectOutputStream.writeObject()
if (!(obj instanceof Serializable)) {
    throw new NotSerializableException(obj.getClass().getName());
}

// Inside Object.clone()
if (!(this instanceof Cloneable)) {
    throw new CloneNotSupportedException();
}

// Inside Collections.sort() / binarySearch()
if (list instanceof RandomAccess || list.size() < BINARYSEARCH_THRESHOLD) {
    // use index-based iteration
} else {
    // use iterator-based iteration
}

// Compile-time safety: only Serializable objects can be cached
public class DistributedCache {
    public void put(String key, Serializable value) {
        // guaranteed serializable at compile time
        byte[] bytes = serialize(value);
        sendToCluster(key, bytes);
    }
}

// This won't compile — String[] implements Serializable, but a raw Socket doesn't
cache.put("session", new Socket()); // COMPILE ERROR

// Annotation approach — applies to methods, not just classes
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Auditable {}

@Auditable  // on class
public class PaymentService {

    @Auditable  // on method — can't do this with interfaces!
    public void processPayment(Order order) { ... }
}

// Marker interface
public interface Auditable {
    // empty — marks classes that need audit logging
}

// Service that enforces the contract at compile time
public class AuditService {
    public <T extends Auditable> void track(T entity, String action) {
        AuditLog log = new AuditLog();
        log.setEntityClass(entity.getClass().getSimpleName());
        log.setAction(action);
        log.setTimestamp(Instant.now());
        auditRepository.save(log);
    }
}

// Usage — compile-time safety
public class Order implements Auditable {
    private String orderId;
    private BigDecimal amount;
}

auditService.track(new Order(), "CREATED");      // compiles
auditService.track(new TempData(), "CREATED");   // COMPILE ERROR — TempData not Auditable

// Marker interface for cache-eligible entities
public interface Cacheable {
    // entities implementing this can be cached
}

// Generic cache that only accepts Cacheable types
public class EntityCache<T extends Cacheable> {
    private final Map<String, T> store = new ConcurrentHashMap<>();

    public void put(String key, T entity) {
        store.put(key, entity);
    }

    public Optional<T> get(String key) {
        return Optional.ofNullable(store.get(key));
    }
}

// Only Cacheable entities can be stored
public class Product implements Cacheable {
    private String sku;
    private String name;
}

EntityCache<Product> cache = new EntityCache<>();  // works
EntityCache<Socket> bad = new EntityCache<>();     // COMPILE ERROR

// From java.util.Collections source
public static <T> void sort(List<T> list, Comparator<? super T> c) {
    if (list instanceof RandomAccess || list.size() < INSERTIONSORT_THRESHOLD) {
        // Use index-based sort — fast for ArrayList
        for (int i = 0; i < list.size(); i++) {
            // direct get(i) access
        }
    } else {
        // Use iterator-based sort — efficient for LinkedList
        Object[] arr = list.toArray();
        Arrays.sort(arr, (Comparator) c);
        ListIterator<T> it = list.listIterator();
        for (Object e : arr) {
            it.next();
            it.set((T) e);
        }
    }
}

// The marker
public interface EventListener {
    // empty
}

// All specific listeners extend it
public interface ActionListener extends EventListener {
    void actionPerformed(ActionEvent e);
}

public interface MouseListener extends EventListener {
    void mouseClicked(MouseEvent e);
    void mousePressed(MouseEvent e);
    // ...
}

// Spring's Aware interfaces are marker-like (with one method)
// But Spring also uses pure markers:

// BeanFactoryAware — Spring injects the BeanFactory
public interface BeanFactoryAware extends Aware {
    void setBeanFactory(BeanFactory beanFactory);
}

// The Aware interface itself is a marker!
public interface Aware {
    // empty — signals that the bean wants framework callbacks
}

// Spring checks:
if (bean instanceof Aware) {
    if (bean instanceof BeanNameAware) {
        ((BeanNameAware) bean).setBeanName(beanName);
    }
    if (bean instanceof BeanFactoryAware) {
        ((BeanFactoryAware) bean).setBeanFactory(this);
    }
}

// Hibernate uses Serializable as a marker for entity IDs
@Entity
public class User {
    @Id
    private Long id;  // Long implements Serializable
}

// Custom marker for soft-deletable entities
public interface SoftDeletable {
    // marker — Hibernate event listener checks instanceof
}

@Entity
public class Customer implements SoftDeletable {
    private boolean deleted;
}

// Hibernate PreDeleteEventListener
public class SoftDeleteListener implements PreDeleteEventListener {
    @Override
    public boolean onPreDelete(PreDeleteEvent event) {
        if (event.getEntity() instanceof SoftDeletable) {
            // set deleted=true instead of actual DELETE
            return true; // veto the hard delete
        }
        return false;
    }
}

// Marker interfaces for role-based access
public interface AdminAccess {}
public interface UserAccess {}
public interface PublicAccess {}

// Controller base enforces at compile time
public abstract class AdminController<T extends AdminAccess> {
    // only AdminAccess services can be injected
    protected final T service;

    protected AdminController(T service) {
        this.service = service;
    }
}

public class UserManagementService implements AdminAccess {
    public void deleteUser(long id) { ... }
}

// Compiles — UserManagementService is AdminAccess
public class AdminUserController extends AdminController<UserManagementService> { }

// Won't compile — PublicSearchService is not AdminAccess
public class BadController extends AdminController<PublicSearchService> { }  // ERROR