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

前端之家收集整理的这篇文章主要介绍了常见设计模式遵循的设计原则--单一职责原则前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

因为在毕业论文中涉及到了设计模式的使用,算是重新回顾了一下,在C#,或者C++这种面向对象的语言中,设计模式的东西已经被很多人深入的研究过了,顺便联系到javascript这种基于原型的动态类型语言中,进行单独的探讨。常常被提到的设计设计模式遵循的设计原则主要有以下几种。

设计原则

  • 合成复用原则(Composite/Aggregate Reuse Principle CARP)

  • 里氏替换原则(Liskov Substitution Principle)

  • 依赖倒置原则(Dependence Inversion Principle)

  • 接口隔离原则(Interface Segregation Principle)

  • 迪米特法则(Law Of Demeter)

  • 开闭原则(Open Close Principle)

  • 单一职责原则(The Single Responsibility Principle)

单一职责原则(Single Responsibility Principle)

定义:不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责。

问题由来:类T负责两个不同的职责:职责P1,职责P2。当由于职责P1需求发生改变而需要修改类T时,有可能会导致原本运行正常的职责P2功能发生故障。

解决方案:遵循单一职责原则。分别建立两个类T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改类T1时,不会使职责P2发生故障风险;同理,当修改T2时,也不会使职责P1发生故障风险。

单一职责的描述如下:

  1. A class should have only one reason to change
  2. 类发生更改的原因应该只有一个

一个类(JavaScript下应该是一个对象)应该有一组紧密相关的行为的意思是什么?遵守单一职责的好处是可以让我们很容易地来维护这个对象,当一个对象封装了很多职责的话,一旦一个职责需要修改,势必会影响该对象想的其它职责代码。通过解耦可以让每个职责更加有弹性地变化。

不过,我们如何知道一个对象的多个行为构造多个职责还是单个职责?我们可以通过参考Role Stereotypes的概念来决定,提出了如下Role Stereotypes来区分职责:

  • Information holder – 该对象设计为存储对象并提供对象信息给其它对象。

  • Structurer – 该对象设计为维护对象和信息之间的关系

  • Service provider – 该对象设计为处理工作并提供服务给其它对象

  • Controller – 该对象设计为控制决策一系列负责的任务处理

  • Coordinator – 该对象不做任何决策处理工作,只是delegate工作到其它对象上

  • Interfacer – 该对象设计为在系统的各个部分转化信息(或请求)

通过这些概念,就更加容易知道你的代码到底是多职责还是单一职责了。

代码示例

比如以将商品加入购物车这段代码为例:

  1. function Product(id,description) {
  2. this.getId = function () {
  3. return id;
  4. };
  5. this.getDescription = function () {
  6. return description;
  7. };
  8. }
  9.  
  10. function Cart(eventAggregator) {
  11. var items = [];
  12.  
  13. this.addItem = function (item) {
  14. items.push(item);
  15. };
  16. }
  17.  
  18. (function () {
  19. var products = [new Product(1,"Star Wars Lego Ship"),new Product(2,"Barbie Doll"),new Product(3,"Remote Control Airplane")],cart = new Cart();
  20.  
  21. function addToCart() {
  22. var productId = $(this).attr('id');
  23. var product = $.grep(products,function (x) {
  24. return x.getId() == productId;
  25. })[0];
  26. cart.addItem(product);
  27.  
  28. var newItem = $('<li></li>').html(product.getDescription()).attr('id-cart',product.getId()).appendTo("#cart");
  29. }
  30.  
  31. products.forEach(function (product) {
  32. var newItem = $('<li></li>').html(product.getDescription())
  33. .attr('id',product.getId())
  34. .dblclick(addToCart)
  35. .appendTo("#products");
  36. });
  37. })();

在这里声明了两个function分别用来描述product和cart,而匿名函数的职责是更新屏幕和用户交互,这还不是一个很复杂的例子,但匿名函数里却包含了很多不相关的职责,让我们来看看到底有多少职责:
首先,有product的集合的声明
其次,有一个将product集合绑定到#product元素的代码,而且还附件了一个添加到购物车的事件处理
第三,有Cart购物车的展示功能
第四,有添加product item到购物车并显示功能

单一职责原则指导下,对对象职责进行划分

我们参考了martinfowler的事件聚合(Event Aggregator)理论在处理代码以便各对象之间进行通信,以便代码各自存放到各自的对象里。

