JavaScript设计模式在音乐流媒体服务中的应用与优化

class MusicFacade {
    constructor() {
        this.streamingService = { subscribed: false };
        this.musicPlayer = new MusicPlayer(); // 音乐播放器
        this.decoderFactory = new DecoderFactory(); // 解码器工厂
        this.playlists = []; // 播放列表
    }

    subscribe() {
        this.streamingService.subscribed = true;
        return "Subscribed to the music streaming service.";
    }

    playMusic(song) {
        if (this.streamingService.subscribed) {
            const decoder = this.decoderFactory.createDecoder(song.format);
            const decodeMessage = decoder.decode(song.format);
            const playMessage = this.musicPlayer.play(song);
            return `${decodeMessage}\n${playMessage}`;
        } else {
            return "You need to subscribe to the music streaming service to play music.";
        }
    }

    createPlaylist(name) {
        const playlist = new Playlist(name);
        this.playlists.push(playlist);
        return `Created playlist: ${name}`;
    }
    // ... 其他简化方法
}

// 示例使用
const musicFacade = new MusicFacade();
console.log(musicFacade.subscribe());
const song = new Song("Song Title", "Artist", "MP3");
console.log(musicFacade.playMusic(song));

// 抽象解码器策略
class Decoder {
    decode(format) {
        throw new Error("Method 'decode()' must be implemented.");
    }
}

// 具体MP3解码策略
class Mp3Decoder extends Decoder {
    decode(format) {
        return `Decoding MP3 format: ${format}...`;
    }
}

// 具体WAV解码策略
class WavDecoder extends Decoder {
    decode(format) {
        return `Decoding WAV format: ${format}...`;
    }
}

// 示例使用（通常与工厂模式结合）
const mp3Decoder = new Mp3Decoder();
console.log(mp3Decoder.decode("MP3"));

// 主题（Subject） - 音乐播放器
class MusicPlayer {
    constructor() {
        this.observers = [];
    }

    play(song) {
        const message = `Playing song: ${song.title} - ${song.artist}`;
        this.notifyObservers(); // 通知所有观察者
        return message;
    }

    registerObserver(observer) {
        this.observers.push(observer);
    }

    removeObserver(observer) {
        const index = this.observers.indexOf(observer);
        if (index !== -1) {
            this.observers.splice(index, 1);
        }
    }

    notifyObservers() {
        this.observers.forEach((observer) => observer.update());
    }
}

// 观察者（Observer） - UI更新组件
class UIObserver {
    update() {
        // UI更新逻辑，例如显示当前播放歌曲信息
        return "Updating UI: Music playback status changed.";
    }
}

// 示例使用
const player = new MusicPlayer();
const uiObserver = new UIObserver();
player.registerObserver(uiObserver);
console.log(player.play(new Song("Test Song", "Test Artist", "MP3")));

class DecoderFactory {
    createDecoder(format) {
        switch (format) {
            case "MP3":
                return new Mp3Decoder();
            case "WAV":
                return new WavDecoder();
            default:
                throw new Error(`Decoder not available for format: ${format}`);
        }
    }
}

// 示例使用
const factory = new DecoderFactory();
const mp3Decoder = factory.createDecoder("MP3");
console.log(mp3Decoder.decode("some_song.mp3"));

// 歌曲类 (叶子节点)
class Song {
    constructor(title, artist, format) {
        this.title = title;
        this.artist = artist;
        this.format = format;
    }
}

// 播放列表类 (组合节点)
class Playlist {
    constructor(name) {
        this.name = name;
        this.songs = []; // 可以包含Song对象
    }

    addSong(song) {
        this.songs.push(song);
        console.log(`Added "${song.title}" to playlist "${this.name}".`);
    }

    removeSong(song) {
        const index = this.songs.findIndex(s => s.title === song.title);
        if (index !== -1) {
            this.songs.splice(index, 1);
            console.log(`Removed "${song.title}" from playlist "${this.name}".`);
        }
    }
    // ... 其他播放列表操作
}

// 示例使用
const myPlaylist = new Playlist("My Favorites");
const song1 = new Song("Bohemian Rhapsody", "Queen", "MP3");
const song2 = new Song("Hotel California", "Eagles", "WAV");
myPlaylist.addSong(song1);
myPlaylist.addSong(song2);

// 使用EventTarget实现观察者模式
class MusicPlayerEvent extends EventTarget {
    play(song) {
        const message = `Playing song: ${song.title} - ${song.artist}`;
        // 派发自定义事件
        this.dispatchEvent(new CustomEvent('playbackStatusChange', {
            detail: {
                status: 'playing',
                songTitle: song.title
            }
        }));
        return message;
    }
}

// 监听事件
const playerWithEvents = new MusicPlayerEvent();
playerWithEvents.addEventListener('playbackStatusChange', (event) => {
    console.log(`UI Updated: ${event.detail.songTitle} is now ${event.detail.status}.`);
});

const songEvent = new Song("Event Song", "Artist", "MP3");
console.log(playerWithEvents.play(songEvent));