设计模式七大原则--单一职责原则

原创 已于 2022-12-29 14:13:29 修改 · 563 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #单一职责原则 #数据库

于 2022-12-29 13:38:10 首次发布
本文阐述了单一职责原则的概念及其重要性，并通过具体的代码示例介绍了如何利用装饰模式来实现这一原则。通过拆分职责并采用装饰模式，提高了系统的灵活性和可维护性。

文章目录

、

一、概念

**

单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。

**
单一职责原则告诉我们：一个类不能太“累”！在软件系统中，一个类（大到模块，小到方法）承担的职责越多，它被复用的可能性就越小，而且一个类承担的职责过多，就相当于将这些职责耦合在一起，当其中一个职责变化时，可能会影响其他职责的运作，因此要将这些职责进行分离，将不同的职责封装在不同的类中，即将不同的变化原因封装在不同的类中，如果多个职责总是同时发生改变则可将它们封装在同一类中。

单一职责原则是实现高内聚、低耦合的指导方针，它是最简单但又最难运用的原则

二、例程

在图1中，CustomerDataChart类中的方法说明如下：getConnection()方法用于连接数据库，findCustomers()用于查询所有的客户信息，createChart()用于创建图表，displayChart()用于显示图表。

在图1中，CustomerDataChart类中的方法说明如下：getConnection()方法用于连接数据库，findCustomers()用于查询所有的客户信息，createChart()用于创建图表，displayChart()用于显示图表。
在图1中，CustomerDataChart类承担了太多的职责，既包含与数据库相关的方法，又包含与图表生成和显示相关的方法。如果在其他类中也需要连接数据库或者使用findCustomers()方法查询客户信息，则难以实现代码的重用。无论是修改数据库连接方式还是修改图表显示方式都需要修改该类，它不止一个引起它变化的原因，违背了单一职责原则。因此需要对该类进行拆分，使其满足单一职责原则，类CustomerDataChart可拆分为如下三个类：

(1) DBUtil：负责连接数据库，包含数据库连接方法getConnection()；

  (2) CustomerDAO：负责操作数据库中的Customer表，包含对Customer表的增删改查等方法，如findCustomers()；

  (3) CustomerDataChart：负责图表的生成和显示，包含方法createChart()和displayChart()。

  使用单一职责原则重构后的结构如图2所示：

在这里插入图片描述

三、代码框架（装饰模式）

在这里插入图片描述

#include  <iostream>
#include <windows.h>

using namespace std;
//业务操作
class Stream {
public:
    virtual char Read(int number) = 0;
	virtual void Seek(int position) = 0;
	virtual void Write(char data) = 0;

	virtual ~Stream() {}
};
//主体类
class FileStream : public Stream {
public:
	virtual char Read(int number) {
		//读文件流
	}
	virtual void Seek(int position) {
		//定位文件流
	}
	virtual void Write(char data) {
		//写文件流
	}
}; 
class NetworkStream :public Stream {
public:
	virtual char Read(int number) {
		//读网络流
	}
	virtual void Seek(int position) {
		//定位网络流
	}
	virtual void Write(char data) {
		//写网络流
	}
};

class MemoryStream :public Stream {
public:
	virtual char Read(int number) {
		//读内存流
	}
	virtual void Seek(int position) {
		//定位内存流
	}
	virtual void Write(char data) {
		//写内存流
	}

};

//扩展操作
class CryptoFileStream :public FileStream {
public:
	virtual char Read(int number) {

		//额外的加密操作...
		FileStream::Read(number);//读文件流

	}
	virtual void Seek(int position) {
		//额外的加密操作...
		FileStream::Seek(position);//定位文件流
								   //额外的加密操作...
	}
	virtual void Write(byte data) {
		//额外的加密操作...
		FileStream::Write(data);//写文件流
								//额外的加密操作...
	}
};

class CryptoNetworkStream:public NetworkStream{
public:
	virtual char Read(int number) {
		//额外的加密操作...
		NetworkStream::Read(number);//读网络流
	}
	virtual void Seek(int position) {
		//额外的加密操作...
		NetworkStream::Seek(position);//定位网络流
									  //额外的加密操作...
	}
	virtual void Write(byte data) {
		//额外的加密操作...
		NetworkStream::Write(data);//写网络流
								   //额外的加密操作...
	}
};

