어댑터 패턴

Coddy Python 여정의 객체 지향 프로그래밍 섹션에 포함된 레슨. 64개 중 50번째.

어댑터 패턴을 사용하면 호환되지 않는 인터페이스를 가진 객체들이 함께 작동할 수 있습니다. 이 패턴은 기존 클래스를 클라이언트가 기대하는 새로운 인터페이스로 감싸 브리지 역할을 합니다.

서로 호환되지 않는 인터페이스를 가진 두 시스템이 있습니다:

class OldPrinter:
    def old_print(self, text):
        return f"OLD: {text}"

class NewPrinter:
    def print(self, text):
        return f"NEW: {text}"

기존 프린터는 old_print()를 사용하는 반면 새 프린터는 print()를 사용합니다.

새 인터페이스에서 기존 프린터를 작동하도록 어댑터를 만드세요:

class PrinterAdapter:
    def __init__(self, old_printer):
        self.old_printer = old_printer
    
    def print(self, text):
        # 이전 인터페이스를 새 인터페이스에 맞게 조정
        return self.old_printer.old_print(text)

어댑터는 기존 프린터를 감싸고 예상되는 인터페이스를 제공합니다.

동일한 클라이언트 코드로 두 프린터를 모두 사용하세요:

def print_document(printer, text):
    return printer.print(text)  # print() 메서드를 기대함

# 새 프린터를 직접 사용
new_printer = NewPrinter()
print(print_document(new_printer, "Hello"))

# 어댑터를 통해 이전 프린터 사용
old_printer = OldPrinter()
adapter = PrinterAdapter(old_printer)
print(print_document(adapter, "Hello"))

미디어 플레이어를 사용하는 또 다른 예제를 만들어 보세요:

class Mp3Player:
    def play_mp3(self, filename):
        return f"Playing MP3: {filename}"

class Mp4Player:
    def play_mp4(self, filename):
        return f"Playing MP4: {filename}"

class MediaAdapter:
    def __init__(self, player, audio_type):
        self.player = player
        self.audio_type = audio_type
    
    def play(self, filename):
        if self.audio_type == "mp3":
            return self.player.play_mp3(filename)
        elif self.audio_type == "mp4":
            return self.player.play_mp4(filename)

class AudioPlayer:
    def play(self, audio_type, filename):
        if audio_type == "mp3":
            return Mp3Player().play_mp3(filename)
        else:
            adapter = MediaAdapter(Mp4Player(), audio_type)
            return adapter.play(filename)

player = AudioPlayer()
print(player.play("mp3", "song.mp3"))
print(player.play("mp4", "video.mp4"))

출력:

NEW: Hello
OLD: Hello
Playing MP3: song.mp3
Playing MP4: video.mp4

핵심 요점: 어댑터 패턴은 기존 클래스를 새로운 인터페이스로 감싸 호환되지 않는 인터페이스가 함께 작동하도록 합니다. 어댑터는 예상되는 인터페이스의 호출을 래핑된 객체의 실제 인터페이스에 맞게 변환합니다. 이는 기존 코드를 수정하지 않고 레거시 코드나 서드 파티 라이브러리를 통합할 때 유용합니다.

챌린지

중급

이 과제에서는 레거시 시스템을 최신 애플리케이션 아키텍처와 통합하기 위해 Adapter 디자인 패턴을 구현합니다. Adapter 패턴은 한 인터페이스를 다른 인터페이스로 변환하는 래퍼(어댑터)를 생성하여 호환되지 않는 인터페이스를 가진 객체들이 함께 작동할 수 있도록 합니다.

여러분의 회사에는 새로운 최신 분석 플랫폼과 통합해야 하는 레거시 데이터 분석 및 시각화 시스템이 있습니다. 레거시 구성 요소의 인터페이스는 새 시스템의 인터페이스와 호환되지 않습니다. 레거시 코드를 다시 작성하는 대신(이는 위험하고 비용이 많이 들 수 있음), 여러분은 이러한 구성 요소가 새 시스템에서 작동하도록 어댑터를 만드는 작업을 맡았습니다.

다음 작업을 수행해야 합니다:

interfaces.py에 정의된 최신 인터페이스를 이해합니다(이 파일은 수정할 수 없음).
legacy_system.py의 레거시 구성 요소를 검토합니다(이 파일은 수정할 수 없음).
레거시 구성 요소가 최신 인터페이스와 호환되도록 adapters.py에 어댑터 클래스를 구현합니다.
이러한 인터페이스를 사용하는 최신 시스템을 modern_system.py에 생성합니다.

필수 출력 형식: [번역된 콘텐츠]

직접 해보기

# 필요한 모든 클래스 가져오기
from adapters import LegacyDataAnalyzerAdapter, LegacyChartGeneratorAdapter
from modern_system import AnalyticsSystem

# 종합 테스트 케이스 핸들러
test_case = input()

if test_case == "basic_adapter_test":
    # 기본 어댑터 기능 테스트
    processor = LegacyDataAnalyzerAdapter()
    data = [1, 2, 3, 4, 5]
    processor.process_data(data)
    results = processor.get_results()
    print(f"Results: {results}")

