[디자인 패턴] 생성 패턴 - Prototype Pattern (프로토타입 패턴)

 

목차

 

 

📇 개요

프로토타입 패턴(Prototype Pattern)은 기존 객체를 복제하여 새로운 객체를 생성하는 생성 디자인 패턴이다. 즉, 원형이 되는 인스턴스를 사용해 새로운 인스턴스를 만드는 방식으로, 객체 생성 비용이 큰 경우에 효율적이다.

⭐️ 특징

• 기존 객체의 상태를 그대로 복사하여 새로운 객체를 생성한다.
• 객체 생성 과정의 복잡성을 감춘다.
• 객체 생성 비용이 큰 경우에 성능을 향상시킨다.
• 프레임워크 확장 시 구체적인 클래스 정보 없이도 객체를 생성할 수 있다.

 

👩🏻‍💻 코드로 알아보자

프로토타입 패턴을 구현하는 여러 방법을 살펴보자.

1. Cloneable 인터페이스 구현

// 1. Cloneable 인터페이스를 구현한 프로토타입 클래스
public class Shape implements Cloneable {
    private String type;
    private String color;
    
    public Shape() {
        // 기본 생성자
    }
    
    public Shape(String type, String color) {
        this.type = type;
        this.color = color;
    }
    
    // Java에서 제공하는 clone() 메서드 오버라이드
    @Override
    public Shape clone() {
        try {
            // Object.clone()은 얕은 복사(shallow copy)를 수행
            return (Shape) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    // getters and setters
    public String getType() {
        return type;
    }
    
    public void setType(String type) {
        this.type = type;
    }
    
    public String getColor() {
        return color;
    }
    
    public void setColor(String color) {
        this.color = color;
    }
    
    @Override
    public String toString() {
        return "Shape [type=" + type + ", color=" + color + "]";
    }
}

// 클라이언트 코드
public class PrototypeExample {
    public static void main(String[] args) {
        // 원본 객체 생성
        Shape originalShape = new Shape("Circle", "Red");
        System.out.println("Original: " + originalShape);
        
        // 프로토타입을 이용한 복제
        Shape clonedShape = originalShape.clone();
        System.out.println("Cloned: " + clonedShape);
        
        // 복제된 객체 수정
        clonedShape.setColor("Blue");
        System.out.println("Modified Clone: " + clonedShape);
        System.out.println("Original After Clone Modification: " + originalShape);
    }
}

2. 깊은 복사(Deep Copy) 구현

// 복잡한 내부 객체를 가진 프로토타입 클래스
public class ComplexShape implements Cloneable {
    private String name;
    private List<Point> points; // 내부 객체 참조
    
    public ComplexShape(String name) {
        this.name = name;
        this.points = new ArrayList<>();
    }
    
    public void addPoint(Point point) {
        points.add(point);
    }
    
    // 깊은 복사 구현
    @Override
    public ComplexShape clone() {
        try {
            ComplexShape cloned = (ComplexShape) super.clone();
            // 내부 List 객체도 복제
            cloned.points = new ArrayList<>();
            
            // 각 Point 객체도 복제
            for (Point point : this.points) {
                cloned.points.add(point.clone());
            }
            
            return cloned;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    // getters and setters
    
    @Override
    public String toString() {
        return "ComplexShape [name=" + name + ", points=" + points + "]";
    }
}

// 내부 객체 클래스
public class Point implements Cloneable {
    private int x;
    private int y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    @Override
    public Point clone() {
        try {
            return (Point) super.clone();
        } catch (CloneNotSupportedException e) {
            return new Point(this.x, this.y);
        }
    }
    
    // getters and setters
    
    @Override
    public String toString() {
        return "(" + x + "," + y + ")";
    }
}

3. 직렬화를 이용한 복제

import java.io.*;

public class SerializableShape implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String type;
    private String color;
    
    public SerializableShape(String type, String color) {
        this.type = type;
        this.color = color;
    }
    
    // 직렬화를 통한 깊은 복사
    public SerializableShape deepCopy() {
        try {
            // 객체를 바이트 스트림으로 직렬화
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            
            // 바이트 스트림에서 객체로 역직렬화
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (SerializableShape) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    // getters and setters
    
    @Override
    public String toString() {
        return "SerializableShape [type=" + type + ", color=" + color + "]";
    }
}

4. 복제 생성자/팩토리 메서드 사용

public class Product {
    private String name;
    private double price;
    private List<String> features;
    
    // 기본 생성자
    public Product(String name, double price) {
        this.name = name;
        this.price = price;
        this.features = new ArrayList<>();
    }
    
    // 복제 생성자
    public Product(Product source) {
        this.name = source.name;
        this.price = source.price;
        // 깊은 복사
        this.features = new ArrayList<>(source.features);
    }
    
    // 정적 팩토리 메서드
    public static Product copyOf(Product source) {
        return new Product(source);
    }
    
    public void addFeature(String feature) {
        features.add(feature);
    }
    
    // getters and setters
    
    @Override
    public String toString() {
        return "Product [name=" + name + ", price=" + price + ", features=" + features + "]";
    }
}

// 사용 예
Product original = new Product("Smartphone", 999.99);
original.addFeature("5G");
original.addFeature("OLED Display");

// 복제 생성자 사용
Product clone1 = new Product(original);

// 정적 팩토리 메서드 사용
Product clone2 = Product.copyOf(original);

5. 스프링 프레임워크의 프로토타입 빈 스코프

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class PrototypeBean {
    private String property;
    
    public PrototypeBean() {
        // 초기화 작업 (비용이 큰 작업 가정)
        System.out.println("PrototypeBean instance created");
    }
    
    // getters and setters
}

// 사용 예 (스프링 컨텍스트에서)
@Autowired
private ApplicationContext context;

public void usePrototypes() {
    // 매번 새로운 인스턴스 생성
    PrototypeBean bean1 = context.getBean(PrototypeBean.class);
    PrototypeBean bean2 = context.getBean(PrototypeBean.class);
    
    // bean1과 bean2는 서로 다른 인스턴스
    System.out.println(bean1 == bean2); // false
}

 

 

☘️ 장/단점

✅ 장점

1. 복잡한 객체 생성 비용 절감
   • 객체 생성 비용이 큰 경우 이미 생성된 객체를 복제하는 것이 효율적이다.
   • 데이터베이스 조회, 네트워크 요청, 복잡한 계산 등을 피할 수 있다.
2. 구체적인 클래스에 의존하지 않는 객체 생성
   • 클라이언트가 객체의 구체적인 클래스를 몰라도 객체를 생성할 수 있다.
   • 다형성을 활용한 유연한 설계가 가능하다.
3. 복잡한 초기화 코드 제거
   • 객체를 처음부터 생성하는 대신 이미 초기화된 상태를 복사하여 사용한다.
   • 초기화 로직을 중복해서 작성할 필요가 없다.
4. 설정이나 상태가 비슷한 객체 생성
   • 기존 객체를 약간만 수정하여 유사한 여러 객체를 효율적으로 생성할 수 있다.
   • 반복적인 객체 생성 코드를 줄일 수 있다.

❌ 단점

1. 깊은 복사의 구현 복잡성
   • 객체가 순환 참조나 복잡한 참조 관계를 가질 경우 깊은 복사 구현이 어렵다.
   • 특히 복잡한 객체 그래프에서 모든 객체를 올바르게 복제하기 어렵다.
2. 생성자 호출 회피
   • 복제 과정에서 객체의 생성자가 호출되지 않을 수 있다.
   • 이로 인해 객체 생성 과정을 추적하거나 디버깅하기 어려울 수 있다.
3. 깊은 복사와 얕은 복사의 선택
   • 상황에 따라 깊은 복사가 필요할지 얕은 복사가 적절할지 결정해야 한다.
   • 잘못된 선택은 예상치 못한 버그를 발생시킬 수 있다.
4. 복제 동작 정의의 어려움
   • 일부 객체의 경우 어떤 상태를 복제해야 하고 어떤 상태는 유지해야 하는지 정의하기 어렵다.
   • 예를 들어 ID나 타임스탬프 같은 값은 복제되지 않아야 할 수 있다.

 

💡 자바/스프링 프레임워크에서의 프로토타입

1. 자바의 Cloneable 인터페이스

Java API에서는 Cloneable 인터페이스와 Object.clone() 메서드를 통해 프로토타입 패턴을 지원한다.

public class CloneableExample implements Cloneable {
    private int id;
    private String name;
    
    // 얕은 복사 구현
    @Override
    public CloneableExample clone() throws CloneNotSupportedException {
        return (CloneableExample) super.clone();
    }
}

2. 스프링의 프로토타입 빈 스코프

스프링 프레임워크에서는 빈 스코프를 통해 프로토타입 패턴을 지원한다.

import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.stereotype.Component;

// 1. 애노테이션으로 프로토타입 스코프 지정
@Component
@Scope("prototype")
public class PrototypeComponent {
    // 매번 새 인스턴스 생성
}

// 2. 메서드 레벨에서 프로토타입 빈 정의
@Configuration
public class AppConfig {
    @Bean
    @Scope("prototype")
    public PrototypeBean prototypeBean() {
        return new PrototypeBean();
    }
}

// 3. XML 구성으로 프로토타입 빈 정의
<!-- applicationContext.xml -->
<bean id="prototypeBean" class="com.example.PrototypeBean" scope="prototype"/>

3. 스프링의 ApplicationContext와 프로토타입 빈

@Service
public class SomeService {
    private final ApplicationContext context;
    
    @Autowired
    public SomeService(ApplicationContext context) {
        this.context = context;
    }
    
    public void doSomething() {
        // 필요할 때마다 새 인스턴스 획득
        PrototypeBean bean = context.getBean(PrototypeBean.class);
        bean.process();
    }
}

4. 프로토타입 빈을 싱글톤 빈에 주입하는 문제

@Service // 기본적으로 싱글톤 스코프
public class SingletonService {
    // 주의: 이렇게 주입하면 항상 같은 프로토타입 인스턴스 사용
    @Autowired
    private PrototypeBean prototypeBean; // 한 번만 주입됨
    
    // 해결책: ObjectFactory 사용
    @Autowired
    private ObjectFactory<PrototypeBean> prototypeBeanFactory;
    
    public void correctWay() {
        // 매번 새 인스턴스 획득
        PrototypeBean bean = prototypeBeanFactory.getObject();
        bean.process();
    }
}

 

📚 실제 사용 사례

1. 자바의 Object.clone()
   • Java 표준 라이브러리에서 제공하는 기본적인 프로토타입 메커니즘
   • 예: ArrayList, HashMap 등 컬렉션 복제
2. 스프링 프레임워크의 프로토타입 빈
   • 스프링에서 빈을 프로토타입 스코프로 정의
   • 예: 사용자별 설정, 요청별 객체 생성
3. 디자인 시스템의 UI 컴포넌트
   • 기본 컴포넌트를 복제하여 다양한 스타일의 컴포넌트 생성
   • 예: 버튼, 카드, 폼 요소 등의 템플릿
4. 게임 개발의 객체 생성
   • 기본 게임 객체를 복제하여 다양한 인스턴스 생성
   • 예: 적 캐릭터, 아이템, 장애물 등
5. 문서 템플릿 시스템
   • 기본 문서를 복제하여 새로운 문서 생성
   • 예: 워드 프로세서의 템플릿, 보고서 양식
6. 캐싱 시스템
   • 데이터베이스에서 가져온 객체를 캐시하고 복제하여 사용
   • 예: 읽기 전용 데이터 복제
7. 멀티스레드 환경의 안전한 객체 복제
   • 공유 객체의 스냅샷을 만들어 각 스레드에서 안전하게 사용
   • 예: 불변 객체의 복제본 생성
8. 테스트 픽스처 생성
   • 테스트에 필요한 객체 상태를 미리 설정하고 복제해서 사용
   • 예: JUnit 테스트의 기본 데이터 설정
9. 도메인 객체 생성
   • 기본 도메인 객체를 템플릿으로 사용하여 유사한 객체 생성
   • 예: 주문, 고객, 제품 등의 기본 템플릿
10. 설정 객체 복제
    • 기본 설정을 복제하여 약간의 수정만으로 새로운 설정 생성
    • 예: 애플리케이션 설정, 사용자 프로필

 

📌 정리

프로토타입 패턴은 기존 객체를 복제하여 새로운 객체를 생성하는 디자인 패턴이다.

이 패턴은 객체 생성 비용이 큰 경우 성능을 향상시키고, A 구체적인 클래스 정보 없이도 객체를 생성할 수 있게 해준다. 하지만 깊은 복사 구현의 복잡성, 생성자 호출 회피, 복제 동작 정의의 어려움 등의 단점이 있다.

✅ 언제 사용하면 좋을까?

• 객체 생성 비용이 클 때 (DB 조회, 네트워크 요청, 복잡한 계산 등)
• 비슷한 객체를 다양한 상태로 생성해야 할 때
• 런타임에 클래스를 동적으로 추가하거나 제거해야 할 때
• 객체의 구체적인 타입을 알지 못하거나 의존하고 싶지 않을 때
• 팩토리 메서드 패턴으로는 너무 많은 서브클래스가 필요할 때

❌ 언제 피해야 할까?

• 객체의 내부 상태가 매우 복잡하거나 순환 참조가 있을 때
• 객체의 생성 비용이 낮고 간단할 때
• 객체가 공유 자원이나 외부 리소스에 의존할 때
• 객체의 독립성이 중요한 경우

 

📋 참고

• https://refactoring.guru/ko/design-patterns/prototype