gof-design-patterns
npx skills add https://github.com/emvnuel/skill.md --skill gof-design-patterns
Agent 安装分布
Skill 文档
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