Praktyczne Wzorce Projektowe w Go i Node.js: Wzorzec Singleton w Go i Node.js

Wzorce projektowe to sprawdzone rozwiązania typowych problemów, które pojawiają się w inżynierii oprogramowania. W kontekście Go i Node.js, wzorce te mogą znacznie ułatwić tworzenie systemów rozproszonych, szczególnie tych z wymaganiami na ultra-niskie opóźnienia. Warto zwrócić uwagę na kilka kluczowych wzorców, takich jak Singleton, Factory, Observer oraz Mediator. Każdy z nich ma swoje zastosowanie w kontekście asynchronicznych operacji, co jest istotne w Node.js, oraz w zarządzaniu współbieżnością w Go. Zastosowanie wzorców projektowych nie tylko poprawia czytelność kodu, ale także ułatwia jego testowanie i utrzymanie.

Wzorzec Singleton jest użyteczny w sytuacjach, gdy należy zapewnić istnienie tylko jednej instancji danej klasy, szczególnie w kontekście zarządzania zasobami. W Go możemy łatwo zaimplementować ten wzorzec, używając pakietu sync, aby zapewnić bezpieczeństwo wątkowe. Oto prosty przykład:

type singleton struct {}
var instance *singleton
var once sync.Once

func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{}
    })
    return instance
}

W Node.js możemy wykorzystać moduły jako pojedyncze instancje. Przykład implementacji:

class Singleton {
    constructor() {
        if (!Singleton.instance) {
            Singleton.instance = this;
        }
        return Singleton.instance;
    }
}
const instance1 = new Singleton();
const instance2 = new Singleton();
console.log(instance1 === instance2); // true

Przykłady te pokazują, jak wzorzec Singleton ułatwia zarządzanie instancjami.

grono.zgora.pl

Wzorzec Factory jest szczególnie przydatny w systemach, gdzie możemy potrzebować różnych typów obiektów w zależności od warunków. W Go możemy stworzyć interfejs oraz różne implementacje:

type Product interface {
    DoSomething()
}

type ConcreteProductA struct {}
func (c *ConcreteProductA) DoSomething() { /* ... */ }

type ConcreteProductB struct {}
func (c *ConcreteProductB) DoSomething() { /* ... */ }

func Factory(method string) Product {
    switch method {
    case "A":
        return &ConcreteProductA{}
    case "B":
        return &ConcreteProductB{}
    }
    return nil
}

W Node.js możemy użyć podobnego podejścia:

class ProductA {
    doSomething() { /* ... */ }
}
class ProductB {
    doSomething() { /* ... */ }
}

function factory(method) {
    switch (method) {
        case 'A':
            return new ProductA();
        case 'B':
            return new ProductB();
    }
}

Wzorzec ten pozwala na elastyczne tworzenie obiektów w oparciu o wymagania systemu.

Node.js jest zbudowany w oparciu o model asynchroniczny, co czyni go idealnym do budowy aplikacji o ultra-niskich opóźnieniach. Kluczowym elementem jest zrozumienie, jak działa pętla zdarzeń oraz jak używać promes i async/await. Typowe błędy to:

• Zapominanie o obsłudze błędów w promesach, co może prowadzić do trudnych do zdiagnozowania problemów.
• Blokowanie pętli zdarzeń przez długoterminowe operacje, co opóźnia obsługę innych zadań.
• Niewłaściwe używanie callbacków, co prowadzi do tzw. "callback hell".

Przykład poprawnej obsługi asynchroniczności:

async function fetchData() {
    try {
        const response = await fetch(url);
        const data = await response.json();
        return data;
    } catch (error) {
        console.error(error);
    }
}

Dzięki stosowaniu async/await kod staje się bardziej czytelny i łatwiejszy w utrzymaniu.

Testowanie systemów opartych na wzorcach projektowych w Go i Node.js wymaga szczególnej uwagi. Rekomendowane podejścia to:

• Testy jednostkowe — skupiają się na testowaniu pojedynczych komponentów.
• Testy integracyjne — sprawdzają współdziałanie różnych komponentów w systemie.
• Testy end-to-end — symulują rzeczywiste scenariusze użytkowników.

W Go możemy użyć pakietu testing:

func TestAddition(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, got %d", result)
    }
}

W Node.js możemy skorzystać z frameworków takich jak Mocha czy Jest:

const assert = require('assert');
const add = require('./add');

describe('Addition', () => {
    it('should return 5', () => {
        assert.strictEqual(add(2, 3), 5);
    });
});

Dobrze zorganizowane testy przyczyniają się do większej stabilności systemu i ułatwiają wprowadzanie zmian.

Czysty kod to koncepcja, która przyciąga uwagę w kontekście wzorców projektowych. Główne zasady to:

• Nazwy zmiennych i funkcji powinny być intuicyjne.
• Funkcje powinny być krótkie i jednoznaczne.
• Unikaj zagnieżdżonych struktur, które mogą skomplikować czytelność.

W Go dobrym przykładem są style kodowania, które promują czytelność:

func CalculateTotal(price float64, quantity int) float64 {
    return price * float64(quantity)
}

W Node.js warto stosować lintery, takie jak ESLint, które pomagają utrzymać spójność kodu i zapobiegać błędom. Przy dobrych praktykach kod będzie nie tylko łatwiejszy do zrozumienia, ale także łatwiejszy w utrzymaniu i rozwijaniu.