常见设计模式遵循的设计原则--单一职责原则

时间 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的展现，优化的结果就是写了一大堆的对象声明，可是好处是每一个对象有了本身明确的职责，该展现数据的展现数据，改处理集合的处理集合，这样耦合度就很是低了。

可是咱们也明显看出来了，为了遵循单一职责的原则，将各个职责严格区分开来，所作的工做也很多，到底工做量是增是减，值不值得，仁者见仁智者见智。由于在一个小项目中，若是为了使用这些原则而使用，会增长很多工做量，反而有时候会把事情搞复杂了，可是从长远角度来看，越是大的，复杂的项目，而且后期增长的可能性和地方很是多的话，在初始设计时可以考虑的这么专业，固然是百利而无一害，而且好处也会渐渐显示出来的，包括之后的维护工做。