elif test_case == "visualizer_adapter_test":
    # 시각화 어댑터 테스트
    visualizer = LegacyChartGeneratorAdapter("bar")
    data = [10, 20, 30, 40, 50]
    success = visualizer.visualize(data)
    if success:
        export_success = visualizer.export_visualization("test_chart.png")
        print(f"Visualization exported: {export_success}")

elif test_case == "analytics_system_test":
    # 완전한 분석 시스템 테스트
    processor = LegacyDataAnalyzerAdapter()
    visualizer = LegacyChartGeneratorAdapter("line")
    system = AnalyticsSystem(processor, visualizer)
    
    data = [15, 25, 35, 45, 55]
    result = system.analyze_and_visualize(data, "analytics_output.png")
    print(f"System result: {result}")

elif test_case == "validation_error_test":
    # Test validation errors
    processor = LegacyDataAnalyzerAdapter()
    try:
        processor.process_data("invalid_data")
        print("Validation failed - should have raised ValueError")
    except ValueError as e:
        print(f"Validation error caught: {e}")

elif test_case == "empty_data_test":
    # 빈 데이터로 테스트
    processor = LegacyDataAnalyzerAdapter()
    try:
        processor.process_data([])
        results = processor.get_results()
        print(f"Empty data results: {results}")
    except Exception as e:
        print(f"Empty data error: {e}")

elif test_case == "chart_types_test":
    # 다양한 차트 유형 테스트
    chart_types = ["bar", "line", "pie"]
    data = [5, 15, 25, 35]
    
    for chart_type in chart_types:
        visualizer = LegacyChartGeneratorAdapter(chart_type)
        success = visualizer.visualize(data)
        print(f"{chart_type} chart created: {success}")

elif test_case == "file_extension_test":
    # 파일 확장자 처리 테스트
    visualizer = LegacyChartGeneratorAdapter()
    data = [1, 2, 3, 4]
    visualizer.visualize(data)
    
    # 다양한 파일명 형식 테스트
    filenames = ["test", "test.jpg", "test.pdf", "test.png"]
    for filename in filenames:
        success = visualizer.export_visualization(filename)
        print(f"Export '{filename}': {success}")

elif test_case == "summary_test":
    # Test analysis summary
    processor = LegacyDataAnalyzerAdapter()
    visualizer = LegacyChartGeneratorAdapter()
    system = AnalyticsSystem(processor, visualizer)
    
    data = [10, 20, 30, 40, 50, 60]
    system.analyze_and_visualize(data)
    summary = system.get_analysis_summary()
    print("Analysis Summary:")
    print(summary)

elif test_case == "mixed_data_test":
    # 혼합 숫자 데이터로 테스트
    processor = LegacyDataAnalyzerAdapter()
    data = [1.5, 2, 3.7, 4, 5.2]
    processor.process_data(data)
    results = processor.get_results()
    print(f"Mixed data results: {results}")

elif test_case == "invalid_numeric_test":
    # 잘못된 숫자 데이터로 테스트
    processor = LegacyDataAnalyzerAdapter()
    try:
        processor.process_data([1, 2, "three", 4, 5])
        print("Validation failed - should have raised ValueError")
    except ValueError as e:
        print(f"Invalid numeric data error: {e}")

elif test_case == "no_results_summary_test":
    # 결과가 없는 요약 테스트
    processor = LegacyDataAnalyzerAdapter()
    visualizer = LegacyChartGeneratorAdapter()
    system = AnalyticsSystem(processor, visualizer)
    
    summary = system.get_analysis_summary()
    print(f"No results summary: {summary}")

elif test_case == "large_dataset_test":
    # 더 큰 데이터셋으로 테스트
    processor = LegacyDataAnalyzerAdapter()
    data = list(range(1, 101))  # 1부터 100까지
    processor.process_data(data)
    results = processor.get_results()
    print(f"Large dataset - Mean: {results.get('mean', 'N/A'):.2f}")
    print(f"Large dataset - Min: {results.get('min', 'N/A')}")
    print(f"Large dataset - Max: {results.get('max', 'N/A')}")

elif test_case == "complete_workflow_test":
    # Test complete workflow with multiple operations
    processor = LegacyDataAnalyzerAdapter()
    bar_visualizer = LegacyChartGeneratorAdapter("bar")
    line_visualizer = LegacyChartGeneratorAdapter("line")
    
    data = [12, 18, 25, 32, 28, 35, 42]
    
    # 서로 다른 시각화 도구로 분석 시스템 생성
    bar_system = AnalyticsSystem(processor, bar_visualizer)
    line_system = AnalyticsSystem(LegacyDataAnalyzerAdapter(), line_visualizer)
    
    # 분석 실행
    bar_result = bar_system.analyze_and_visualize(data, "bar_chart.png")
    line_result = line_system.analyze_and_visualize(data, "line_chart.png")
    
    print("Complete workflow test completed")
    print(f"Bar chart result: {bar_result['visualization_file']}")
    print(f"Line chart result: {line_result['visualization_file']}")
    
    # 요약 가져오기
    print("Bar system summary:")
    print(bar_system.get_analysis_summary())
    print("Line system summary:")
    print(line_system.get_analysis_summary())