[Design Patterns] 04. 팩토리 패턴의 진화

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

// 이후 예제 전반에서 재사용하는 최소 타입 정의
public interface PaymentProcessor {
    void process(Payment payment);
}

public class Payment {
    private final double amount;
    public Payment(double amount) { this.amount = amount; }
    public double getAmount() { return amount; }
}

public class Customer {
    private final String email;
    public Customer(String email) { this.email = email; }
    public String getEmail() { return email; }
}

public enum PaymentType { CREDIT_CARD, PAYPAL, BANK_TRANSFER, CRYPTOCURRENCY }

public class Order {
    private final Payment payment;
    private final Customer customer;
    private final PaymentType paymentType;

    public Order(Payment payment, Customer customer, PaymentType paymentType) {
        this.payment = payment;
        this.customer = customer;
        this.paymentType = paymentType;
    }

    public Payment getPayment() { return payment; }
    public Customer getCustomer() { return customer; }
    public PaymentType getPaymentType() { return paymentType; }
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) { /* 카드사 API 호출 */ }
}

public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) { /* PayPal API 호출 */ }
}

public class BankTransferProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) { /* 은행 이체 API 호출 */ }
}

public interface EmailNotifier {
    void sendConfirmation(Customer customer);
}

public class SmtpEmailNotifier implements EmailNotifier {
    @Override
    public void sendConfirmation(Customer customer) { /* SMTP 발송 */ }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 언뜻 보기에는 문제없어 보이는 코드
public class OrderService {
    public void processOrder(Order order) {
        PaymentProcessor processor = new CreditCardProcessor();  // 하드코딩!
        EmailNotifier notifier = new SmtpEmailNotifier();       // 하드코딩!
        
        processor.process(order.getPayment());
        notifier.sendConfirmation(order.getCustomer());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Simple Factory 패턴
public class PaymentProcessorFactory {
    public static PaymentProcessor create(PaymentType type) {
        switch (type) {
            case CREDIT_CARD:
                return new CreditCardProcessor();
            case PAYPAL:
                return new PayPalProcessor();
            case BANK_TRANSFER:
                return new BankTransferProcessor();
            default:
                throw new IllegalArgumentException("Unsupported payment type: " + type);
        }
    }
}

// 사용하는 쪽
public class OrderService {
    public void processOrder(Order order) {
        PaymentProcessor processor = PaymentProcessorFactory.create(order.getPaymentType());
        processor.process(order.getPayment());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 새로운 결제 방식 추가 시
public static PaymentProcessor create(PaymentType type) {
    switch (type) {
        case CREDIT_CARD:
            return new CreditCardProcessor();
        case PAYPAL:
            return new PayPalProcessor();
        case BANK_TRANSFER:
            return new BankTransferProcessor();
        case CRYPTOCURRENCY:  // 새로 추가
            return new CryptocurrencyProcessor();  // 기존 코드 수정!
        default:
            throw new IllegalArgumentException("Unsupported payment type: " + type);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// Java의 실제 사례들
List<String> emptyList = Collections.emptyList();
Optional<String> optional = Optional.of("value");
LocalDate today = LocalDate.now();
Integer number = Integer.valueOf(42);  // new Integer(42)보다 권장

// 장점을 보여주는 커스텀 예제
public class DatabaseConnection {
    private final String url;
    private final ConnectionType type;
    
    private DatabaseConnection(String url, ConnectionType type) {
        this.url = url;
        this.type = type;
    }
    
    // 의미 있는 이름으로 생성 의도를 명확히 전달
    public static DatabaseConnection forMySQL(String host, int port, String database) {
        String url = String.format("jdbc:mysql://%s:%d/%s", host, port, database);
        return new DatabaseConnection(url, ConnectionType.MYSQL);
    }
    
    public static DatabaseConnection forPostgreSQL(String host, int port, String database) {
        String url = String.format("jdbc:postgresql://%s:%d/%s", host, port, database);
        return new DatabaseConnection(url, ConnectionType.POSTGRESQL);
    }
    
    public static DatabaseConnection fromUrl(String url) {
        ConnectionType type = ConnectionType.fromUrl(url);
        return new DatabaseConnection(url, type);
    }
    
    // 캐싱을 통한 성능 최적화도 가능
    private static final Map<String, DatabaseConnection> cache = new ConcurrentHashMap<>();
    
    public static DatabaseConnection cached(String url) {
        return cache.computeIfAbsent(url, DatabaseConnection::fromUrl);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// 추상 Creator 클래스
public abstract class PaymentServiceCreator {
    // Template Method: 전체 프로세스를 정의
    public final PaymentResult processPayment(PaymentRequest request) {
        PaymentProcessor processor = createPaymentProcessor();  // Factory Method
        
        // 공통 로직
        logPaymentAttempt(request);
        PaymentResult result = processor.process(request);
        logPaymentResult(result);
        
        return result;
    }
    
    // Factory Method: 서브클래스에서 구현
    protected abstract PaymentProcessor createPaymentProcessor();
    
    // 공통 기능들
    private void logPaymentAttempt(PaymentRequest request) {
        System.out.println("Processing payment: " + request.getAmount());
    }
    
    private void logPaymentResult(PaymentResult result) {
        System.out.println("Payment result: " + result.getStatus());
    }
}

// 구체적인 Creator 구현들
public class CreditCardPaymentService extends PaymentServiceCreator {
    @Override
    protected PaymentProcessor createPaymentProcessor() {
        return new CreditCardProcessor();
    }
}

public class PayPalPaymentService extends PaymentServiceCreator {
    @Override
    protected PaymentProcessor createPaymentProcessor() {
        return new PayPalProcessor();
    }
}

// 새로운 결제 방식 추가 - 기존 코드 수정 없음!
public class CryptocurrencyPaymentService extends PaymentServiceCreator {
    @Override
    protected PaymentProcessor createPaymentProcessor() {
        return new CryptocurrencyProcessor();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

// AbstractList의 iterator() / listIterator() (OpenJDK 실제 구조를 단순화)
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

    // Factory Method 1: 순방향 전용 Iterator를 반환
    public Iterator<E> iterator() {
        return new Itr();  // listIterator()에 위임하지 않음
    }

    // Factory Method 2: 양방향 탐색이 가능한 ListIterator를 반환
    public ListIterator<E> listIterator() {
        return listIterator(0);
    }

    public ListIterator<E> listIterator(final int index) {
        rangeCheckForAdd(index);
        return new ListItr(index);  // 기본 구현
    }

    private class Itr implements Iterator<E> {
        // 기본 fail-fast Iterator 구현
    }

    private class ListItr extends Itr implements ListIterator<E> {
        // Itr을 확장해 양방향 이동·set·add를 추가 구현
    }

    // ArrayList, LinkedList 등에서 각각 최적화된 Iterator/ListIterator 구현
}

// ArrayList의 구현 (java.util.ArrayList 실제 구조를 단순화)
public class ArrayList<E> extends AbstractList<E> {

    @Override
    public Iterator<E> iterator() {
        return new Itr();  // ArrayList 전용 최적화 Iterator (listIterator()와 무관하게 독립 구현)
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: " + index);
        return new ListItr(index);  // ArrayList 전용 최적화 ListIterator
    }

    private class Itr implements Iterator<E> {
        // 배열 인덱스 기반의 효율적인 구현 (modCount로 fail-fast 검사)
    }

    private class ListItr extends Itr implements ListIterator<E> {
        // ArrayList에 특화된 양방향 이동 구현
    }
}

// LinkedList의 구현 (java.util.LinkedList 실제 구조를 단순화)
public class LinkedList<E> extends AbstractSequentialList<E> {
    @Override
    public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);  // 노드 포인터 기반에 최적화된 ListIterator
    }

    private class ListItr implements ListIterator<E> {
        // LinkedList에 특화된 노드 기반 구현
    }

    // iterator()는 별도로 오버라이드하지 않는다 — 상위 클래스인
    // AbstractSequentialList.iterator()가 listIterator()에 위임하도록
    // 이미 재정의되어 있으므로 그 구현을 그대로 상속받는다.
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

// BeanFactory 인터페이스 - Factory Method의 추상화 (실제 시그니처, 일부만 발췌)
public interface BeanFactory {
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    
    boolean containsBean(String name);
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    // ... 기타 Factory Methods
}

// ApplicationContext - 고수준 Factory
// 주의: 아래 getBean() default 메서드와 getBeanFactory() 호출은
// 실제 ApplicationContext 인터페이스에 없는 가상 코드다.
// 실제로는 BeanFactory의 getBean 시그니처를 그대로 상속받아 쓴다.
public interface ApplicationContext extends BeanFactory, MessageSource, 
        ApplicationEventPublisher, ResourcePatternResolver {
    
    // (가상) Factory Method들이 Template Method 패턴으로 조합되는 모습을 보여주기 위한 예시
    default <T> T getBean(Class<T> requiredType) throws BeansException {
        return getBeanFactory().getBean(requiredType);
    }
    
    // 복잡한 초기화 로직이 Template Method로 구현됨
    void refresh() throws BeansException, IllegalStateException;
}

// 구체적인 구현체들
public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
    
    // Factory Method 구현
    @Override
    protected Resource[] getConfigResources() {
        return getConfigLocations() != null 
            ? Arrays.stream(getConfigLocations())
                   .map(ClassPathResource::new)
                   .toArray(Resource[]::new)
            : null;
    }
}

public class AnnotationConfigApplicationContext extends GenericApplicationContext {
    
    // Factory Method 구현
    @Override
    protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
        super.customizeBeanFactory(beanFactory);
        if (this.allowBeanDefinitionOverriding != null) {
            beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        if (this.allowCircularReferences != null) {
            beanFactory.setAllowCircularReferences(this.allowCircularReferences);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 문제 상황: 플랫폼별로 다른 컴포넌트들이 섞일 수 있음
public class ApplicationWindow {
    public void createUI() {
        // 문제: 플랫폼별로 다른 컴포넌트들이 섞일 수 있음
        Button button = new WindowsButton();      // Windows 스타일
        TextField textField = new MacTextField(); // Mac 스타일 - 일관성 깨짐!
        Menu menu = new LinuxMenu();              // Linux 스타일 - 더 큰 문제!
        
        // 시각적 일관성이 파괴됨
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

// Abstract Factory 패턴 구현
public interface GUIFactory {
    Button createButton();
    TextField createTextField();
    Menu createMenu();
    Dialog createDialog();
}

// Windows 전용 Factory
public class WindowsGUIFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }
    
    @Override
    public TextField createTextField() {
        return new WindowsTextField();
    }
    
    @Override
    public Menu createMenu() {
        return new WindowsMenu();
    }
    
    @Override
    public Dialog createDialog() {
        return new WindowsDialog();
    }
}

// Mac 전용 Factory
public class MacGUIFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }
    
    @Override
    public TextField createTextField() {
        return new MacTextField();
    }
    
    @Override
    public Menu createMenu() {
        return new MacMenu();
    }
    
    @Override
    public Dialog createDialog() {
        return new MacDialog();
    }
}

// 클라이언트 코드
public class ApplicationWindow {
    private final GUIFactory guiFactory;
    
    public ApplicationWindow(GUIFactory guiFactory) {
        this.guiFactory = guiFactory;
    }
    
    public void createUI() {
        // 모든 컴포넌트가 동일한 플랫폼 스타일로 생성됨
        Button button = guiFactory.createButton();
        TextField textField = guiFactory.createTextField();
        Menu menu = guiFactory.createMenu();
        Dialog dialog = guiFactory.createDialog();
        
        // 시각적 일관성 보장!
    }
}

// Factory 선택 로직
public class GUIFactoryProvider {
    public static GUIFactory getFactory() {
        String os = System.getProperty("os.name").toLowerCase();
        
        if (os.contains("windows")) {
            return new WindowsGUIFactory();
        } else if (os.contains("mac")) {
            return new MacGUIFactory();
        } else {
            return new LinuxGUIFactory();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// JDBC의 Abstract Factory 구조
public interface Driver {
    Connection connect(String url, Properties info) throws SQLException;
    boolean acceptsURL(String url) throws SQLException;
}

// Connection이 Abstract Factory 역할
public interface Connection {
    Statement createStatement() throws SQLException;
    PreparedStatement prepareStatement(String sql) throws SQLException;
    CallableStatement prepareCall(String sql) throws SQLException;
    DatabaseMetaData getMetaData() throws SQLException;
}

// MySQL 드라이버의 구현
public class MySQLConnection implements Connection {
    @Override
    public Statement createStatement() throws SQLException {
        return new MySQLStatement(this);  // MySQL 전용 Statement
    }
    
    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        return new MySQLPreparedStatement(this, sql);  // MySQL 전용 PreparedStatement
    }
    
    @Override
    public DatabaseMetaData getMetaData() throws SQLException {
        return new MySQLDatabaseMetaData(this);  // MySQL 전용 MetaData
    }
}

// PostgreSQL 드라이버의 구현
public class PostgreSQLConnection implements Connection {
    @Override
    public Statement createStatement() throws SQLException {
        return new PostgreSQLStatement(this);  // PostgreSQL 전용 Statement
    }
    
    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        return new PostgreSQLPreparedStatement(this, sql);  // PostgreSQL 전용 PreparedStatement
    }
    
    @Override
    public DatabaseMetaData getMetaData() throws SQLException {
        return new PostgreSQLDatabaseMetaData(this);  // PostgreSQL 전용 MetaData
    }
}

// 사용법 - 드라이버 변경 시에도 일관된 객체군 보장
public class DatabaseService {
    private final Connection connection;
    
    public DatabaseService(String databaseUrl) throws SQLException {
        this.connection = DriverManager.getConnection(databaseUrl);
        // URL에 따라 적절한 Connection 구현체가 반환됨
        // 그리고 그 Connection에서 생성되는 모든 객체들이 일관성을 가짐
    }
    
    public void executeQuery(String sql) throws SQLException {
        Statement stmt = connection.createStatement();  // 드라이버별 최적화된 Statement
        PreparedStatement pstmt = connection.prepareStatement(sql);  // 일관된 구현체
        DatabaseMetaData metadata = connection.getMetaData();  // 일관된 메타데이터
        
        // 모든 객체가 동일한 드라이버 구현체 계열
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

// AWS SDK의 Abstract Factory 패턴 (개념 단순화)
// 실제 AWS SDK for Java 2.x는 이런 통합 Factory 인터페이스를 제공하지 않고
// 서비스별 Client.builder()를 개별 호출한다 — 아래는 그 관례를 Abstract Factory
// 형태로 재구성한 가상 예제이며, AmazonS3/AmazonEC2 등은 실제 AWS SDK v1 타입이다.
public interface AWSServiceFactory {
    AmazonS3 createS3Client();
    AmazonEC2 createEC2Client();
}

// 리전별 Factory 구현 - 인스턴스 하나가 하나의 리전에 고정된다
public class RegionalAWSFactory implements AWSServiceFactory {
    private final AWSCredentials credentials;
    private final Regions region;

    public RegionalAWSFactory(AWSCredentials credentials, Regions region) {
        this.credentials = credentials;
        this.region = region;
    }

    @Override
    public AmazonS3 createS3Client() {
        return AmazonS3ClientBuilder.standard()
                .withCredentials(new AWSStaticCredentialsProvider(credentials))
                .withRegion(region)
                .build();
    }

    @Override
    public AmazonEC2 createEC2Client() {
        return AmazonEC2ClientBuilder.standard()
                .withCredentials(new AWSStaticCredentialsProvider(credentials))
                .withRegion(region)
                .build();
    }
    // RDS, SQS 등 다른 서비스 클라이언트도 동일한 region 필드로 생성한다
}

// 사용 예제 - 모든 클라이언트가 생성 시점에 같은 리전으로 고정됨
public class CloudService {
    private final AWSServiceFactory serviceFactory;

    public CloudService(AWSServiceFactory serviceFactory) {
        this.serviceFactory = serviceFactory;
    }

    public void migrateData() {
        AmazonS3 s3 = serviceFactory.createS3Client();
        AmazonEC2 ec2 = serviceFactory.createEC2Client();
        // s3, ec2가 항상 같은 리전을 가리키므로 교차 리전 호출이 원천 차단된다
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// 전통적인 Factory 방식
public class OrderServiceFactory {
    public static OrderService create() {
        PaymentProcessor paymentProcessor = new CreditCardProcessor();
        NotificationService notificationService = new EmailNotificationService();
        return new OrderService(paymentProcessor, notificationService);
    }
}

// 현대적인 DI 기반 Factory
@Configuration
public class OrderServiceConfiguration {
    
    @Bean
    @ConditionalOnProperty(name = "payment.type", havingValue = "credit")
    public PaymentProcessor creditCardProcessor() {
        return new CreditCardProcessor();
    }
    
    @Bean
    @ConditionalOnProperty(name = "payment.type", havingValue = "paypal")
    public PaymentProcessor paypalProcessor() {
        return new PayPalProcessor();
    }
    
    @Bean
    public OrderService orderService(PaymentProcessor paymentProcessor,
                                   NotificationService notificationService) {
        return new OrderService(paymentProcessor, notificationService);
    }
}

// 사용하는 쪽 - Factory의 복잡성이 완전히 숨겨짐
@Service
public class OrderController {
    private final OrderService orderService;  // 자동으로 주입됨
    
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// 전통적인 Factory
public interface ProcessorFactory {
    PaymentProcessor create(PaymentConfig config);
}

// 함수형 Factory
public class FunctionalFactoryExample {
    
    // 함수를 반환하는 Factory
    public static Function<PaymentConfig, PaymentProcessor> getProcessorFactory(PaymentType type) {
        switch (type) {
            case CREDIT_CARD:
                return config -> new CreditCardProcessor(config.getApiKey(), config.getEndpoint());
            case PAYPAL:
                return config -> new PayPalProcessor(config.getClientId(), config.getSecret());
            case CRYPTO:
                return config -> new CryptoProcessor(config.getWalletAddress());
            default:
                throw new IllegalArgumentException("Unsupported type: " + type);
        }
    }
    
    // Curry를 활용한 Factory
    public static Function<PaymentConfig, PaymentProcessor> createCurriedFactory(
            PaymentType type, 
            SecuritySettings security) {
        
        Function<PaymentType, Function<SecuritySettings, Function<PaymentConfig, PaymentProcessor>>> 
            curriedFactory = paymentType -> securitySettings -> config -> {
                PaymentProcessor processor = createProcessor(paymentType, config);
                return new SecurePaymentProcessorWrapper(processor, securitySettings);
            };
        
        return curriedFactory.apply(type).apply(security);
    }
    
    // 사용법
    public void processPayments() {
        Function<PaymentConfig, PaymentProcessor> factory = getProcessorFactory(PaymentType.CREDIT_CARD);
        
        List<PaymentConfig> configs = getPaymentConfigs();
        List<PaymentProcessor> processors = configs.stream()
            .map(factory)  // Factory를 map 함수로 직접 사용
            .collect(Collectors.toList());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// 타입 안전한 Generic Factory
public class TypeSafeFactory {
    
    private final Map<Class<?>, Supplier<?>> factories = new HashMap<>();
    
    // 타입 안전한 Factory 등록
    public <T> void register(Class<T> type, Supplier<T> factory) {
        factories.put(type, factory);
    }
    
    // 타입 안전한 객체 생성
    @SuppressWarnings("unchecked")
    public <T> T create(Class<T> type) {
        Supplier<T> factory = (Supplier<T>) factories.get(type);
        if (factory == null) {
            throw new IllegalArgumentException("No factory registered for type: " + type);
        }
        return factory.get();
    }
    
    // 빌더 패턴과 결합
    public static TypeSafeFactory builder() {
        return new TypeSafeFactory();
    }
    
    public <T> TypeSafeFactory with(Class<T> type, Supplier<T> factory) {
        register(type, factory);
        return this;
    }
}

// 사용 예제
public class FactoryUsage {
    public void demonstrateTypeSafety() {
        TypeSafeFactory factory = TypeSafeFactory.builder()
            .with(PaymentProcessor.class, () -> new CreditCardProcessor())
            .with(NotificationService.class, () -> new EmailNotificationService())
            .with(AuditLogger.class, () -> new DatabaseAuditLogger());
        
        // 컴파일 타임에 타입 안전성 보장
        PaymentProcessor processor = factory.create(PaymentProcessor.class);
        NotificationService notifier = factory.create(NotificationService.class);
        
        // 컴파일 에러 - 등록되지 않은 타입
        // ReportGenerator generator = factory.create(ReportGenerator.class);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// Factory 자동화를 위한 어노테이션
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FactoryProduct {
    String value();
}

// 제품 클래스에는 등록 키만 붙이면 된다 (PayPalProcessor, CryptoProcessor도 동일한 방식)
@FactoryProduct("credit-card")
public class CreditCardProcessor implements PaymentProcessor {
    // 구현
}

// 자동화된 Factory - 클래스패스 스캔으로 productMap을 채운다
public class AutoPaymentProcessorFactory {

    private static final Map<String, Class<? extends PaymentProcessor>> productMap = new HashMap<>();

    static {
        // org.reflections:reflections 라이브러리를 사용하는 클래스패스 스캔 (외부 의존성 가정)
        Reflections reflections = new Reflections("com.example.processors");
        for (Class<?> clazz : reflections.getTypesAnnotatedWith(FactoryProduct.class)) {
            if (PaymentProcessor.class.isAssignableFrom(clazz)) {
                String key = clazz.getAnnotation(FactoryProduct.class).value();
                productMap.put(key, (Class<? extends PaymentProcessor>) clazz);
            }
        }
    }

    public PaymentProcessor create(String type) {
        Class<? extends PaymentProcessor> clazz = productMap.get(type);
        if (clazz == null) {
            throw new IllegalArgumentException("Unknown payment type: " + type);
        }
        try {
            return clazz.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException("Failed to create instance", e);
        }
    }
    // 새 타입 추가 시 @FactoryProduct만 붙이면 되고 이 클래스는 수정하지 않는다
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

// 성능 벤치마크를 위한 테스트 (개념 예시 — 실제로는 JMH 등의 벤치마크 하네스로 실행해야 한다)
public class FactoryPerformanceTest {

    private static final int ITERATIONS = 1_000_000;

    // 리플렉션 기반 Factory: 앞서 정의한 AutoPaymentProcessorFactory를 그대로 사용한다
    private final AutoPaymentProcessorFactory reflectionBasedFactory = new AutoPaymentProcessorFactory();

    // 캐시된 Factory: 타입별 인스턴스를 한 번만 생성해 재사용하는 최소 구현
    private final CachedPaymentProcessorFactory cachedFactory = new CachedPaymentProcessorFactory();

    private static class CachedPaymentProcessorFactory {
        private final Map<PaymentType, PaymentProcessor> cache = new ConcurrentHashMap<>();

        PaymentProcessor create(PaymentType type) {
            return cache.computeIfAbsent(type, t -> new CreditCardProcessor());
        }
    }

    @Benchmark
    public PaymentProcessor directCreation() {
        return new CreditCardProcessor();  // 직접 생성
    }
    
    @Benchmark
    public PaymentProcessor simpleFactory() {
        return PaymentProcessorFactory.create(PaymentType.CREDIT_CARD);  // Simple Factory
    }
    
    @Benchmark
    public PaymentProcessor reflectionFactory() {
        return reflectionBasedFactory.create("credit-card");  // 리플렉션 기반
    }
    
    @Benchmark
    public PaymentProcessor cachedFactory() {
        return cachedFactory.create(PaymentType.CREDIT_CARD);  // 캐시된 Factory
    }
}

/*
예시 수치(플랫폼에 따라 다름) — 실측치도, 위 코드를 그대로 실행해 재현한 값도 아니다.
아래는 "상대적인 크기 차이"를 감 잡기 위한 참고용 수치일 뿐이며,
직접 벤치마크 결과로 인용하거나 의사결정 근거로 삼아서는 안 된다.

직접 생성:           약 5 ns/op
Simple Factory:      약 9 ns/op   (직접 생성 대비 소폭 증가)
리플렉션 Factory:    약 800 ns/op (직접 생성 대비 수백 배 — 리플렉션 오버헤드가 지배적)
캐시된 Factory:      약 12 ns/op  (최초 1회 생성 이후에는 직접 생성에 근접)

결론(방향성만 유효, 절대값은 환경마다 다름):
- 단순한 Factory 호출 자체의 오버헤드는 대체로 무시할 수준
- 리플렉션은 성능 크리티컬한 경로에서는 피하거나 캐싱과 결합해야 함
- 캐싱은 리플렉션·재생성 비용을 크게 줄이지만 상태 공유에 따른 스레드 안전성을 별도로 고려해야 함
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47