gof-design-patterns

by @emvnuel in Development

# Install this skill:

npx skills add emvnuel/SKILL.md --skill "gof-design-patterns"

Install specific skill from multi-skill repository

# Description

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.md

name: gof-design-patterns
description: 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.

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

# Supported AI Coding Agents

This skill is compatible with the SKILL.md standard and works with all major AI coding agents:

⚡ Amp 🚀 Antigravity 🤖 Claude Code 🦀 Clawdbot 📝 Codex ▶️ Cursor 🤖 Droid 💎 Gemini CLI 🐙 GitHub Copilot 🪿 Goose 📊 Kilo Code 🔧 Kiro CLI 💻 OpenCode 🦘 Roo Code 🌲 Trae 🏄 Windsurf

Learn more about the SKILL.md standard and how to use these skills with your preferred AI coding agent.