JavaScript设计模式实践：构建模块化音乐流媒体服务

class Song {
    constructor(title, artist, format) {
      this.title = title;
      this.artist = artist;
      this.format = format; // 例如 "MP3", "WAV"
    }
}

// Decoder.js (策略模式 - 抽象策略)
class Decoder {
    decode(format) {
      return `Decoding ${format} format...`;
    }
}

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

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

// DecoderFactory.js (工厂模式)
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}`);
      }
    }
}

// MusicPlayer.js (观察者模式 - 主题/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) => console.log(observer.update()));
    }
}

// Observer.js (观察者模式 - 观察者/Observer)
class Observer {
    constructor() {
      this.subject = null;
    }

    setSubject(subject) {
      this.subject = subject;
      this.subject.registerObserver(this); // 注册自身为观察者
    }

    update() {
      // 实际的UI更新逻辑或状态处理逻辑将在此处实现
      return "Updating UI...";
    }
}

// Playlist.js (组合模式)
class Playlist {
    constructor(name) {
      this.name = name;
      this.songs = []; // 包含歌曲的列表
    }

    addSong(song) {
      this.songs.push(song);
    }

    removeSong(song) {
      const index = this.songs.findIndex(
        (s) => s.title === song.title && s.artist === song.artist
      );
      if (index !== -1) {
        this.songs.splice(index, 1);
      }
    }
}

// MusicFacade.js (门面模式)
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.";
    }

    unsubscribe() {
      this.streamingService.subscribed = false;
      return "Unsubscribed from 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}`;
    }

    addSongToPlaylist(song, playlistName) {
      const playlist = this.playlists.find((p) => p.name === playlistName);
      if (playlist) {
        playlist.addSong(song);
        return `Added song to playlist: ${playlistName}`;
      } else {
        return `Playlist not found: ${playlistName}`;
      }
    }

    removeSongFromPlaylist(song, playlistName) {
      const playlist = this.playlists.find((p) => p.name === playlistName);
      if (playlist) {
        playlist.removeSong(song);
        return `Removed song from playlist: ${playlistName}`;
      } else {
        return `Playlist not found: ${playlistName}`;
      }
    }
}

const musicFacade = new MusicFacade();
console.log(musicFacade.subscribe()); // 订阅服务

const observer = new Observer();
const song = new Song("Song Title", "Artist", "MP3");
observer.setSubject(musicFacade.musicPlayer); // 将观察者注册到音乐播放器

console.log(musicFacade.playMusic(song)); // 播放音乐
console.log(musicFacade.createPlaylist("My Playlist")); // 创建播放列表
console.log(musicFacade.addSongToPlaylist(song, "My Playlist")); // 添加歌曲到播放列表
console.log(musicFacade.removeSongFromPlaylist(song, "My Playlist")); // 从播放列表移除歌曲
console.log(musicFacade.unsubscribe()); // 取消订阅