/java-design-pattern

description: Detects GoF patterns in Java code or recommends the right pattern for a problem. Use when user asks to "what pattern is this", "detect design patterns", "suggest a pattern", "should I use factory", "which design pattern", or "recommend a pattern for".
argument-hint: "[paste code to detect patterns, or describe your problem]"

Either detect which design patterns are used in the provided code, or recommend the right pattern for a described problem. Tailor all examples to the detected Java version (Java 8+).

Mode A — Detect patterns in existing code

Scan the code for these common patterns and name them explicitly:

**Creational:**

• **Singleton** — private constructor + static instance (flag if not thread-safe without `volatile` or `enum`)
• **Factory Method** — static `create()` or `of()` returning an interface type
• **Builder** — inner static `Builder` class with fluent setters and `build()`
• **Abstract Factory** — factory that creates families of related objects

**Structural:**

• **Decorator** — wraps another object implementing the same interface to add behaviour
• **Proxy** — Spring `@Transactional`, `@Cacheable`, `@Async` are all proxies; flag manual proxies
• **Adapter** — converts one interface to another (often with `*Adapter` or `*Wrapper` class name)
• **Facade** — simplifies a complex subsystem; often a service that orchestrates multiple repos/clients
• **Composite** — tree structure where leaf and composite implement the same interface

**Behavioral:**

• **Strategy** — interface with multiple implementations selected at runtime
• **Observer** — Spring `ApplicationEvent` / `@EventListener` or manual listener list
• **Template Method** — abstract class with `final` algorithm method calling overridable steps
• **Command** — encapsulates a request as an object (common in undo/redo, queuing)
• **Chain of Responsibility** — Spring Security filter chain, Servlet filters
• **State** — object behaviour changes based on internal state enum/object

For each detected pattern: name it, show the key code that reveals it, explain how it's used here.

Mode B — Recommend a pattern for a problem

When the user describes a problem, recommend the most appropriate pattern:

| Problem | Recommended Pattern | |---|---| | Need multiple algorithms interchangeable at runtime | Strategy | | Object creation is complex, many optional fields | Builder | | Need to add behaviour without modifying existing class | Decorator | | Need to notify multiple objects when state changes | Observer | | Complex subsystem needs a simple interface | Facade | | Same operation on tree structures | Composite | | Object has distinct lifecycle states | State | | Need only one instance globally | Singleton (or Spring `@Component`) |

Show a minimal Java implementation for the recommended pattern, appropriate for the detected Java version:

• Java 8+: use functional interfaces (Strategy can be a lambda `Function<T,R>`)
• Java 17+: use sealed classes for State pattern
• Java 16+: use records for value objects in patterns

Output format

**Mode A:** List each detected pattern with: name + location + explanation + any concerns (e.g., non-thread-safe Singleton) **Mode B:** Recommend pattern + minimal before/after code + when to use vs alternatives

Next Steps

• After identifying patterns → run `/java-solid` to check if patterns are applied correctly
• For implementation help → ask the `java-architect` agent for full design guidance