# Gof Design Patterns > Detects opportunities to apply GoF Design Patterns in Jakarta EE/MicroProfile. Use when reviewing code for structural improvements or implementing creational, structural, or behavioral patterns. - Skill: `emvnuel/gof-design-patterns-2` (Agent Skill, multi-file: 24 files) - Install (CLI): `npx skillmds@latest add emvnuel/gof-design-patterns-2` - Raw SKILL.md: https://api.skillmd.com/api/skills/emvnuel/gof-design-patterns-2/raw - Safety review: pending (external: skill-scanner PASS, skillspector PASS) - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: emvnuel (https://skillmd.com/u/emvnuel) - Updated: 2026-09-21 - Page: https://skillmd.com/skills/emvnuel/gof-design-patterns-2 --- # 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` + `@Named` qualifiers **Cookbook**: [factory-method.md](./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](./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](./cookbook/builder.md) ### Singleton **Detect**: Manual `getInstance()` with double-checked locking **Refactor**: `@ApplicationScoped` CDI bean **Cookbook**: [singleton.md](./cookbook/singleton.md) ### Prototype **Detect**: Expensive object creation, need to copy/clone objects **Refactor**: `Cloneable` interface + prototype registry **Cookbook**: [prototype.md](./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](./cookbook/adapter.md) ### Bridge **Detect**: Abstraction and implementation should vary independently **Refactor**: Separate hierarchy for implementors, inject via CDI **Cookbook**: [bridge.md](./cookbook/bridge.md) ### Composite **Detect**: Tree/hierarchy structures (menus, org charts, file systems) **Refactor**: Recursive interface, JPA `@OneToMany` self-reference **Cookbook**: [composite.md](./cookbook/composite.md) ### Decorator **Detect**: Inheritance explosion, cross-cutting concerns mixed in business logic **Refactor**: CDI `@Decorator` + `@Delegate`, `@Interceptor` for AOP **Cookbook**: [decorator.md](./cookbook/decorator.md) ### Facade **Detect**: Resource/controller calling multiple services directly **Refactor**: `@ApplicationScoped` facade service orchestrating subsystems **Cookbook**: [facade.md](./cookbook/facade.md) ### Flyweight **Detect**: Many similar objects causing high memory usage **Refactor**: Shared object cache, separate intrinsic/extrinsic state **Cookbook**: [flyweight.md](./cookbook/flyweight.md) ### Proxy **Detect**: Manual lazy loading, scattered access control checks **Refactor**: CDI proxies (automatic), `@RolesAllowed`, MicroProfile REST Client **Cookbook**: [proxy.md](./cookbook/proxy.md) --- ## Behavioral Patterns ### Chain of Responsibility **Detect**: Sequential handler processing with hardcoded chain **Refactor**: CDI `Instance` + ordering, JAX-RS filters **Cookbook**: [chain-of-responsibility.md](./cookbook/chain-of-responsibility.md) ### Command **Detect**: Operations needing undo/redo, queuing, or logging **Refactor**: Command objects with `execute()`/`undo()` + executor **Cookbook**: [command.md](./cookbook/command.md) ### Interpreter **Detect**: DSL/grammar parsing, configurable business rules **Refactor**: Expression tree with `interpret()` method **Cookbook**: [interpreter.md](./cookbook/interpreter.md) ### Iterator **Detect**: Custom traversal needed, lazy loading from database **Refactor**: Custom `Iterator` for paginated queries **Cookbook**: [iterator.md](./cookbook/iterator.md) ### Mediator **Detect**: Complex inter-object communication, many direct dependencies **Refactor**: CDI Events (`Event` + `@Observes`) or mediator service **Cookbook**: [mediator.md](./cookbook/mediator.md) ### Memento **Detect**: Need undo/redo, state snapshots, version history **Refactor**: Memento objects + caretaker for history **Cookbook**: [memento.md](./cookbook/memento.md) ### Observer **Detect**: Direct method calls to notify multiple dependents **Refactor**: CDI `Event` + `@Observes` / `@ObservesAsync` **Cookbook**: [observer.md](./cookbook/observer.md) ### State **Detect**: Complex conditionals based on object state (`if status == X`) **Refactor**: State interface with per-state implementations **Cookbook**: [state.md](./cookbook/state.md) ### Strategy **Detect**: `switch`/`if-else` selecting between algorithms **Refactor**: CDI `Instance` + strategy selection by qualifier/type **Cookbook**: [strategy.md](./cookbook/strategy.md) ### Template Method **Detect**: Duplicate algorithm structure with varying steps **Refactor**: Abstract class with `final` template + abstract hooks **Cookbook**: [template-method.md](./cookbook/template-method.md) ### Visitor **Detect**: Operations across unrelated element types **Refactor**: Visitor interface + `accept(visitor)` in elements **Cookbook**: [visitor.md](./cookbook/visitor.md) --- ## Quick Reference Table | Pattern | Detection Signal | Jakarta EE/MP Integration | | ----------------------- | -------------------------------------- | -------------------------------- | | Factory Method | `if/switch` with `new` based on type | CDI `Instance` + 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` + 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`, 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` + `@Observes` | | State | Complex state-based conditionals | State interface + transitions | | Strategy | `switch`/`if-else` selecting algorithm | CDI `Instance` + 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 1. **Simple cases**: Don't add Factory for 2-3 types that rarely change 2. **YAGNI**: Don't add patterns for "future flexibility" 3. **Performance-critical paths**: Pattern overhead may matter 4. **Clear and readable code**: Patterns shouldn't obscure intent 5. **Team familiarity**: Consider team's pattern knowledge --- ## Cookbook Index All 23 GoF patterns with Jakarta EE implementations: **Creational (5)**: [Factory Method](./cookbook/factory-method.md) · [Abstract Factory](./cookbook/abstract-factory.md) · [Builder](./cookbook/builder.md) · [Singleton](./cookbook/singleton.md) · [Prototype](./cookbook/prototype.md) **Structural (7)**: [Adapter](./cookbook/adapter.md) · [Bridge](./cookbook/bridge.md) · [Composite](./cookbook/composite.md) · [Decorator](./cookbook/decorator.md) · [Facade](./cookbook/facade.md) · [Flyweight](./cookbook/flyweight.md) · [Proxy](./cookbook/proxy.md) **Behavioral (11)**: [Chain of Responsibility](./cookbook/chain-of-responsibility.md) · [Command](./cookbook/command.md) · [Interpreter](./cookbook/interpreter.md) · [Iterator](./cookbook/iterator.md) · [Mediator](./cookbook/mediator.md) · [Memento](./cookbook/memento.md) · [Observer](./cookbook/observer.md) · [State](./cookbook/state.md) · [Strategy](./cookbook/strategy.md) · [Template Method](./cookbook/template-method.md) · [Visitor](./cookbook/visitor.md)