class CryptoMemoryStream : public MemoryStream {
public:
	virtual char Read(int number) {
		//额外的加密操作...
		MemoryStream::Read(number);//读内存流
	}
	virtual void Seek(int position) {
		//额外的加密操作...
		MemoryStream::Seek(position);//定位内存流
									 //额外的加密操作...
	}
	virtual void Write(byte data) {
		//额外的加密操作...
		MemoryStream::Write(data);//写内存流
								  //额外的加密操作...
	}
};
class BufferedFileStream : public FileStream {
	//...
};

class BufferedNetworkStream : public NetworkStream {
	//...
};
class BufferedMemoryStream : public MemoryStream {
	//...
};
class CryptoBufferedFileStream :public FileStream {
public:
	virtual char Read(int number) {
		//额外的加密操作...
		//额外的缓冲操作...
		FileStream::Read(number);//读文件流
	}
	virtual void Seek(int position) {
		//额外的加密操作...
		//额外的缓冲操作...
		FileStream::Seek(position);//定位文件流
								   //额外的加密操作...
								   //额外的缓冲操作...
	}
	virtual void Write(byte data) {
		//额外的加密操作...
		//额外的缓冲操作...
		FileStream::Write(data);//写文件流
								//额外的加密操作...
								//额外的缓冲操作...
	}
};
void Process() {
	//编译时装配
	CryptoFileStream *fs1 = new CryptoFileStream();
	BufferedFileStream *fs2 = new BufferedFileStream();
	CryptoBufferedFileStream *fs3 = new CryptoBufferedFileStream();

}

#include  <iostream>
#include <windows.h>

using namespace std;
//业务操作
class Stream {
public:
		virtual char Read(int number) = 0;
	virtual void Seek(int position) = 0;
	virtual void Write(char data) = 0;
	virtual ~Stream() {}
};
//主体类
class FileStream : public Stream {
public:
	virtual char Read(int number) {
		//读文件流
	}
	virtual void Seek(int position) {
		//定位文件流
	}
	virtual void Write(char data) {
		//写文件流
	}
};
class NetworkStream :public Stream {
public:
	virtual char Read(int number) {
		//读网络流
	}
	virtual void Seek(int position) {
		//定位网络流
	}
	virtual void Write(char data) {
		//写网络流
	}
};
class MemoryStream :public Stream {
public:
	virtual char Read(int number) {
		//读内存流
	}
	virtual void Seek(int position) {
		//定位内存流
	}
	virtual void Write(char data) {
		//写内存流
	}
};
//扩展操作
class CryptoStream : public Stream {
	Stream* stream;//...
public:
	CryptoStream(Stream* stm) :stream(stm) {
	}
	virtual char Read(int number) {
		//额外的加密操作...
		stream->Read(number);//读文件流
	}
	virtual void Seek(int position) {
		//额外的加密操作...
		stream->Seek(position);//定位文件流
							   //额外的加密操作...
	}
	virtual void Write(char data) {
		//额外的加密操作...
		stream->Write(data);//写文件流
							//额外的加密操作...
	}
};

class BufferedStream : public Stream {
	Stream* stream;//...
public:
	BufferedStream(Stream* stm) :stream(stm) {
	}
	//...
	virtual char Read(int number) {
		//额外的加密操作...
		stream->Read(number);//读文件流
	}
	virtual void Seek(int position) {
		//额外的加密操作...
		stream->Seek(position);//定位文件流
							   //额外的加密操作...
	}
	virtual void Write(char data) {
		//额外的加密操作...
		stream->Write(data);//写文件流
							//额外的加密操作...
	}
};
void Process() {
	//运行时装配
	FileStream* s1 = new FileStream();
	CryptoStream* s2 = new CryptoStream(s1);
	BufferedStream* s3 = new BufferedStream(s1);
	BufferedStream* s4 = new BufferedStream(s2);
}

//业务操作
class Stream {

public:
		virtual char Read(int number) = 0;
	virtual void Seek(int position) = 0;
	virtual void Write(char data) = 0;

	virtual ~Stream() {}
};

//主体类
class FileStream : public Stream {
public:
	virtual char Read(int number) {
		//读文件流
	}
	virtual void Seek(int position) {
		//定位文件流
	}
	virtual void Write(char data) {
		//写文件流
	}

};

class NetworkStream :public Stream {
public:
	virtual char Read(int number) {
		//读网络流
	}
	virtual void Seek(int position) {
		//定位网络流
	}
	virtual void Write(char data) {
		//写网络流
	}

};

class MemoryStream :public Stream {
public:
	virtual char Read(int number) {
		//读内存流
	}
	virtual void Seek(int position) {
		//定位内存流
	}
	virtual void Write(char data) {
		//写内存流
	}

};

