Proxy Pattern

Acting as an intermediary control layer, the proxy pattern intercepts requests intended for target objects, routing them through surrogate instances rather than permitting direct access. This architectural approach enables the injection of pre-processing and post-processing logic—such as security validation, transaction coordination, audit logging, and input sanitizasion—without modifying the underlying service implementation.

Static vs. Dynamic Implementation

Static Proxy implementations require developers to manually construct proxy classes that implement the same interfaces as their targets. While this approach offers transparency, it introduces tight coupling; interface modifications necessitate synchronized updates across all proxy classes, complicating maintenance.

Dynamic Proxy architectures leverage the java.lang.reflect package to generate proxy classes at runtime. This eliminates the need for pre-compiled proxy source files and enables the assignment of proxy behavior to arbitrary target objects through the InvocationHandler interface.

JDK Dynamic Proxy Implementation

The JDK's built-in proxy mechanism generates bytecode for classes that implement specified interfaces on demand.

public class TalentAgency {
    public static Performer createRepresentationProxy(Artist talent) {
        return (Performer) Proxy.newProxyInstance(
            TalentAgency.class.getClassLoader(),
            new Class<?>[] { Performer.class },
            (proxy, method, arguments) -> {
                if ("performConcert".equals(method.getName())) {
                    System.out.println("Agency: Stage preparation and ticket validation");
                } else if ("meetAndGreet".equals(method.getName())) {
                    System.out.println("Agency: Security screening and scheduling");
                }
                return method.invoke(talent, arguments);
            }
        );
    }
}

CGLIB Enhancement

When target objects do not implement interfaces, CGLIB (Code Generation Library) creates proxies by generating subclasses that override target methods using bytecode manipulation, enabling proxy functionality for concrete classes.

Reflection Infrastructure

Dynamic proxies rely on Java Reflection, which provides runtime introspection capabilities for examining and manipulating classes, methods, and fields.

Class Metadata Acquisition

// Approach 1: Fully qualified class name (dynamic loading)
Class<?> metadata = Class.forName("com.enterprise.Employee");

// Approach 2: Class literal (compile-time checking)
Class<?> metadata = Employee.class;

// Approach 3: Instance introspection
Employee instance = new Employee();
Class<?> metadata = instance.getClass();

Runtime Method Invocation

Class<?> serviceType = Class.forName("com.enterprise.PaymentGateway");
Object gateway = serviceType.getDeclaredConstructor().newInstance();
Method transactionMethod = serviceType.getMethod("processTransaction", String.class, BigDecimal.class);
Object receipt = transactionMethod.invoke(gateway, "INV-2024", new BigDecimal("150.00"));

Framework Integration

Spring AOP implements proxy patterns to weave cross-cutting concerns—such as logging and declarative transactions—around service components without source code intrusion.

MyBatis utilizes interface proxies to map Java method invocations to SQL statements, eliminating the need for manual JDBC boilerplate while maintaining type safety.

Dubbo employs transport proxies to abstract distributed service calls, presenting remote methods as local invocations while handling serialization, load balancing, and fault tolerance transparently.

Singleton Pattern

Restricting class instantiation to a single JVM-wide instance, the Singleton pattern ensures controlled access to shared resources through a global access point while managing concurrency risks.

Initialization Strategies

Lazy Initialization postpones instance creation until first use, requiring double-checked locking to maintain thread safety:

public class ConfigurationManager {
    private static volatile ConfigurationManager instance;
    private Properties settings;
    
    private ConfigurationManager() {
        this.settings = loadConfiguration();
    }
    
    public static ConfigurationManager getInstance() {
        if (instance == null) {
            synchronized (ConfigurationManager.class) {
                if (instance == null) {
                    instance = new ConfigurationManager();
                }
            }
        }
        return instance;
    }
}

Eager Initialization creates the instance during class loading, eliminating synchronization overhead and ensuring thread safety without explicit locking:

