Design patterns remain essential in modern Java enterprise applications despite framework abstraction. 2. Creational patterns like Singleton (managed by Spring) and Builder (for immutability) enable controlled object creation. 3. Structural patterns such as Adapter integrate legacy systems and Proxy enables AOP for logging or security. 4. Behavioral patterns like Strategy allow runtime algorithm selection and Observer supports event-driven design via Spring events. 5. Modern trends include DI for loose coupling, factory-based bean resolution, and reactive adaptations of Template Method. Understanding these patterns helps developers write maintainable, scalable, and testable code, even when frameworks implement them under the hood, making pattern knowledge crucial for effective customization, debugging, and collaboration in enterprise environments.

Design patterns in modern Java are more relevant than ever in enterprise applications—despite the rise of frameworks and automation. While tools like Spring, Jakarta EE, and reactive libraries abstract much of the complexity, understanding design patterns helps developers write maintainable, scalable, and testable code. Here’s how classic and modern interpretations of design patterns are applied in today’s enterprise Java environments.

1. Creational Patterns: Managing Object Creation Smartly

In enterprise apps, object creation must be efficient, configurable, and loosely coupled.

Singleton (Used Sparingly)

Though often overused or misused, the Singleton pattern still has valid use cases—like managing thread pools, cache managers, or configuration loaders.

With modern Java and dependency injection (DI) frameworks like Spring, you rarely implement Singleton manually. Instead, Spring’s @Component with default singleton scope handles it:

@Component
public class AppConfig {
    private Properties config;

    public String getProperty(String key) {
        return config.getProperty(key);
    }
}

Best Practice: Let the container manage lifecycle. Don’t hand-roll singletons unless you’re in a framework-free environment.

Builder Pattern (Especially with Immutable Objects)

Modern Java favors immutability (e.g., records, final fields). The Builder pattern is ideal for complex object construction.

With @Builder from Lombok:

@Builder
public class Order {
    private final String orderId;
    private final BigDecimal amount;
    private final LocalDateTime created;
}

Or manually for critical domains:

public class User {
    private final String name;
    private final String email;

    private User(Builder builder) {
        this.name = builder.name;
        this.email = builder.email;
    }

    public static class Builder {
        private String name;
        private String email;
        public Builder name(String name) { this.name = name; return this; }
        public Builder email(String email) { this.email = email; return this; }
        public User build() { return new User(this); }
    }
}

Useful for configuration objects, DTOs, and entities with many optional fields.

2. Structural Patterns: Building Flexible and Interoperable Systems

These help structure classes and objects to form larger, flexible systems.

Adapter Pattern (Integration Made Easy)

Common when integrating legacy systems or third-party APIs.

Example: Adapting a legacy LegacyPaymentProcessor to a modern PaymentService interface.

public interface PaymentService {
    PaymentResult process(PaymentRequest request);
}

public class LegacyPaymentAdapter implements PaymentService {
    private LegacyPaymentProcessor legacyProcessor;

    @Override
    public PaymentResult process(PaymentRequest request) {
        LegacyRequest adapted = convert(request);
        LegacyResponse response = legacyProcessor.send(adapted);
        return convertToResult(response);
    }
}

Widely used in microservices when wrapping external APIs or migrating systems.

Proxy Pattern (Transparent Enhancements)

Used for lazy loading, access control, or logging.

Spring AOP and proxies:

@Aspect
@Component
public class LoggingAspect {
    @Around("execution(* com.service.*.*(..))")
    public Object logExecution(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("Before: "   pjp.getSignature());
        Object result = pjp.proceed();
        System.out.println("After: "   pjp.getSignature());
        return result;
    }
}

Here, Spring generates a proxy that wraps your bean—classic structural proxy in action.

3. Behavioral Patterns: Managing Object Responsibility and Communication

These govern how objects interact and delegate responsibilities.

Strategy Pattern (Runtime Algorithm Switching)

Perfect for business logic that varies by context—e.g., discount rules, shipping methods.

public interface ShippingStrategy {
    BigDecimal calculate(Order order);
}

@Service
public class StandardShipping implements ShippingStrategy { ... }

@Service
public class ExpressShipping implements ShippingStrategy { ... }

@Component
public class ShippingCalculator {
    private final Map<String, ShippingStrategy> strategies;

    public ShippingCalculator(List<ShippingStrategy> strategyList) {
        this.strategies = strategyList.stream().collect(
            Collectors.toMap(this::getName, Function.identity())
        );
    }

    public BigDecimal calculate(String type, Order order) {
        return strategies.get(type).calculate(order);
    }
}

Spring autowires all ShippingStrategy beans, making this clean and extensible.

Observer Pattern (Event-Driven Architecture)

Java has java.util.Observable (deprecated), but modern apps use better alternatives.

In Spring: Application Events

// Event
public class OrderCreatedEvent {
    private final String orderId;
    // constructor, getter
}

// Publisher
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;

    public void createOrder(Order order) {
        // save order
        publisher.publishEvent(new OrderCreatedEvent(order.getId()));
    }
}

// Listener
@Component
public class EmailNotificationListener {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        sendEmail(event.getOrderId());
    }
}

This decouples business logic from side effects—ideal for microservices and domain-driven design.

4. Modern Trends: Patterns Beyond the Classics

While GoF patterns remain foundational, modern Java enterprise development embraces higher-level architectural patterns—often implemented using design patterns under the hood.

Dependency Injection (Not a GoF Pattern, But Fundamental)

DI is now standard via Spring or CDI. It enables Inversion of Control, making testing and configuration easier.

@Service
public class UserService {
    private final UserRepository repository;

    public UserService(UserRepository repository) {
        this.repository = repository; // Injected
    }
}

This promotes loose coupling and is the backbone of most modern Java apps.

Factory Pattern Spring = Smart Bean Resolution

Instead of new, use factories—often hidden behind DI.

@Component
public class ReportGeneratorFactory {
    private final Map<String, ReportGenerator> generators;

    public ReportGeneratorFactory(Map<String, ReportGenerator> generators) {
        this.generators = generators; // Spring injects all beans of type ReportGenerator
    }

    public ReportGenerator getGenerator(String type) {
        return generators.get(type   "ReportGenerator");
    }
}

No if-else or switch—just naming convention and autowiring.

Template Method in Reactive Streams

Even in reactive programming (Project Reactor), you see pattern echoes.

public abstract class BaseService<T> {
    public Mono<T> save(T entity) {
        return validate(entity)
            .then(beforeSave(entity))
            .then(doSave(entity)) // abstract
            .then(afterSave(entity))
            .thenReturn(entity);
    }

    protected abstract Mono<T> doSave(T entity);
}

This is Template Method adapted to non-blocking flows.

Final Thoughts

Design patterns in modern Java aren’t about rigidly applying GoF recipes—they’re about solving recurring problems with proven structures. Frameworks like Spring absorb many patterns (Singleton, Proxy, Observer, Factory), but understanding them lets you:

• Customize behavior when needed
• Debug and extend frameworks effectively
• Design clean APIs and services
• Collaborate with teams using a shared vocabulary

Bottom line: You may not write a Strategy or Observer from scratch every day, but you’re using them constantly—often through Spring. Knowing the "why" behind the magic makes you a better enterprise Java developer.

Basically, patterns haven’t disappeared—they’ve just gone undercover.

The above is the detailed content of Design Patterns in Modern Java for Enterprise Applications. For more information, please follow other related articles on the PHP Chinese website!