Golang外观模式简化复杂子系统调用

MediaConverterFacade

Convert

package main

import "fmt"

// --- 复杂的子系统组件 ---

type VideoEncoder struct{}

func (ve *VideoEncoder) EncodeVideo(filePath string, codec string) error {
    fmt.Printf("VideoEncoder: Encoding video %s with codec %s...\n", filePath, codec)
    // 模拟编码逻辑
    return nil
}

type AudioEncoder struct{}

func (ae *AudioEncoder) EncodeAudio(filePath string, format string) error {
    fmt.Printf("AudioEncoder: Encoding audio %s to format %s...\n", filePath, format)
    // 模拟编码逻辑
    return nil
}

type SubtitleProcessor struct{}

func (sp *SubtitleProcessor) ExtractSubtitles(filePath string) ([]string, error) {
    fmt.Printf("SubtitleProcessor: Extracting subtitles from %s...\n", filePath)
    // 模拟字幕提取
    return []string{"Subtitle 1", "Subtitle 2"}, nil
}

type FileMuxer struct{}

func (fm *FileMuxer) MuxFiles(videoFile, audioFile string, subtitles []string, outputFile string) error {
    fmt.Printf("FileMuxer: Muxing video (%s), audio (%s), and %d subtitles into %s...\n", videoFile, audioFile, len(subtitles), outputFile)
    // 模拟文件合成
    return nil
}

// --- 外观（Facade） ---

// MediaConverterFacade 提供了统一的接口来处理媒体转换
type MediaConverterFacade struct {
    videoEncoder    *VideoEncoder
    audioEncoder    *AudioEncoder
    subtitleProcessor *SubtitleProcessor
    fileMuxer       *FileMuxer
}

// NewMediaConverterFacade 创建一个新的媒体转换外观实例
func NewMediaConverterFacade() *MediaConverterFacade {
    return &MediaConverterFacade{
        videoEncoder:    &VideoEncoder{},
        audioEncoder:    &AudioEncoder{},
        subtitleProcessor: &SubtitleProcessor{},
        fileMuxer:       &FileMuxer{},
    }
}

// ConvertToMP4 提供一个简化的接口来将给定文件转换为MP4
func (mcf *MediaConverterFacade) ConvertToMP4(inputFile string, outputFile string) error {
    fmt.Printf("\n--- MediaConverterFacade: Starting MP4 conversion for %s ---\n", inputFile)

    // 模拟复杂的转换流程
    err := mcf.videoEncoder.EncodeVideo(inputFile, "H.264")
    if err != nil {
        return fmt.Errorf("video encoding failed: %w", err)
    }

    err = mcf.audioEncoder.EncodeAudio(inputFile, "AAC")
    if err != nil {
        return fmt.Errorf("audio encoding failed: %w", err)
    }

    subtitles, err := mcf.subtitleProcessor.ExtractSubtitles(inputFile)
    if err != nil {
        return fmt.Errorf("subtitle extraction failed: %w", err)
    }

    // 假设编码后生成了临时文件，这里简化为直接使用原始文件名
    err = mcf.fileMuxer.MuxFiles(inputFile+"_encoded_video", inputFile+"_encoded_audio", subtitles, outputFile)
    if err != nil {
        return fmt.Errorf("file muxing failed: %w", err)
    }

    fmt.Printf("--- MediaConverterFacade: MP4 conversion for %s completed successfully to %s ---\n", inputFile, outputFile)
    return nil
}

func main() {
    converter := NewMediaConverterFacade()
    err := converter.ConvertToMP4("input.mov", "output.mp4")
    if err != nil {
        fmt.Println("Conversion failed:", err)
    }

    fmt.Println("\n--- Client trying to do it manually (avoid this!) ---")
    // 想象一下如果不用外观模式，客户端代码会是多么复杂和脆弱
    // videoEnc := &VideoEncoder{}
    // audioEnc := &AudioEncoder{}
    // subProc := &SubtitleProcessor{}
    // muxer := &FileMuxer{}
    //
    // videoEnc.EncodeVideo("input.mov", "H.264")
    // audioEnc.EncodeAudio("input.mov", "AAC")
    // subs, _ := subProc.ExtractSubtitles("input.mov")
    // muxer.MuxFiles("input.mov_encoded_video", "input.mov_encoded_audio", subs, "output_manual.mp4")
    // ... 这还不包括错误处理和更复杂的逻辑
}

MediaConverterFacade

ConvertToMP4

converter.ConvertToMP4(...)

MediaConverterFacade

// 定义子系统接口
type VideoEncoderI interface {
    EncodeVideo(filePath string, codec string) error
}

// MediaConverterFacade 注入接口
type MediaConverterFacade struct {
    videoEncoder VideoEncoderI // 使用接口类型
    // ... 其他子系统
}

// NewMediaConverterFacade 构造函数接受接口实现
func NewMediaConverterFacade(ve VideoEncoderI /*, ... */) *MediaConverterFacade {
    return &MediaConverterFacade{
        videoEncoder: ve,
        // ...
    }
}

MediaConverterFacade

mock

stub

VideoEncoderI