单一职责原则(SRP) Single Responsibility Principle

定义：应该有且仅有一个原因引起类的变更。即单一指责原则要求一个借口或类只有一个原因引起变化，也就是一个接口或类只有一个职责，它就负责一件事情。

优点：1.类的复杂性降低，实现什么职责都有清晰明确的定义

            2.可读性提高，复杂性降低，那当然可读性提高了。

            3.可维护性提高，可读性提高，那当然更容易维护了。

            4.变更引起的风险降低，变更是必不可少的，如果接口的单一职责做得好，一个接口修改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性，维护性都有非常大的帮助。

例：通常写用户管理都是一个接口 一个实现类

        

<<用户管理UML.vsdx>>

/**

 *

 * @author liang

 * 用户信息管理

 */

public interface IUserInfo {

 

    //设置用户的ID

public void setUserID(String userID);

 

//获得用户的ID

public String getUserID();

 

//设置用户的密码

/** */

public void setPassword(String password);

 

//获得用户的密码

public String getPassword();

 

//设置用户的名字

public void setUserName(String userName);

 

//获得用户的名字

public String getUserName();

 

//修改用户的密码

public boolean changePassword(String oldPassword);

 

//删除用户

public boolean deleteUser();

 

//用户映射

public void mapUser();

}

/**

 *

 * @author liang

 * 用户管理的实现类

 */

public class UserInfo implements IUserInfo{

 

private String userName;

private String userID;

private String password;

 

public void setUserID(String userID) {

this.userID = userID;

}

 

public String getUserID() {

return userID;

}

 

public void setPassword(String password) {

this.password = password;

}

 

public String getPassword() {

return password;

}

 

public void setUserName(String userName) {

this.userName = userName;

}

 

public String getUserName() {

return userName;

}

 

//修改用户密码

public boolean changePassword(String oldPassword){

System.out.println("密码修改成功...");

return true;

}

 

//删除用户

public boolean deleteUser(){

System.out.println("删除用户成功...");

return true;

}

 

//用户映射

public void mapUser()

System.out.println("用户映射成功...");

}

}

/**

 *

 * @author liang

 *业务类调用

 */

public class Client {

 

public static void main(String[] args) {

IUserInfo userInfo = new UserInfo();

userInfo.changePassword("abc");

}

} 

 用户属性和用户行为没有分开是一个严重的错误！应该把用户的信息抽取程一个BO(Business Object业务对象)，把行为抽取成一个Biz(Business Logic业务逻辑)。

<<修改后用户管理UML.vsdx>>

/**

 *

 * @author liang

 * 用户的业务对象

 */

public interface IUserBO {

 

// 设置用户ID

void setUserID(String userID);

 

// 获取用户ID

String getUserID();

 

// 设置用户密码

void setPassword(String password);

 

// 获得用户密码

String getPassword();

 

// 设置用户姓名

void setUserName(String userName);

 

// 获得用户姓名

String getUserName();

}

/**

 *

 * @author liang

 *用户信息管理

 */

public interface IUserBiz {

 

//修改用户密码

boolean changePassword(String oldPassword);

 

//删除用户

boolean deleteUser();

 

//用户映射

void mapUser();

 

//增加一个组织

boolean addOrg(int orgID);

 

//增加一个角色

boolean addRole(int roleID);

}

/**

 *

 * @author liang

 *

 */

public interface IUserInfo extends IUserBiz,IUserBO{

 

}

/**

 *

 * @author liang

 * 用户管理的实现类

 */

public class UserInfo implements IUserInfo {

 

private String userID;

private String password;

private String userName;

 

public void setUserID(String userID) {

this.userID = userID;

}

 

public String getUserID() {

return userID;

}

 

public void setPassword(String password) {

this.password = password;

}

 

public String getPassword() {

return password;

}

 

public void setUserName(String userName) {

this.userName = userName;

}

 

public String getUserName() {

return userName;

}

 

// 修改用户密码

public boolean changePassword(String oldPassword) {

System.out.println("修改密码成功");

return true;

}

 

// 删除用户

public boolean deleteUser() {

System.out.println("删除成功");

return true;

}

 

// 用户映射

public void mapUser() {

System.out.println("映射成功");

}

 

// 增加一个组织

public boolean addOrg(int orgID) {

System.out.println("增加组织");

return true;

}

 

// 增加一个角色

public boolean addRole(int roleID) {

System.out.println("增加角色");

return true;

}

 

}

