常見設計模式遵循的設計原則--單一職責原則

時間 2019-12-05

原文原文鏈接

由於在畢業論文中涉及到了設計模式的使用，算是從新回顧了一下，在C#，或者C++這種面向對象的語言中，設計模式的東西已經被不少人深刻的研究過了，順便聯繫到javascript這種基於原型的動態類型語言中，進行單獨的探討。經常被提到的設計設計模式遵循的設計原則主要有如下幾種。javascript

設計原則

合成複用原則（Composite/Aggregate Reuse Principle CARP）html
里氏替換原則（Liskov Substitution Principle）java
依賴倒置原則（Dependence Inversion Principle）ajax
接口隔離原則（Interface Segregation Principle）設計模式
迪米特法則（Law Of Demeter）app
開閉原則（Open Close Principle）ide
單一職責原則（The Single Responsibility Principle）函數

單一職責原則（Single Responsibility Principle）

定義：不要存在多於一個致使類變動的緣由。通俗的說，即一個類只負責一項職責。優化

問題由來：類T負責兩個不一樣的職責：職責P1，職責P2。當因爲職責P1需求發生改變而須要修改類T時，有可能會致使本來運行正常的職責P2功能發生故障。this

解決方案：遵循單一職責原則。分別創建兩個類T一、T2，使T1完成職責P1功能，T2完成職責P2功能。這樣，當修改類T1時，不會使職責P2發生故障風險；同理，當修改T2時，也不會使職責P1發生故障風險。

單一職責的描述以下：

A class should have only one reason to change
類發生更改的緣由應該只有一個

一個類（JavaScript下應該是一個對象）應該有一組緊密相關的行爲的意思是什麼？遵照單一職責的好處是可讓咱們很容易地來維護這個對象，當一個對象封裝了不少職責的話，一旦一個職責須要修改，勢必會影響該對象想的其它職責代碼。經過解耦可讓每一個職責更加有彈性地變化。

不過，咱們如何知道一個對象的多個行爲構造多個職責仍是單個職責？咱們能夠經過參考Role Stereotypes的概念來決定，提出了以下Role Stereotypes來區分職責：

Information holder – 該對象設計爲存儲對象並提供對象信息給其它對象。
Structurer – 該對象設計爲維護對象和信息之間的關係
Service provider – 該對象設計爲處理工做並提供服務給其它對象
Controller – 該對象設計爲控制決策一系列負責的任務處理
Coordinator – 該對象不作任何決策處理工做，只是delegate工做到其它對象上
Interfacer – 該對象設計爲在系統的各個部分轉化信息（或請求）

經過這些概念，就更加容易知道你的代碼究竟是多職責仍是單一職責了。

代碼示例

好比以將商品加入購物車這段代碼爲例：

function Product(id, description) {
    this.getId = function () {
        return id;
    };
    this.getDescription = function () {
        return description;
    };
}

function Cart(eventAggregator) {
    var items = [];

    this.addItem = function (item) {
        items.push(item);
    };
}

(function () {
    var products = [new Product(1, "Star Wars Lego Ship"),
            new Product(2, "Barbie Doll"),
            new Product(3, "Remote Control Airplane")],
        cart = new Cart();

    function addToCart() {
        var productId = $(this).attr('id');
        var product = $.grep(products, function (x) {
            return x.getId() == productId;
        })[0];
        cart.addItem(product);

        var newItem = $('<li></li>').html(product.getDescription()).attr('id-cart', product.getId()).appendTo("#cart");
    }

    products.forEach(function (product) {
        var newItem = $('<li></li>').html(product.getDescription())
                                    .attr('id', product.getId())
                                    .dblclick(addToCart)
                                    .appendTo("#products");
    });
})();

在這裏聲明瞭兩個function分別用來描述product和cart，而匿名函數的職責是更新屏幕和用戶交互，這還不是一個很複雜的例子，但匿名函數裏卻包含了不少不相關的職責，讓咱們來看看到底有多少職責：
首先，有product的集合的聲明
其次，有一個將product集合綁定到#product元素的代碼，並且還附件了一個添加到購物車的事件處理
第三，有Cart購物車的展現功能
第四，有添加product item到購物車並顯示的功能

單一職責原則指導下，對對象職責進行劃分

咱們參考了martinfowler的事件聚合（Event Aggregator）理論在處理代碼以便各對象之間進行通訊，以便代碼各自存放到各自的對象裏。

首先咱們先來實現事件聚合的功能，該功能分爲2部分，1個是Event，用於Handler回調的代碼，1個是EventAggregator用來訂閱和發佈Event，代碼以下：

