Consigli di architettura di design sulla relazione tra oggetti e singleton JS

2

Desidero il tuo feedback su alcune best practice sulla relazione di design tra oggetti, specialmente quando è coinvolto un oggetto singleton.

Immaginiamo di dover simulare un negozio con i clienti.

Nella mia applicazione c'è un solo negozio e un cliente appartiene solo a quel negozio.

Quando il negozio si chiude devo avvisare ogni cliente.

Sotto qualche pseudo codice.

In entrambi gli approcci considero un negozio come un singolo oggetto.

Nell'approccio 01, chiamo addCustomer in negozio.

Nell'approccio 02, chiamo addCustomer quando effettivamente creo un oggetto Cliente mantenendo un riferimento su Shop in ogni cliente .

Credo che un terzo approccio potrebbe anche essere possibile, fondamentalmente dove negozio e cliente comunicano con gli eventi. Quindi, ad esempio, quando si crea un cliente, viene trasmesso un evento, si acquista ascoltando quell'evento e si aggiunge un cliente a se stesso.

Quali sono le tue opinioni, pro / contro riguardo a questi approcci? Sto usando JavaScript come lingua. Grazie in anticipo per il tuo supporto.

  // 01 approch
            var shop = {
                customers: [],
                addCustomer: function (customer) {
                    this.customers.push(customer);
                },
                close: function () {
                    this.customers.forEach(function (customer) {
                        customer.goOut();
                    });

                }
            };
            function Customer(name) {
                this.name = name;
                this.goOut = function () {
                    console.log(this.name + ' goes out')
                }
            }
            // set up
            shop.addCustomer(new Customer('a'));
            shop.addCustomer(new Customer('b'));
            shop.addCustomer(new Customer('c'));
            shop.close();
            console.log('-------------------------');
        // 02 approch
        var shop2 = {
            customers: [],
            addCustomer: function (customer) {
                this.customers.push(customer);
            },
            close: function () {
                this.customers.forEach(function (customer) {
                    customer.goOut();
                });
                this.customers = [];
            }
        };

        function Customer2(name) {
            this.shop = shop2;
            this.name = name;
            this.goOut = function () {
                console.log(this.name + ' goes out')
            }
            this.shop.addCustomer(this); // make sense?
        }
        new Customer2('d');
        new Customer2('e');
        new Customer2('f');
        shop2.close();
    
posta GibboK 15.10.2015 - 11:46
fonte

2 risposte

2

È difficile raccomandare qualcosa in particolare perché stiamo discutendo solo di una piccola quantità di codice. Ma ci sono alcuni commenti

In approach 01, I call addCustomer on shop.

In questo caso il negozio conosce i clienti. I clienti non sanno del negozio. Quindi, c'è un link.

In approach 02, I call addCustomer when actually creating a Customer object keeping a reference on Shop in every Customer.

In questo caso entrambi i negozi conoscono clienti e clienti che sono a conoscenza del negozio. Quindi, ci sono due link e l'accoppiamento tra le classi diventa ancora più strong (che è per lo più cattivo)

I believe a third approach could be also possible, basically where shop and Customer communicate with events.

Questo alza leggermente l'accoppiamento, ma non lo rimuove comunque.

For my understanding coupling should be removed as Shop is not referenced in ? Customer as in the second approach. Am I wrong?

Bene, sarà rimosso o meno dipende da cosa esattamente fai quando viene ricevuto l'evento. L'accoppiamento è solo conoscenza. Se viene ricevuto dopo l'evento, il cliente si aggiunge al negozio o ai negozi al suo interno un riferimento al negozio, l'accoppiamento è ancora lì.

C'è anche un accoppiamento indiretto. Stai inviando un evento e questo evento è stato elaborato. Potrebbe essere elaborato senza coinvolgere riferimenti oggetto reali, ma è ancora lì. Il tuo sistema impone la conoscenza della relazione tra queste due classi.

Quindi, è necessario fornire agli oggetti una conoscenza minima reciproca. Ma non meno conoscenza, è necessario che funzionino correttamente.

    
risposta data 15.10.2015 - 15:18
fonte
0

Il modello classico che potresti usare per implementare questo è lo schema dell'osservatore. È fondamentalmente l'astrazione della tua prima soluzione. Con il modello di osservatore non importa al tuo negozio, che tipo di oggetti ascoltano il tuo "evento vicino". Quindi potrebbero essere clienti ma anche fornitori (beh ... qualunque cosa tu possa pensare :)).

Vedi questi collegamenti come punto di partenza:

risposta data 15.10.2015 - 15:39
fonte

Leggi altre domande sui tag