"围观"设计模式(1)--单一职责原则(SRP,Single Responsibility Principle)

沉寂了一个月的时间，仔细学习了下设计模式，从本篇博文开始陆续更新设计模式系列的文章，我给它起了个有意思的名字叫做：“围观”设计模式，当然围观是加引号的，我写博文分享的目的一方面是将自己学到的一些心得体会分享给大家，另一方面是博文与实际的案例结合，达到可以用于实际项目中的目的。希望看到博文的朋友多多提出宝贵的建议与批评，我会虚心的接受。

单一职责原则

单一功能原则（Single responsibility principle）规定每个类都应该有一个单一的功能，并且该功能应该由这个类完全封装起来。所有它的（这个类的）服务都应该严密的和该功能平行（功能平行，意味着没有依赖）。——维基百科

我们这里定义了这样的一个接口，包括setCarName,setCarColor,startUp,run和stop方法，那么这里应该很明显，所有的事情都要交给Car的实现类去完成，其中setCarName,setCarColor可以认为是完成了属性设置的任务，而后面的三个startUp、run、stop则完成了车的具体动作。从这里可以看出这个接口提供的方法存在职责不单一的问题，当然话说回来，setCarName和setCarColor如果放在一个接口中，那就职责单一了吗？一个设置名称，一个是设置颜色，也不是完全的单一嘛，我在这里的看法是不要斤斤计较，过分的划分功能，会导致设计的复杂化，加大工作量，所以在这里我觉得职责在划分的时候，需要进行一个抽象的过程，将完成的功能相近的划分到一起我觉得就可以了。

[java]  view plain  copy

1. package cn.design.pattern2016032001SingleResponsibility;  
2.   
3. public interface Car {  
4.   
5.     /** 设置名称 */  
6.     public void setCarName(String carName);  
7.       
8.     /** 设置颜色*/  
9.     public void setCarColor(String carColoe);  
10.       
11.     /** 启动*/  
12.     public void startUp();  
13.       
14.     /** 行驶*/  
15.     public void run();  
16.       
17.     /** 停止*/  
18.     public void stop();  
19.       
20. }  

[java]  view plain  copy

1. package cn.design.pattern2016032001SingleResponsibility;  
2.   
3. public class CarImpl implements Car {  
4.   
5.     @Override  
6.     public void setCarName(String carName) {  
7.         System.out.println("名称：" + carName);  
8.     }  
9.   
10.     @Override  
11.     public void setCarColor(String carColoe) {  
12.         System.out.println("颜色：" + carColoe);  
13.     }  
14.   
15.     @Override  
16.     public void startUp() {  
17.         System.out.println("启动");  
18.     }  
19.   
20.     @Override  
21.     public void run() {  
22.         System.out.println("行驶");  
23.     }  
24.   
25.     @Override  
26.     public void stop() {  
27.         System.out.println("停止");  
28.     }  
29.   
30. }  

[java]  view plain  copy

1. package cn.design.pattern2016032001SingleResponsibility;  
2.   
3. public class MainTest {  
4.   
5.     public static void main(String[] args) {  
6.         Car car = new CarImpl();  
7.         car.setCarName("HongQi");  
8.         car.setCarColor("Black");  
9.           
10.         car.startUp();  
11.         car.run();  
12.         car.stop();  
13.     }  
14. }  

那么我们应该怎么设计这个接口呢？

参考了《设计模式之禅》中的例子，将不同职责的操作分开到不同的接口中去。

[java]  view plain  copy

1. package cn.design.pattern2016032002SingleResponsibility;  
2.   
3. public interface Car {  
4.   
5.     /** 设置名称 */  
6.     public void setCarName(String carName);  
7.       
8.     /** 设置颜色*/  
9.     public void setCarColor(String carColoe);  
10. }  

[java]  view plain  copy

1. package cn.design.pattern2016032002SingleResponsibility;  
2.   
3. public interface CarAction {  
4.   
5.     /** 启动*/  
6.     public void startUp();  
7.       
8.     /** 行驶*/  
9.     public void run();  
10.       
11.     /** 停止*/  
12.     public void stop();  
13. }  

[java]  view plain  copy

1. package cn.design.pattern2016032002SingleResponsibility;  
2.   
3. public interface CarOperate extends Car, CarAction{  
4.   
5. }  

[java]  view plain  copy

1. package cn.design.pattern2016032002SingleResponsibility;  
2.   
3. public class CarImpl implements CarOperate{  
4.   
5.     @Override  
6.     public void setCarName(String carName) {  
7.         System.out.println("名称：" + carName);  
8.     }  
9.   
10.     @Override  
11.     public void setCarColor(String carColoe) {  
12.         System.out.println("颜色：" + carColoe);  
13.     }  
14.   
15.     @Override  
16.     public void startUp() {  
17.         System.out.println("启动");  
18.     }  
19.   
20.     @Override  
21.     public void run() {  
22.         System.out.println("行驶");  
23.     }  
24.   
25.     @Override  
26.     public void stop() {  
27.         System.out.println("停止");  
28.     }  
29.   
30.   
31. }  

