2nd/10_Wiki/Topics/AI_and_ML/Factory-Pattern.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-factory-pattern	Factory Pattern	10_Wiki/Topics	verified	self	factory factory method abstract factory simple factory GoF factory	none	A	0.97	applied	design-pattern gof factory oop creational abstract-factory		2026-05-10	pending	language applicable_to TypeScript / Python / Java OOP Plugin System DI

Factory Pattern

매 한 줄

"매 object creation 의 의 의 encapsulate". GoF creational. 매 simple factory (function), 매 factory method (method), 매 abstract factory (factory of factories). 매 modern: 매 DI / DI container 의 partly 의 replace.

매 핵심

매 variant

• Simple factory: 매 단순 function.
• Factory method: 매 polymorphic creation.
• Abstract factory: 매 family of factories.

매 motivation

• 매 client 의 concrete class 의 의 know X.
• 매 creation logic 의 encapsulate.
• 매 family of related objects.
• 매 testability (mock).

매 modern alternative

• DI container (Inversify, NestJS).
• Builder (complex creation).
• Static factory method (named).
• Functional factory.

💻 패턴

Simple factory

function createButton(theme: 'light' | 'dark'): Button {
  if (theme === 'light') return new LightButton();
  return new DarkButton();
}

Factory method

abstract class Dialog {
  protected abstract createButton(): Button;
  
  render() {
    const btn = this.createButton();
    btn.render();
  }
}

class WindowsDialog extends Dialog {
  protected createButton(): Button {
    return new WindowsButton();
  }
}

class MacDialog extends Dialog {
  protected createButton(): Button {
    return new MacButton();
  }
}

Abstract factory

interface UIFactory {
  createButton(): Button;
  createCheckbox(): Checkbox;
}

class WindowsFactory implements UIFactory {
  createButton() { return new WindowsButton(); }
  createCheckbox() { return new WindowsCheckbox(); }
}

class MacFactory implements UIFactory {
  createButton() { return new MacButton(); }
  createCheckbox() { return new MacCheckbox(); }
}

function getFactory(): UIFactory {
  return process.platform === 'darwin' ? new MacFactory() : new WindowsFactory();
}

Static factory method (Effective Java)

class User {
  private constructor(public id: string, public role: string) {}
  
  static guest() { return new User('guest', 'guest'); }
  static admin(id: string) { return new User(id, 'admin'); }
  static fromJSON(json: any) { return new User(json.id, json.role); }
}

Functional (Python)

from typing import Callable

def make_logger(level: str) -> Callable:
    if level == 'debug':
        return lambda msg: print(f'[DEBUG] {msg}')
    if level == 'error':
        return lambda msg: sys.stderr.write(f'[ERROR] {msg}\n')
    return lambda msg: print(msg)

Registry-based factory

class ShapeRegistry:
    _registry: dict = {}
    
    @classmethod
    def register(cls, name: str):
        def decorator(klass):
            cls._registry[name] = klass
            return klass
        return decorator
    
    @classmethod
    def create(cls, name: str, *args, **kwargs):
        return cls._registry[name](*args, **kwargs)

@ShapeRegistry.register('circle')
class Circle:
    def __init__(self, r): self.r = r

shape = ShapeRegistry.create('circle', 5)

DI container alternative (NestJS)

@Injectable()
class UserService {
  constructor(
    @Inject('UserRepo') private repo: UserRepo,
    private logger: Logger,
  ) {}
}

@Module({
  providers: [
    UserService,
    Logger,
    { provide: 'UserRepo', useClass: PostgresUserRepo },
  ],
})
class AppModule {}

Plugin / strategy factory

PARSERS = {
    'json': JSONParser,
    'yaml': YAMLParser,
    'toml': TOMLParser,
}

def parse(content, format):
    return PARSERS[format]().parse(content)

Conditional with extensibility

class ModelFactory:
    def __init__(self):
        self.providers = {}
    
    def register(self, name, provider_cls):
        self.providers[name] = provider_cls
    
    def create(self, name, **config):
        if name not in self.providers:
            raise ValueError(f'Unknown provider: {name}')
        return self.providers[name](**config)

factory = ModelFactory()
factory.register('openai', OpenAIProvider)
factory.register('anthropic', AnthropicProvider)

Async factory

class DBConnectionFactory:
    @classmethod
    async def create(cls, url):
        conn = AsyncConnection(url)
        await conn.connect()
        return conn

db = await DBConnectionFactory.create('postgres://...')

매 결정 기준

상황	Pattern
Simple variant	Simple factory function
Polymorphic creation	Factory method
Family of objects	Abstract factory
Many params	Builder
Plugin system	Registry
DI heavy	DI container
Functional	Closure factory

기본값: 매 simple = 매 plain function. 매 plugin = registry. 매 DI = container. 매 family = abstract factory.

🔗 Graph

• 부모: Design-Pattern · GoF
• 변형: Builder · Singleton · Prototype
• 응용: Plugin-System · Dependency-Injection
• Adjacent: Strategy-Pattern · Encapsulation-and-Information-Hiding

🤖 LLM 활용

언제: 매 plugin / multiple impl. 매 testability. 매 family of objects. 언제 X: 매 single concrete (just new).

❌ 안티패턴

• Factory for factory's sake: 매 single impl.
• God factory: 매 too many responsibilities.
• Hidden global state: 매 testability lose.
• Switch explosion: 매 registry 의 prefer.
• Reinventing DI: 매 use container.

🧪 검증 / 중복

• Verified (GoF Design Patterns, Effective Java).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-04-20	Auto-reinforced
2026-05-08	Phase 1
2026-05-10	Manual cleanup — variants + 매 simple / method / abstract / registry / DI code