Le Basi 🌟
Introduzione al Pattern Singleton
Immagina un supereroe unico, che può esistere solo in un singolo esemplare nell'universo. Questo è esattamente il pattern Singleton! 🦸♂️
Perché abbiamo bisogno di un eroe unico? 🤔
Ecco alcuni scenari comuni:
- 🎮 Un videogioco con più tabelle dei punteggi... che confusione!
- 🏦 Più connessioni allo stesso database... che spreco di risorse!
- ⚙️ Configurazioni multiple diverse... è la porta aperta al caos!
I Superpoteri del Singleton
- 💪 Forza dell'Unicità: Una sola istanza, come un solo Batman per Gotham
- 🌟 Visione Globale: Accessibile ovunque, come il Bat-Segnale nel cielo
- 🎯 Precisione: Un solo punto di verità, come l'unico anello di Sauron
Implementazione Base
Il codice del nostro eroe
1class Logger {
2 private static instance: Logger;
3 private logCount: number = 0;
4
5 private constructor() {
6 console.log('🚀 Logger si risveglia...');
7 }
8
9 public static getInstance(): Logger {
10 if (!Logger.instance) {
11 Logger.instance = new Logger();
12 }
13 return Logger.instance;
14 }
15
16 public log(message: string): void {
17 this.logCount++;
18 console.log(`📝 [Log #${this.logCount}] ${message}`);
19 }
20
21 public getStats(): string {
22 return `📊 Totale log: ${this.logCount}`;
23 }
24}
Utilizzo Semplice
1const logger = Logger.getInstance();
2logger.log('Il nostro eroe è pronto!');
3console.log(logger.getStats());
Tecniche Avanzate 🚀
Singleton Thread-Safe
In un ambiente multi-thread, il nostro eroe ha bisogno di un'armatura extra! Ecco un'implementazione thread-safe:
1class ThreadSafeLogger {
2 private static instance: ThreadSafeLogger;
3 private static instanceLock = false;
4 private logs: string[] = [];
5
6 private constructor() {}
7
8 public static getInstance(): ThreadSafeLogger {
9 if (!ThreadSafeLogger.instanceLock) {
10 ThreadSafeLogger.instanceLock = true;
11 if (!ThreadSafeLogger.instance) {
12 ThreadSafeLogger.instance = new ThreadSafeLogger();
13 }
14 ThreadSafeLogger.instanceLock = false;
15 }
16 return ThreadSafeLogger.instance;
17 }
18}
Singleton con Inizializzazione Lazy 🦥
1class LazyLogger {
2 private static instance: LazyLogger;
3 private config: object;
4
5 private constructor(config: object) {
6 this.config = config;
7 }
8
9 public static getInstance(config?: object): LazyLogger {
10 if (!LazyLogger.instance && config) {
11 LazyLogger.instance = new LazyLogger(config);
12 }
13 if (!LazyLogger.instance) {
14 throw new Error(
15 'Logger necessita di configurazione alla prima inizializzazione!',
16 );
17 }
18 return LazyLogger.instance;
19 }
20}
Singleton con Reset per i Test 🧪
1class TestableLogger {
2 private static instance: TestableLogger;
3
4 private constructor() {}
5
6 public static getInstance(): TestableLogger {
7 if (!TestableLogger.instance) {
8 TestableLogger.instance = new TestableLogger();
9 }
10 return TestableLogger.instance;
11 }
12
13 // Metodo speciale per i test
14 public static resetInstance(): void {
15 TestableLogger.instance = null;
16 }
17}
Singleton Generico 🎭
1class GenericSingleton<T> {
2 private static instances: Map<string, any> = new Map();
3
4 protected constructor() {}
5
6 public static getInstance<T>(this: new () => T): T {
7 const className = this.name;
8 if (!GenericSingleton.instances.has(className)) {
9 GenericSingleton.instances.set(className, new this());
10 }
11 return GenericSingleton.instances.get(className);
12 }
13}
14
15// Utilizzo
16class UserService extends GenericSingleton<UserService> {
17 public getUsers() {
18 return ['user1', 'user2'];
19 }
20}
21
22class ConfigService extends GenericSingleton<ConfigService> {
23 public getConfig() {
24 return { api: 'url' };
25 }
26}
Anti-Pattern e Trappole da Evitare ⚠️
- Accoppiamento Forte
1// Da evitare ❌
2class BadSingleton {
3 public static getInstance() {
4 // Codice...
5 }
6 public doDirectDatabaseOperation() {
7 // Operazione diretta sul DB
8 }
9}
10
11// Preferire ✅
12interface DatabaseOperation {
13 execute(): void;
14}
15
16class GoodSingleton {
17 public static getInstance() {
18 // Codice...
19 }
20 public executeOperation(operation: DatabaseOperation) {
21 operation.execute();
22 }
23}
- Stato Globale Mutabile
1// Da evitare ❌
2class MutableSingleton {
3 private static instance: MutableSingleton;
4 public globalState: any = {};
5}
6
7// Preferire ✅
8class ImmutableSingleton {
9 private static instance: ImmutableSingleton;
10 private state: Readonly<any>;
11
12 public getState(): Readonly<any> {
13 return this.state;
14 }
15}
Pattern Complementari 🤝
Factory + Singleton
1interface Logger {
2 log(message: string): void;
3}
4
5class LoggerFactory {
6 private static instance: LoggerFactory;
7 private loggers: Map<string, Logger> = new Map();
8
9 private constructor() {}
10
11 public static getInstance(): LoggerFactory {
12 if (!LoggerFactory.instance) {
13 LoggerFactory.instance = new LoggerFactory();
14 }
15 return LoggerFactory.instance;
16 }
17
18 public getLogger(type: 'console' | 'file'): Logger {
19 if (!this.loggers.has(type)) {
20 this.loggers.set(type, this.createLogger(type));
21 }
22 return this.loggers.get(type);
23 }
24
25 private createLogger(type: 'console' | 'file'): Logger {
26 // Creazione del logger specifico
27 return type === 'console' ? new ConsoleLogger() : new FileLogger();
28 }
29}
Sfida Avanzata 🎯
Crea un Singleton che:
- Sia thread-safe
- Utilizzi l'inizializzazione lazy
- Permetta il reset per i test
- Integri un sistema di versionamento
Per Concludere 🎬
Il Singleton è un pattern potente ma richiede riflessione nella sua implementazione. La versione base è sufficiente per casi semplici, ma le versioni avanzate offrono maggiore robustezza e flessibilità per applicazioni complesse.
Consigli Pro 💡
- Usa l'inizializzazione lazy per le risorse costose
- Pensa sempre alla testabilità
- Preferisci l'iniezione delle dipendenze quando possibile
- Documenta bene i casi d'uso dei tuoi Singleton
Esercizi Pratici 🎮
- Implementa un Singleton per gestire le configurazioni di un'applicazione
- Crea un Singleton thread-safe con una coda di messaggi
- Sviluppa un sistema di cache utilizzando il pattern Singleton
Buon coding! 🚀