function Event(name) {
            var handlers = [];

            this.getName = function () {
                return name;
            };

            this.addHandler = function (handler) {
                handlers.push(handler);
            };

            this.removeHandler = function (handler) {
                for (var i = 0; i < handlers.length; i++) {
                    if (handlers[i] == handler) {
                        handlers.splice(i, 1);
                        break;
                    }
                }
            };

            this.fire = function (eventArgs) {
                handlers.forEach(function (h) {
                    h(eventArgs);
                });
            };
        }

        function EventAggregator() {
            var events = [];

            function getEvent(eventName) {
                return $.grep(events, function (event) {
                    return event.getName() === eventName;
                })[0];
            }

            this.publish = function (eventName, eventArgs) {
                var event = getEvent(eventName);

                if (!event) {
                    event = new Event(eventName);
                    events.push(event);
                }
                event.fire(eventArgs);
            };

            this.subscribe = function (eventName, handler) {
                var event = getEvent(eventName);

                if (!event) {
                    event = new Event(eventName);
                    events.push(event);
                }

                event.addHandler(handler);
            };
        }

而後，咱們來聲明Product對象，代碼以下：

function Product(id, description) {
    this.getId = function () {
        return id;
    };
    this.getDescription = function () {
        return description;
    };
}

接着來聲明Cart對象，該對象的addItem的function裏咱們要觸發發佈一個事件itemAdded，而後將item做爲參數傳進去。

function Cart(eventAggregator) {
    var items = [];

    this.addItem = function (item) {
        items.push(item);
        eventAggregator.publish("itemAdded", item);
    };
}

CartController主要是接受cart對象和事件聚合器，經過訂閱itemAdded來增長一個li元素節點，經過訂閱productSelected事件來添加product。

function CartController(cart, eventAggregator) {
    eventAggregator.subscribe("itemAdded", function (eventArgs) {
        var newItem = $('<li></li>').html(eventArgs.getDescription()).attr('id-cart', eventArgs.getId()).appendTo("#cart");
    });

    eventAggregator.subscribe("productSelected", function (eventArgs) {
        cart.addItem(eventArgs.product);
    });
}

Repository的目的是爲了獲取數據（能夠從ajax裏獲取），而後暴露get數據的方法。

function ProductRepository() {
    var products = [new Product(1, "Star Wars Lego Ship"),
            new Product(2, "Barbie Doll"),
            new Product(3, "Remote Control Airplane")];

    this.getProducts = function () {
        return products;
    }
}

ProductController裏定義了一個onProductSelect方法，主要是發佈觸發productSelected事件，forEach主要是用於綁定數據到產品列表上，代碼以下：

function ProductController(eventAggregator, productRepository) {
    var products = productRepository.getProducts();

    function onProductSelected() {
        var productId = $(this).attr('id');
        var product = $.grep(products, function (x) {
            return x.getId() == productId;
        })[0];
        eventAggregator.publish("productSelected", {
            product: product
        });
    }

    products.forEach(function (product) {
        var newItem = $('<li></li>').html(product.getDescription())
                                    .attr('id', product.getId())
                                    .dblclick(onProductSelected)
                                    .appendTo("#products");
    });
}

最後聲明匿名函數（須要確保HTML都加載完了才能執行這段代碼，好比放在jQuery的ready方法裏）：

(function () {
    var eventAggregator = new EventAggregator(),
    cart = new Cart(eventAggregator),
    cartController = new CartController(cart, eventAggregator),
    productRepository = new ProductRepository(),
    productController = new ProductController(eventAggregator, productRepository);
})();

能夠看到匿名函數的代碼減小了不少，主要是一個對象的實例化代碼，代碼裏咱們介紹了Controller的概念，他接受信息而後傳遞到action，咱們也介紹了Repository的概念，主要是用來處理product的展現，優化的結果就是寫了一大堆的對象聲明，可是好處是每一個對象有了本身明確的職責，該展現數據的展現數據，改處理集合的處理集合，這樣耦合度就很是低了。

可是咱們也明顯看出來了，爲了遵循單一職責的原則，將各個職責嚴格區分開來，所作的工做也很多，到底工做量是增是減，值不值得，仁者見仁智者見智。由於在一個小項目中，若是爲了使用這些原則而使用，會增長很多工做量，反而有時候會把事情搞複雜了，可是從長遠角度來看，越是大的，複雜的項目，而且後期增長的可能性和地方很是多的話，在初始設計時可以考慮的這麼專業，固然是百利而無一害，而且好處也會漸漸顯示出來的，包括之後的維護工做。