Special application scenarios of the Multiton pattern

Special Application Scenarios of the Multiton Pattern

The Multiton pattern is an extension of the Singleton pattern, allowing a class to have multiple instances, each with a unique identifier. Unlike the Singleton pattern, the Multiton pattern does not restrict the number of class instances but manages multiple instances through key-value pairs. This pattern is particularly useful in scenarios where multiple independent instances need to be created and managed based on specific conditions.

Basic Implementation of the Multiton Pattern

In JavaScript, the Multiton pattern can be implemented using an object to store instances and unique keys to access them. Here is a basic implementation of the Multiton pattern:

class Multiton {
  static instances = {};

  constructor(key) {
    if (Multiton.instances[key]) {
      return Multiton.instances[key];
    }
    this.key = key;
    Multiton.instances[key] = this;
  }

  static getInstance(key) {
    return Multiton.instances[key] || new Multiton(key);
  }
}

// Usage example
const instance1 = Multiton.getInstance('key1');
const instance2 = Multiton.getInstance('key2');
const instance3 = Multiton.getInstance('key1');

console.log(instance1 === instance2); // false
console.log(instance1 === instance3); // true

Application of the Multiton Pattern in Configuration Management

The Multiton pattern is particularly suitable for managing configurations across different environments. For example, an application might have three environments—development, testing, and production—each with its own configuration:

class EnvironmentConfig {
  static configs = {};

  constructor(env) {
    if (EnvironmentConfig.configs[env]) {
      return EnvironmentConfig.configs[env];
    }
    
    this.env = env;
    this.loadConfig();
    EnvironmentConfig.configs[env] = this;
  }

  loadConfig() {
    switch (this.env) {
      case 'development':
        this.apiUrl = 'http://dev.api.example.com';
        this.debug = true;
        break;
      case 'production':
        this.apiUrl = 'https://api.example.com';
        this.debug = false;
        break;
      default:
        throw new Error(`Unknown environment: ${this.env}`);
    }
  }

  static getConfig(env) {
    return EnvironmentConfig.configs[env] || new EnvironmentConfig(env);
  }
}

// Usage example
const devConfig = EnvironmentConfig.getConfig('development');
const prodConfig = EnvironmentConfig.getConfig('production');
const sameDevConfig = EnvironmentConfig.getConfig('development');

console.log(devConfig === sameDevConfig); // true
console.log(devConfig.apiUrl); // 'http://dev.api.example.com'

Application of the Multiton Pattern in UI Component Management

In front-end development, the Multiton pattern can be used to manage UI components of the same type but with different instances. For example, an application might have multiple modals, each with a unique ID:

class Modal {
  static modals = {};

  constructor(id) {
    if (Modal.modals[id]) {
      return Modal.modals[id];
    }
    
    this.id = id;
    this.isOpen = false;
    Modal.modals[id] = this;
  }

  open() {
    this.isOpen = true;
    console.log(`Modal ${this.id} opened`);
  }

  close() {
    this.isOpen = false;
    console.log(`Modal ${this.id} closed`);
  }

  static getModal(id) {
    return Modal.modals[id] || new Modal(id);
  }
}

// Usage example
const loginModal = Modal.getModal('login');
const registerModal = Modal.getModal('register');
const sameLoginModal = Modal.getModal('login');

loginModal.open(); // "Modal login opened"
registerModal.open(); // "Modal register opened"
console.log(loginModal === sameLoginModal); // true

Application of the Multiton Pattern in Cache Management

The Multiton pattern can be used to implement different types of cache managers. For example, an application might need different caches for user data, product data, etc.:

class CacheManager {
  static caches = {};

  constructor(cacheType) {
    if (CacheManager.caches[cacheType]) {
      return CacheManager.caches[cacheType];
    }
    
    this.cacheType = cacheType;
    this.data = new Map();
    CacheManager.caches[cacheType] = this;
  }

  set(key, value) {
    this.data.set(key, value);
  }

  get(key) {
    return this.data.get(key);
  }

  static getCache(cacheType) {
    return CacheManager.caches[cacheType] || new CacheManager(cacheType);
  }
}

// Usage example
const userCache = CacheManager.getCache('user');
const productCache = CacheManager.getCache('product');
const sameUserCache = CacheManager.getCache('user');