public class DatabaseConnectionPool {
    private static final DatabaseConnectionPool INSTANCE = new DatabaseConnectionPool();
    
    private DatabaseConnectionPool() {
        initializePool();
    }
    
    public static DatabaseConnectionPool getInstance() {
        return INSTANCE;
    }
}

Enterprise Applications

Configuration Management: Centralized repositories for environment-specific settings and feature flags.

Logging Infrastructure: Single entry points for log aggregation to prevent file descriptor exhaustion and ensure chronological ordering.

Resource Pooling: Database connection managers and thread executors that must maintain global state regarding resource availability.

Spring Container: Default bean scope instantiates singleton objects managed by the IoC container, ensuring consistent state across application contexts.

Factory Method Pattern

Defining a creational interface while delegating instantiation logic to subclasses, the Factory Method pattern decouples object construction from business logic, enabling runtime flexibility in type selection.

Structural Implementation

interface MessageChannel {
    void transmit(String payload);
}

class EmailChannel implements MessageChannel {
    public void transmit(String payload) {
        System.out.println("Email dispatched: " + payload);
    }
}

class PushNotificationChannel implements MessageChannel {
    public void transmit(String payload) {
        System.out.println("Push notification sent: " + payload);
    }
}

abstract class CommunicationFactory {
    abstract MessageChannel establishChannel();
    
    public void broadcast(String content) {
        MessageChannel channel = establishChannel();
        channel.transmit(content);
    }
}

class EmailFactory extends CommunicationFactory {
    MessageChannel establishChannel() { return new EmailChannel(); }
}

class PushFactory extends CommunicationFactory {
    MessageChannel establishChannel() { return new PushNotificationChannel(); }
}

Spring IoC and FactoryBean

Spring's ApplicationContext implements the factory pattern, managing object lifecycles and dependency graphs. The FactoryBean interface provides granular control over instantiation:

@Component
public class EncryptionFactory implements FactoryBean<CipherEngine> {
    @Override
    public CipherEngine getObject() {
        return new AesCipherEngine(256, "GCM");
    }
    
    @Override
    public Class<?> getObjectType() {
        return CipherEngine.class;
    }
    
    @Override
    public boolean isSingleton() {
        return true;
    }
}

Abstract Factory Pattern

Providing an interface for creating families of related objects without specifying concrete implementations, this pattern ensures component compatibility across different platform variants or product lines.

Cross-Platform Component Creation

interface UIFactory {
    Button createButton();
    TextField createInput();
}

class WindowsUIFactory implements UIFactory {
    public Button createButton() { return new WindowsButton(); }
    public TextField createInput() { return new WindowsTextField(); }
}

class MacOSUIFactory implements UIFactory {
    public Button createButton() { return new MacOSButton(); }
    public TextField createInput() { return new MacOSTextField(); }
}

Template Method Pattern

Defining algorithmic skeletons in base classes while permitting subclasses to override specific steps, this pattern promotes code reuse while enforcing structural consistency across implementations.

Algorithmic Framework

abstract class DocumentParser {
    public final void parseDocument() {
        acquireResource();
        extractContent();
        releaseResource();
    }
    
    protected void acquireResource() {
        System.out.println("Opening file stream");
    }
    
    protected abstract void extractContent();
    
    protected void releaseResource() {
        System.out.println("Closing file handles");
    }
}

class CSVParser extends DocumentParser {
    protected void extractContent() {
        System.out.println("Tokenizing comma-separated values");
    }
}

class JSONParser extends DocumentParser {
    protected void extractContent() {
        System.out.println("Mapping JSON nodes to objects");
    }
}

Servlet and JDBC Applications

Java Servlet API: The HttpServlet class defines the service() template method, which delegates to doGet(), doPost(), and other hook methods implemented by concrete servlets.

Spring JDBC: JdbcTemplate encapsulates connection acquisition, statement preparation, and exception translation, allowing developers to focus exclusively on result set mapping logic.