[java]  view plain  copy

1. package cn.design.pattern2016032002SingleResponsibility;  
2.   
3. public class MainTest {  
4.   
5.     public static void main(String[] args) {  
6.         CarOperate car = new CarImpl();  
7.         Car carSet = (Car) car;  
8.         carSet.setCarName("HongQI");  
9.         carSet.setCarColor("Black");  
10.           
11.         CarAction carAction = (CarAction)car;  
12.         carAction.startUp();  
13.         carAction.run();  
14.         carAction.stop();  
15.     }  
16. }  

这些代码比较简单，我这里就不再过多的说明了。

我对这个问题有自己的看法，看下类图

这里会发生耦合，理论上应该尽量避免的，但是我觉得这样设计的话更能体现出单一职责原则。不过应该说尽量避免耦合才好，可能我的这种想法并不是推荐的方法。读者可以进行参考。

[java]  view plain  copy

1. package cn.design.pattern2016032003SingleResponsibility;  
2.   
3. public interface Car {  
4.   
5.     /** 设置名称 */  
6.     public void setCarName(String carName);  
7.     /** 名称 */  
8.     public String getCarName();  
9.       
10.     /** 设置颜色*/  
11.     public void setCarColor(String carColoe);  
12.     /** 颜色 */  
13.     public String getCarColor();  
14. }  

[java]  view plain  copy

1. public interface CarAction {  
2.   
3.     /** 启动*/  
4.     public void startUp();  
5.       
6.     /** 行驶*/  
7.     public void run();  
8.       
9.     /** 停止*/  
10.     public void stop();  
11. }  

[java]  view plain  copy

1. package cn.design.pattern2016032003SingleResponsibility;  
2.   
3. public class CarImpl implements Car{  
4.   
5.     private String carName;  
6.     private String carColor;  
7.       
8.     @Override  
9.     public void setCarName(String carName) {  
10.         this.carName = carName;  
11.         System.out.println("名称：" + carName);  
12.     }  
13.   
14.     @Override  
15.     public void setCarColor(String carColoe) {  
16.         this.carColor = carColoe;  
17.         System.out.println("颜色：" + carColoe);  
18.     }  
19.   
20.     @Override  
21.     public String getCarName() {  
22.         return this.carName;  
23.     }  
24.   
25.     @Override  
26.     public String getCarColor() {  
27.         return this.carColor;  
28.     }  
29.   
30. }  

[java]  view plain  copy

1. package cn.design.pattern2016032003SingleResponsibility;  
2.   
3. public class CarActionImpl implements CarAction{  
4.   
5.     private Car car;  
6.       
7.     public CarActionImpl(Car car){  
8.         this.car = car;  
9.     }  
10.       
11.     @Override  
12.     public void startUp() {  
13.         System.out.println("启动>>" + car.getCarName());  
14.     }  
15.   
16.     @Override  
17.     public void run() {  
18.         System.out.println("行驶");  
19.     }  
20.   
21.     @Override  
22.     public void stop() {  
23.         System.out.println("停止>>" + car.getCarName());  
24.     }  
25. }  

[java]  view plain  copy

1. package cn.design.pattern2016032003SingleResponsibility;  
2.   
3. public class CarOperate {  
4.   
5.     private Car car ;  
6.     private CarAction carAction ;  
7.       
8.     public CarOperate(Car car, CarAction carAction){  
9.         this.car = car;  
10.         this.carAction = carAction;  
11.     }  
12.   
13.     public Car getCar() {  
14.         return car;  
15.     }  
16.   
17.     public CarAction getCarAction() {  
18.         return carAction;  
19.     }  
20.       
21.       
22. }  

[java]  view plain  copy

1. package cn.design.pattern2016032003SingleResponsibility;  
2.   
3. public class MainTest {  
4.   
5.     public static void main(String[] args) {  
6.         Car car = new CarImpl();  
7.         CarAction carAction = new CarActionImpl(car);  
8.         CarOperate carOper = new CarOperate(car, carAction);  
9.         /** 
10.          * 如果在Action中需要得到Car中的属性可以通过构造函数进行设置 
11.          */  
12.         carOper.getCar().setCarColor("Black");  
13.         carOper.getCar().setCarName("HongQI");  
14.           
15.         carOper.getCarAction().startUp();  
16.         carOper.getCarAction().stop();  
17.     }  
18. }  

虽然这样的话体现单一设计模式比较好一些，但是还是感觉类之间的耦合有点强，不知道读者对这样的设计有什么看法呢？可以评论提出宝贵的建议。

单一职责模式的优点

1. 降低了单个类的复杂性，尽量保证一个类中操作的类型一致

2. 可读性较好，因为单一职责的原因，对某种职责的操作可以去具体的类中查看。

补充说明

单一职责原则，理论上我们要进行遵循的，但是往往实践中并不一定完全按照他的思路去设计，我的看法还是，尽量在完成业务需要的情况下，考虑按照单一职责原则对接口和类进行设计，类的设计过程中，不要过度的划分，适可而止就好。

源码已经上传至GitHub:下载设计模式代码