userCache.set('user1', { name: 'Alice', age: 25 });
productCache.set('product1', { name: 'Laptop', price: 999 });

console.log(userCache.get('user1')); // { name: 'Alice', age: 25 }
console.log(userCache === sameUserCache); // true

Application of the Multiton Pattern in Game Development

In game development, the Multiton pattern can be used to manage different types of game characters or scenes. For example, a role-playing game might have various monster types:

class Monster {
  static monsters = {};

  constructor(type) {
    if (Monster.monsters[type]) {
      return Monster.monsters[type];
    }
    
    this.type = type;
    this.loadStats();
    Monster.monsters[type] = this;
  }

  loadStats() {
    switch (this.type) {
      case 'goblin':
        this.health = 50;
        this.attack = 10;
        break;
      case 'troll':
        this.health = 100;
        this.attack = 20;
        break;
      default:
        throw new Error(`Unknown monster type: ${this.type}`);
    }
  }

  static getMonster(type) {
    return Monster.monsters[type] || new Monster(type);
  }
}

// Usage example
const goblin1 = Monster.getMonster('goblin');
const troll1 = Monster.getMonster('troll');
const goblin2 = Monster.getMonster('goblin');

console.log(goblin1.health); // 50
console.log(troll1.attack); // 20
console.log(goblin1 === goblin2); // true

Multiton Pattern and Memory Management

While the Multiton pattern provides convenient instance management, it is important to be mindful of memory leaks. When certain instances are no longer needed, a cleanup mechanism should be provided:

class ResourceManager {
  static resources = {};

  constructor(resourceId) {
    if (ResourceManager.resources[resourceId]) {
      return ResourceManager.resources[resourceId];
    }
    
    this.resourceId = resourceId;
    this.loadResource();
    ResourceManager.resources[resourceId] = this;
  }

  loadResource() {
    console.log(`Loading resource ${this.resourceId}`);
    // Simulate resource loading
    this.data = `Data for ${this.resourceId}`;
  }

  static getResource(resourceId) {
    return ResourceManager.resources[resourceId] || new ResourceManager(resourceId);
  }

  static releaseResource(resourceId) {
    if (ResourceManager.resources[resourceId]) {
      console.log(`Releasing resource ${resourceId}`);
      delete ResourceManager.resources[resourceId];
    }
  }
}

// Usage example
const res1 = ResourceManager.getResource('image1');
const res2 = ResourceManager.getResource('image2');

ResourceManager.releaseResource('image1');
const res1Again = ResourceManager.getResource('image1'); // Will reload

Variant of the Multiton Pattern: Limited Multiton

Sometimes, we need to limit the number of instances of a certain type. In such cases, the Limited Multiton pattern can be used. For example, to limit the size of a database connection pool:

class DatabaseConnection {
  static pool = {};
  static maxConnections = 3;
  static connectionCount = 0;

  constructor(connectionName) {
    if (DatabaseConnection.pool[connectionName]) {
      return DatabaseConnection.pool[connectionName];
    }
    
    if (DatabaseConnection.connectionCount >= DatabaseConnection.maxConnections) {
      throw new Error('Maximum number of connections reached');
    }
    
    this.connectionName = connectionName;
    this.connect();
    DatabaseConnection.pool[connectionName] = this;
    DatabaseConnection.connectionCount++;
  }

  connect() {
    console.log(`Establishing connection: ${this.connectionName}`);
    // Simulate connection establishment
    this.connected = true;
  }

  static getConnection(connectionName) {
    return DatabaseConnection.pool[connectionName] || new DatabaseConnection(connectionName);
  }

  static releaseConnection(connectionName) {
    if (DatabaseConnection.pool[connectionName]) {
      console.log(`Releasing connection: ${connectionName}`);
      DatabaseConnection.pool[connectionName].connected = false;
      delete DatabaseConnection.pool[connectionName];
      DatabaseConnection.connectionCount--;
    }
  }
}

// Usage example
try {
  const conn1 = DatabaseConnection.getConnection('conn1');
  const conn2 = DatabaseConnection.getConnection('conn2');
  const conn3 = DatabaseConnection.getConnection('conn3');
  const conn4 = DatabaseConnection.getConnection('conn4'); // Throws an error
} catch (e) {
  console.error(e.message); // "Maximum number of connections reached"
}