首先我们先来实现事件聚合的功能,该功能分为2部分,1个是Event,用于Handler回调的代码,1个是EventAggregator用来订阅和发布Event,代码如下:

  1. function Event(name) {
  2. var handlers = [];
  3.  
  4. this.getName = function () {
  5. return name;
  6. };
  7.  
  8. this.addHandler = function (handler) {
  9. handlers.push(handler);
  10. };
  11.  
  12. this.removeHandler = function (handler) {
  13. for (var i = 0; i < handlers.length; i++) {
  14. if (handlers[i] == handler) {
  15. handlers.splice(i,1);
  16. break;
  17. }
  18. }
  19. };
  20.  
  21. this.fire = function (eventArgs) {
  22. handlers.forEach(function (h) {
  23. h(eventArgs);
  24. });
  25. };
  26. }
  27.  
  28. function EventAggregator() {
  29. var events = [];
  30.  
  31. function getEvent(eventName) {
  32. return $.grep(events,function (event) {
  33. return event.getName() === eventName;
  34. })[0];
  35. }
  36.  
  37. this.publish = function (eventName,eventArgs) {
  38. var event = getEvent(eventName);
  39.  
  40. if (!event) {
  41. event = new Event(eventName);
  42. events.push(event);
  43. }
  44. event.fire(eventArgs);
  45. };
  46.  
  47. this.subscribe = function (eventName,handler) {
  48. var event = getEvent(eventName);
  49.  
  50. if (!event) {
  51. event = new Event(eventName);
  52. events.push(event);
  53. }
  54.  
  55. event.addHandler(handler);
  56. };
  57. }

然后,我们来声明Product对象,代码如下:

  1. function Product(id,description) {
  2. this.getId = function () {
  3. return id;
  4. };
  5. this.getDescription = function () {
  6. return description;
  7. };
  8. }

接着来声明Cart对象,该对象的addItem的function里我们要触发发布一个事件itemAdded,然后将item作为参数传进去。

  1. function Cart(eventAggregator) {
  2. var items = [];
  3.  
  4. this.addItem = function (item) {
  5. items.push(item);
  6. eventAggregator.publish("itemAdded",item);
  7. };
  8. }

CartController主要是接受cart对象和事件聚合器,通过订阅itemAdded来增加一个li元素节点,通过订阅productSelected事件来添加product。

  1. function CartController(cart,eventAggregator) {
  2. eventAggregator.subscribe("itemAdded",function (eventArgs) {
  3. var newItem = $('<li></li>').html(eventArgs.getDescription()).attr('id-cart',eventArgs.getId()).appendTo("#cart");
  4. });
  5.  
  6. eventAggregator.subscribe("productSelected",function (eventArgs) {
  7. cart.addItem(eventArgs.product);
  8. });
  9. }

Repository的目的是为了获取数据(可以从ajax里获取),然后暴露get数据的方法

  1. function ProductRepository() {
  2. var products = [new Product(1,"Remote Control Airplane")];
  3.  
  4. this.getProducts = function () {
  5. return products;
  6. }
  7. }

ProductController里定义了一个onProductSelect方法,主要是发布触发productSelected事件,forEach主要是用于绑定数据到产品列表上,代码如下:

  1. function ProductController(eventAggregator,productRepository) {
  2. var products = productRepository.getProducts();
  3.  
  4. function onProductSelected() {
  5. var productId = $(this).attr('id');
  6. var product = $.grep(products,function (x) {
  7. return x.getId() == productId;
  8. })[0];
  9. eventAggregator.publish("productSelected",{
  10. product: product
  11. });
  12. }
  13.  
  14. products.forEach(function (product) {
  15. var newItem = $('<li></li>').html(product.getDescription())
  16. .attr('id',product.getId())
  17. .dblclick(onProductSelected)
  18. .appendTo("#products");
  19. });
  20. }

最后声明匿名函数(需要确保HTML都加载完了才能执行这段代码,比如放在jQuery的ready方法里):

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

可以看到匿名函数代码减少了很多,主要是一个对象的实例化代码代码里我们介绍了Controller的概念,他接受信息然后传递到action,我们也介绍了Repository的概念,主要是用来处理product的展示,优化的结果就是写了一大堆的对象声明,但是好处是每个对象有了自己明确的职责,该展示数据的展示数据,改处理集合的处理集合,这样耦合度就非常低了。

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

猜你在找的设计模式相关文章