//扩展操作

class DecoratorStream: public Stream{
protected:
	Stream* stream;//...
	DecoratorStream(Stream * stm) :stream(stm) {

	}

};
 class CryptoStream : public DecoratorStream {
				 public:
					 CryptoStream(Stream* stm) :DecoratorStream(stm) {

					 }

					 virtual char Read(int number) {

						 //额外的加密操作...
						 stream->Read(number);//读文件流
					 }
					 virtual void Seek(int position) {
						 //额外的加密操作...
						 stream->Seek(position);//定位文件流
												//额外的加密操作...
					 }
					 virtual void Write(char data) {
						 //额外的加密操作...
						 stream->Write(data);//写文件流
											 //额外的加密操作...
					 }
				 };

				 class BufferedStream : public DecoratorStream {
					 Stream* stream;//...

				 public:
					 BufferedStream(Stream* stm) :DecoratorStream(stm) {

					 }
					 virtual char Read(int number) {

						 //额外的加密操作...
						 stream->Read(number);//读文件流
					 }
					 virtual void Seek(int position) {
						 //额外的加密操作...
						 stream->Seek(position);//定位文件流
												//额外的加密操作...
					 }
					 virtual void Write(char data) {
						 //额外的加密操作...
						 stream->Write(data);//写文件流
											 //额外的加密操作...
					 }
					 //...
				 };
				 void Process() {
					 //运行时装配
					 FileStream* s1 = new FileStream();
					 CryptoStream* s2 = new CryptoStream(s1);
					 BufferedStream* s3 = new BufferedStream(s1);
					 BufferedStream* s4 = new BufferedStream(s2);
				 }

在这里插入图片描述
在这里插入图片描述

————————————————
版权声明：本文为优快云博主「LoveLion」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/lovelion/article/details/7536542

本文引用：https://blog.youkuaiyun.com/lovelion/article/details/7536542