/**

 *

 * @author liang

 *业务类调用

 */

public class Client {

 

public static void main(String[] args) {

IUserInfo userInfo = new UserInfo();

//我要复制了，我就认为它是一个纯粹的BO

IUserBO userBO = (IUserBO)userInfo;

userBO.setPassword("abc");

 

//我要执行动作了，我就认为是一个业务逻辑类

IUserBiz userBiz = (IUserBiz)userInfo;

userBiz.deleteUser();

}

}

从新拆分成两个接口，IUserBO负责用户属性，收集和反馈用户的属性信息，IUserBiz负责用户行为，完成用户信息的维护和变更。

       电话通话的时候有4个过程发生：拨号，通话，回应，挂机。其类图如下：

<<电话类图.vsdx>>

public interface IPhone {

 

// 拨通电话

public void dial(String phoneNumber);

 

// 通话

public void chat(Object o);

 

// 通话完毕，挂电话

public void hangup();

}

单一责任原则要求一个借口或者类只有一个原因引起变化，也就是一个接口或类只能一个职责，它就负责一件事情。

IPhone这个接口可不是只有一个职责，它包含两个职责：一个是协议管理，一个是数据传输。Dial()和hangup()两个方法实现是协议管理，分别负责拨号接通和挂机，chat()实现的是数据的传输。协议接通的变化会引起这个接口或者实现类的变化，数据传送也会引起这样的变化，但是协议管理和数据传输这两个职责不相互影响。那就考虑拆分成两个接口。

<<职责分明的电话类图.vsdx>>

这样是存在缺陷的，一个手机类要把ConnextionManager和DataTransfer组合在一起才能使用。组合是一种强耦合关系。这样的耦合还不如使用接口实现的方式。

<<简洁清晰职责分明的电话类图.vsdx>>

/**

 *

 * @author liang

 * 协议管理类接口

 */

public interface IConnectionManager {

 

// 拨打电话

void dial(String phoneNumber);

 

// 挂断电话

void hangup();

}

/**

 *

 * @author liang

 *数据传输类接口

 */

public interface IDataTransfer {

 

//输出传输

void DataTransfer(IConnectionManager cm);

}

/**

 *

 * @author liang

 *实现类

 */

public class Phone implements IDataTransfer, IConnectionManager {

 

@Override

public void DataTransfer(IConnectionManager cm) {

System.out.println("正在通话");

}

 

@Override

public void dial(String phoneNumber) {

System.out.println("拨打电话");

}

 

@Override

public void hangup() {

System.out.println("挂断电话");

}

 

}

/**

 *

 * @author liang

 *测试类

 */

public class Client {

 

public static void main(String[] args) {

 

Phone phone = new Phone();

phone.dial("127XXXXXXXX");

phone.DataTransfer(phone);

phone.hangup();

}

}

这样的设计才是比较合理的，一个类实现了两个接口，把两个职责融合在一个类中。这个Phone由两个原因引起变化。如果真要实现类的单一职责，这个就必须使用上面的职责分明的电话类图的模式了，这样会引起类间耦合过重，类的数量增加等问题。

注意：单一职责原则提出了一个编写程序的标准，用"职责"和"变化原因"来衡量接口或类设计的是否优良。但是这两者都是不可度量的，因项目环境而已。

对于单一职责原则，建议是接口一定要做到单一职责，类的设计尽量做到只有一个原因引起变化。

下面是电话职责的另外一种实现

/**

 *

 * @author liang

 * 协议管理类接口

 */

public interface IConnectionManager {

 

// 拨打电话

void dial(String phoneNumber);

 

// 挂断电话

void hangup();

}

/**

 *

 * @author liang

 *数据传输类接口

 */

public interface IDataTransfer {

 

//输出传输

void DataTransfer(IConnectionManager cm);

}

/**

 *

 * @author liang

 *实现类

 */

public class Phone implements IDataTransfer {

 

@Override

public void DataTransfer(IConnectionManager cm) {

cm.dial("127XXXXXXXX");

System.out.println("正在通话");

cm.hangup();

}

 

}

public class Client {

 

public static void main(String[] args) {

Phone phone = new Phone();

IConnectionManager cm = new IConnectionManager() {

 

@Override

public void hangup() {

System.out.println("开始拨打电话");

}

 

@Override

public void dial(String phoneNumber) {

System.out.println("挂断电话");

}

};

phone.DataTransfer(cm);

}

}