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