设计模式 -- 单一职责原则
clack_man的博客
01-11 403
Robert Martin 说，单一职责原则是基于康威定律的一个推论：一个软件系统的最佳结构高度依赖于使用这个软件的组织的内部结构。当需求变化时，该变化会反应为类的职责的变化。“一个模块只干一件事”的确是重要的软件设计思想，但它其实是“高内聚、低耦合”的通俗解释，是从模块自身考虑怎么去组合的设计思想。软件设计是一门关注长期变化的学问，一个模块最理想的状态是不改变，其次是少改变，它可以成为一个模块设计好坏的衡量标准。而项目管理的需求，通常是业务部门提出的，它的行为者则是部门负责人、项目负责人。
设计模式（一）--单一职责模式（衡量接口或类设计）
newlifemain的博客
09-01 471
作为一只入坑了两年多的java程序猿，最近才真正接触到公司的项目，面对公司所使用的框架技术，真是两眼一抹黑啊，如何快速看懂现有项目的关键技术，这直接决定你是否能快速胜任手里的工作！这段时间也思考了很多；现有的后端技术真的很多，springBoot、springcloud。。。什么的，我们固然要学习了，但是如果你的思维还停留在以前学生时代写的代码，做的软件。。那你也许会很不适应公司的开...
【设计模式一】七大原则、UML类图、设计模式分类
土味儿
07-25 1774
目录一、七大原则1、单一职责原则2、接口隔离原则3、依赖倒置原则4、里氏替换原则5、开闭原则6、迪米特原则7、合成复用原则8、核心思想二、UML类图1、基本介绍2、UML图3、UML类图4、继承和实现1)继承(Inheritance)2)实现(Realization)3)继承和实现的区别5、依赖、关联、聚合和组合1)依赖(Dependency)2)关联(Association)3)聚合(Aggr...
面向对象设计原则之单一职责原则
limuzi13的专栏
06-25 532
单一职责原则是最简单的面向对象设计原则，它用于控制类的粒度大小。单一职责原则定义如下： 单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。 单一职责原则告诉我们：一个类不能太“累”！在软件系统中，一个类（大到模块，小到方法）承担的职责越多，它被复用
设计模式六大原则（1）：单一职责原则
luohai859的专栏
03-09 968
定义：不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。 问题由来：类T负责两个不同的职责：职责P1，职责P2。当由于职责P1需求发生改变而需要修改类T时，有可能会导致原本运行正常的职责P2功能发生故障。 解决方案：遵循单一职责原则。分别建立两个类T1、T2，使T1完成职责P1功能，T2完成职责P2功能。这样，当修改类T1时，不会使职责P2发生故障风险；同理，当修改T2时，也
Java设计模式七大原则-单一职责原则.md
08-13
设计模式
Java设计模式-七大架构设计原则-单一职责原则
Fatter$hday的博客
03-22 906
Java设计模式-七大架构设计原则-单一职责原则
软件设计七大原则详解 1. 单一职责原则（Single Responsibility Principle, SRP） 1.1 原则定义 1.2 为什么需要单一职责原则？ 1.3 违反单一职责原则的例子
最新发布
04-24
软件设计七大原则详解 1. 单一职责原则（Single Responsibility Principle, SRP） 1.1 原则定义 1.2 为什么需要单一职责原则？ 1.3 违反单一职责原则的例子 1.4 应用单一职责原则的改进 1.5 现实应用场景 1.6 单一...
设计模式基础培训材料-面向对象设计原则与模式
06-08
#### 二、面向对象设计七大原则详解 1. **开闭原则（Open-Closed Principle, OCP）** - **定义**：开闭原则强调系统应当对扩展开放，对修改关闭。这意味着当需要增加新功能时，应尽可能不修改现有代码。 - **...
第一章设计模式与七大原则.doc
02-28
1. **单一职责原则**：这是设计原则中最基础的一个，要求每个类或者模块只应该有一个引起其变化的原因。这样可以降低类的复杂度，提高类的可读性，并且使得类更容易被复用。 2. **里氏替换原则（LSP，Liskov ...
设计原则（一）---单一职责原则
Seasons_in_your_sun的博客
11-01 618
1.1 我是“牛”类，我可以担任多职吗 &amp;amp;amp;amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp
《设计模式》——单一职责原则
半寿翁的博客
08-04 447
单一职责原则 《设计模式之禅第2版》设计模式之禅的第一个标题就是“我是‘牛’类，我可以担任多职吗”。 看到这就不禁想到公司的状况，就比如作为一个Android工程师，如果不仅让我开发Android，还要从需求调研、到原型设计、再到测试、发布都一个人干。就好像一个“牛”类一般，身兼多职，可是工资不变又不给多发福利。而且“牛”类还有一个弊端就是越“牛”就越“牛”，领导有事第一个想到让你解决，你承担的...
设计模式（单一职责原则）
qq_39234639的博客
06-22 855
设计模式（单一职责原则）
设计模式原则——单一职责原则
Whoo_的博客
09-30 632
单一职责原则了解
设计模式——简单说（单一职责原则）
weixin_30672019的博客
02-23 174
单一职责原则的英文是Single Responsibility Principle，简称SRP。 定义：应该有且仅有一个原因引起类的变更。 如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会影响到其他的职责，另外，把多个职责耦合在一起，也会影响复用性。 举个例子： /** * 水壶的接口 */ public interface Ikettle {...
设计模式原则 - 单一职责原则（一）
weixin_43811057的博客
12-19 859
单一职责原则（Single Responsibility Principle, SRP），有且仅有一个原因引起类的变更顾名思义：一个类只负责一项职责即对类来说，一个类应该只负责一项职责。如类 A 负责两个不同职责：职责 1，职责 2，当职责 1 需求变更而改变 A 时，可能造成职责 2 执行错误，所以需要将类 A 的粒度分解为 A1，A2单一职责原则：各司其职通过上面两种方案分析：方案一：类级别遵守了单一职责原则，但是改动的代价很高方案二：方法级别遵守了单一职责原则，改动幅度较小。
设计模式——单一职责原则
心之所向，身之所往
11-21 989
定义：不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。 问题由来：类T负责两个不同的职责：职责P1，职责P2。当由于职责P1需求发生改变而需要修改类T时，有可能会导致原本运行正常的职责P2功能发生故障。 解决方案：遵循单一职责原则。分别建立两个类T1、T2，使T1完成职责P1功能，T2完成职责P2功能。这样，当修改类T1时，不会使职责P2发生故障风险；同理，当修改T
设计原则之单一职责原则
鸭梨的博客
05-20 219
单一职责原则的定义 单一职责原则的英文原话是： There should never be more than one reason for a class to change. 意思是：一个类，应当只有一个引起它变化的原因；即一个类应该只有一个职责。 就一个类而言，应该只专注于做一件事和仅有一个引起变化的原因，这就是所谓的单一职责原则。该原则提出了对对象职责的一种理想期望，对象不应该承担太多职责，正如人不应该一心分为二用。 唯有专注，才能保证对象的高内聚； 唯有单一，才能保证对象的细粒度。 对象的高内
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

晓纪同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值