GoF Design Patterns Refactoring Detection
Identify opportunities to apply Gang of Four (GoF) Design Patterns in Jakarta EE and MicroProfile applications.
Creational Patterns
Factory Method
Detect: if/switch with new based on type/condition
Refactor: CDI Instance<T> + @Named qualifiers
Cookbook: factory-method.md
Abstract Factory
Detect: Creating families of related objects with scattered logic
Refactor: CDI qualifiers for factory interface implementations
Cookbook: abstract-factory.md
Builder
Detect: Constructors with 4+ parameters, telescoping constructors, many setters in sequence
Refactor: Fluent builder with build() method, immutable objects
Cookbook: builder.md
Singleton
Detect: Manual getInstance() with double-checked locking
Refactor: @ApplicationScoped CDI bean
Cookbook: singleton.md
Prototype
Detect: Expensive object creation, need to copy/clone objects
Refactor: Cloneable interface + prototype registry
Cookbook: prototype.md
Structural Patterns
Adapter
Detect: Interface mismatch with external/legacy APIs
Refactor: CDI bean wrapping legacy system with target interface
Cookbook: adapter.md
Bridge
Detect: Abstraction and implementation should vary independently
Refactor: Separate hierarchy for implementors, inject via CDI
Cookbook: bridge.md
Composite
Detect: Tree/hierarchy structures (menus, org charts, file systems)
Refactor: Recursive interface, JPA @OneToMany self-reference
Cookbook: composite.md
Decorator
Detect: Inheritance explosion, cross-cutting concerns mixed in business logic
Refactor: CDI @Decorator + @Delegate, @Interceptor for AOP
Cookbook: decorator.md
Facade
Detect: Resource/controller calling multiple services directly
Refactor: @ApplicationScoped facade service orchestrating subsystems
Cookbook: facade.md
Flyweight
Detect: Many similar objects causing high memory usage
Refactor: Shared object cache, separate intrinsic/extrinsic state
Cookbook: flyweight.md
Proxy
Detect: Manual lazy loading, scattered access control checks
Refactor: CDI proxies (automatic), @RolesAllowed, MicroProfile REST Client
Cookbook: proxy.md
Behavioral Patterns
Chain of Responsibility
Detect: Sequential handler processing with hardcoded chain
Refactor: CDI Instance<T> + ordering, JAX-RS filters
Cookbook: chain-of-responsibility.md
Command
Detect: Operations needing undo/redo, queuing, or logging
Refactor: Command objects with execute()/undo() + executor
Cookbook: command.md
Interpreter
Detect: DSL/grammar parsing, configurable business rules
Refactor: Expression tree with interpret() method
Cookbook: interpreter.md
Iterator
Detect: Custom traversal needed, lazy loading from database
Refactor: Custom Iterator<T> for paginated queries
Cookbook: iterator.md
Mediator
Detect: Complex inter-object communication, many direct dependencies
Refactor: CDI Events (Event<T> + @Observes) or mediator service
Cookbook: mediator.md
Memento
Detect: Need undo/redo, state snapshots, version history
Refactor: Memento objects + caretaker for history
Cookbook: memento.md
Observer
Detect: Direct method calls to notify multiple dependents
Refactor: CDI Event<T> + @Observes / @ObservesAsync
Cookbook: observer.md
State
Detect: Complex conditionals based on object state (if status == X)
Refactor: State interface with per-state implementations
Cookbook: state.md
Strategy
Detect: switch/if-else selecting between algorithms
Refactor: CDI Instance<T> + strategy selection by qualifier/type
Cookbook: strategy.md
Template Method
Detect: Duplicate algorithm structure with varying steps
Refactor: Abstract class with final template + abstract hooks
Cookbook: template-method.md
Visitor
Detect: Operations across unrelated element types
Refactor: Visitor interface + accept(visitor) in elements
Cookbook: visitor.md
Quick Reference Table
| Pattern | Detection Signal | Jakarta EE/MP Integration |
|---|---|---|
| Factory Method | if/switch with new based on type | CDI Instance<T> + qualifiers |
| Abstract Factory | Creating families of related objects | CDI qualifiers for factory types |
| Builder | Constructors with 4+ parameters | Immutable objects + fluent API |
| Singleton | Manual getInstance() pattern | @ApplicationScoped |
| Prototype | Expensive object creation, need copies | Cloneable + prototype registry |
| Adapter | Interface mismatch with external APIs | CDI bean wrapping legacy |
| Bridge | Abstraction/implementation should vary | CDI for implementor injection |
| Composite | Tree/hierarchy structures | Recursive interface + JPA |
| Decorator | Inheritance for extending behavior | @Decorator, @Interceptor |
| Facade | Multiple service calls in controller | @ApplicationScoped facade |
| Flyweight | Many similar objects, high memory | Shared caches, object pools |
| Proxy | Manual lazy loading / access control | CDI proxies, @RolesAllowed |
| Chain of Responsibility | Sequential handler processing | CDI Instance<T> + ordering |
| Command | Operations needing undo/queue/log | Command objects + executor |
| Interpreter | DSL/grammar parsing, rule engines | Expression trees + parser |
| Iterator | Custom traversal, lazy DB loading | Iterator<T>, paginated queries |
| Mediator | Complex inter-object communication | CDI Events or mediator service |
| Memento | Undo/redo, state snapshots | Memento objects + caretaker |
| Observer | Direct calls to multiple dependents | CDI Event<T> + @Observes |
| State | Complex state-based conditionals | State interface + transitions |
| Strategy | switch/if-else selecting algorithm | CDI Instance<T> + iteration |
| Template Method | Duplicate algorithm with varying steps | Abstract class with hooks |
| Visitor | Operations across unrelated elements | Visitor interface + accept |
MicroProfile-Specific Patterns
| MP Feature | Pattern Applied | Example |
|---|---|---|
| Health Check | Factory + Strategy | @Liveness, @Readiness implementing HealthCheck |
| Fault Tolerance | Decorator/Proxy | @Retry, @Timeout, @Fallback annotations |
| Config | Strategy | @ConfigProperty to select behavior at runtime |
| REST Client | Proxy | Interface-based remote service invocation |
| Metrics | Decorator | @Counted, @Timed interceptors |
When NOT to Apply Patterns
- •Simple cases: Don't add Factory for 2-3 types that rarely change
- •YAGNI: Don't add patterns for "future flexibility"
- •Performance-critical paths: Pattern overhead may matter
- •Clear and readable code: Patterns shouldn't obscure intent
- •Team familiarity: Consider team's pattern knowledge
Cookbook Index
All 23 GoF patterns with Jakarta EE implementations:
Creational (5): Factory Method · Abstract Factory · Builder · Singleton · Prototype
Structural (7): Adapter · Bridge · Composite · Decorator · Facade · Flyweight · Proxy
Behavioral (11): Chain of Responsibility · Command · Interpreter · Iterator · Mediator · Memento · Observer · State · Strategy · Template Method · Visitor