设计模式学习笔记 - 设计原则 - 7.DRY 原则及提高代码复用性

前言

DRY 原则,英文描述为: Don't Repeat Yourself。中文直译:不要重复自己。将它应用在编程中,可理解为:不要写重读的代码。

可能你认为,这个原则很简单。只要两段代码长得一样,那就是违反 DRY 原则了。真的是这样吗? 答案是否定的。这是很多人对这条原则存在的误解。实际上,重读的代码不一定违反 DRY 原则,而有些看似不重复的代码也可能违反 DRY 原则。


DRY 原则(Don't Repeat Yourself)

DRY 原则的定义非常简单,我就不再过度解读了。今天,主要将三种典型的代码重复情况,它们分别是:实现逻辑重复、功能语义重复和代码执行重复。这三种代码重复,有些看似违反 DRY 原则,实际上并不违反;有的看似不违反,实际上却违反了。

实现逻辑重复

先看一段代码

java 复制代码
public class UserAuthenticator {
    public void authenticate(String username, String password) {
        if (!isValidUsername(username)) {
            // throw new InvalidUsernameException...
        }
        if (!isValidPassword(password)) {
            // throw new InvalidPasswordException...
        }
        // 省略其他代码...
    }
    
    private boolean isValidUsername(String username) {
        if (StringUtils.isEmpty(username)) { return false; }
        // check length: 4-64
        int length = username.length();
        if (length < 4 || length > 64) { return false; }
        // contains only lower case letters
        if (StringUtils.isAllLowerCase(username)) { return false; }
        // contains only z~z,0~9,dot
        for (int i = 0; i < length; ++i) {
            char c = username.charAt(i);
            if (!((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '.')) { return false; }
        }
        return true;
    }

    private boolean isValidPassword(String password) {
        if (StringUtils.isEmpty(password)) { return false; }
        // check length: 4-64
        int length = password.length();
        if (length < 4 || length > 64) { return false; }
        // contains only lower case letters
        if (StringUtils.isAllLowerCase(password)) { return false; }
        // contains only z~z,0~9,dot
        for (int i = 0; i < length; ++i) {
            char c = password.charAt(i);
            if (!((c >= 'a' && c <= 'z') || !(c >= '0' && c <= '9') || c != '.')) { return false; }
        }
        return true;
    }
}

在代码中,有两处非常重复的代码片段: isValidUsername()isValidPassword()。重复的代码被敲了两遍,看起来明显违反了 DRY 原则。为了移除重复的代码,我们进行下重构,将 isValidUsername()isValidPassword() 合并Wie一个更通用的函数, isValidUsernameOrPassword()

java 复制代码
public class UserAuthenticator {
    public void authenticate(String username, String password) {
        if (!isValidUsernameOrPassword(username)) {
            // throw new InvalidUsernameException...
        }
        if (!isValidUsernameOrPassword(password)) {
            // throw new InvalidPasswordException...
        }
        // 省略其他代码...
    }

    private boolean isValidUsernameOrPassword(String usernameOrPassword) {
        if (StringUtils.isEmpty(usernameOrPassword)) { return false; }
        // check length: 4-64
        int length = usernameOrPassword.length();
        if (length < 4 || length > 64) { return false; }
        // contains only lower case letters
        if (StringUtils.isAllLowerCase(usernameOrPassword)) { return false; }
        // contains only z~z,0~9,dot
        for (int i = 0; i < length; ++i) {
            char c = usernameOrPassword.charAt(i);
            if (!((c >= 'a' && c <= 'z') || !(c >= '0' && c <= '9') || c != '.')) { return false; }
        }
        return true;
    }
}

重构之后,代码行数减少了,也没有重复代码了,是不是更好呢?

单从名字上看,合并之后的 isValidUsernameOrPassword() 函数,负责两件事情:验证用户名和密码,违反了单一职责原则和接口隔离原则。实际上,即便将两个函数合并成 isValidUsernameOrPassword() ,代码仍然存在问题。

因为 isValidUsername()isValidPassword(),虽然代码实现逻辑上看起来是重复的,但是从语义上并不重复。尽管在目前的设计中,两个校验逻辑完全一样,但是如果按照第二种写法,将两个函数合并,那就回农村在潜在的问题。在未来的某一天,如果我们修改了密钥校验逻辑,比如,允许密码包含大写字符,允许密码长度为 8 到 64 个字符,那这个时候, isValidUsername()isValidPassword() 的实现逻辑就会不相同。我们需要把合并后的函数,重新拆分成合并前的两个函数。

所谓 "语义不重复" 是指:从功能上看,这两个函数干的是完全不重复的事情,一个是校验用户名,一个是校验密码。

尽管代码的实现逻辑相同,但语义不同,我们判定它并不违反 DRY 原则 。对于包含重复代码的问题,我们可以通过抽象成更细粒度函数的方式来解决。比如将校验只包含 a-z、0-9、dot 的逻辑都封装成函数。

功能语义重复

在看另一个例子。在同一个项目代码中有下面两个函数: isValidIp()checkIfIpValid()。尽管命名不同、实现逻辑不同,但是功能是相同的,都是用来判定 IP 是否合法的。

出现这个现象的原因,可能是其中的一个同事不知道已有了 isValidIp() 的情况下,自己又定义并实现了相同用来校验 IP 地址是否合法的 checkIfIpValid() 函数。

这两个函数如下所示,它们是否违反了 DRY 原则?

java 复制代码
public boolean isValidIp(String ip) {
    if (StringUtils.isBlank(ip)) { return false; }
    String regex = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\." 
            + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\." 
            + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\." 
            + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$";
    return ip.matches(regex);
}

public boolean checkIfIpValid(String ip) {
    if (StringUtils.isBlank(ip)) { return false; }
    String[] ipUnits = StringUtils.split(ip, ".");
    if (ipUnits.length != 4) { return false; }
    for (int i = 0; i < ip.length(); i++) {
        int ipUnitIntValue;
        try {
            ipUnitIntValue = Integer.parseInt(ipUnits[i]);
        } catch (NumberFormatException e) {
            return false;
        }
        if (ipUnitIntValue < 0 || ipUnitIntValue > 255) { return false; }
        if (i == 0 && ipUnitIntValue == 0) { return false; }
    }
    return true;
}

在这个例子中,尽管两段代码的实现逻辑不重复,但语义重复(即功能重复),我们认为它们违反了 DRY 原则

我们应该在项目中,统一一种实现思路,所有用到判断 IP 地址是否合法的地方,都统一调用一个函数。

假设,我们不统一实现思路,有些地方调用了 isValidIp(),有些地方又调用了 checkIfIpValid(),这就会导致代码看起来很奇怪,相当于给代码 "挖坑",给不熟悉的这部分代码的同事增加了阅读难度。同事可能研究了半天,觉得功能一样,但又有点疑问,觉得是不是有更高深的考量,才定义了两个功能类似的函数,最终发现居然是代码设计的问题。

另外,如果哪天项目中 IP 地址是否合法的判定逻辑改了,比如: 255.255.255.255 判定不合法,相应地,我们对 isValidIp() 的实现逻辑做了修改,但却忘记修改 checkIfIpValid(),这样就会导致有些代码仍然用老的 IP 判定逻辑,导致出现一些莫名其妙的 BUG。

代码执行重复

前两个例子,一个是实现逻辑重复,一个是语义重复,在看下第三个例子。其中 UserServicelogin() 用来校验用户登录是否成功。如果失败,就返回异常;如果成功就返回用户信息。具体代码如下所示:

java 复制代码
public class UserService {
    private UserRepo userRepo; // 通过依赖注入或者IOC框架注入
    
    public User login(String email, String password) {
        boolean existed = userRepo.checkIfUserExisted(email, password);
        if (!existed) {
            // throw AuthenticationFailureException...
        }
        User user = userRepo.getUserByEmail(email);
        return user;
    }
}

public class UserRepo {
    public boolean checkIfUserExisted(String email, String password) {
        if (EmailValidation.validate(email)) {
            // throw InvalidEmailException...
        }
        
        if (PasswordValidation.validate(password)) {
            // throw InvalidPasswordException...
        }
        // query db to check if email&password exists...
    }
    
    public User getUserByEmail(String email) {
        if (EmailValidation.validate(email)) {
            // throw InvalidEmailException...
        }
        // query db to get user by email...
    }
}

上面的代码,既没有逻辑重复,也没有语义重复,但仍然违反了 DRY 原则。这是因为代码存在 "执行重复"

重复执行最明显的地阿福,就是在 login() 中,email 的校验逻辑执行了两次。一次是在调用 checkIfUserExisted() 函数的时候,另一次是调用 getUserByEmail() 的时候。这个问题解决起来比较简答,只要将校验逻辑从 UserRepo 中移除,统一放到 UserService 中就可以了。

此外,代码中,还有移除比较隐藏的执行重复: login() 函数并不需要调用 checkIfUserExisted(),只需要调用一次 getUserByEmail() ,从数据库中获取用户的 email、password 等信息,然后跟输入的 email、password 信息做比对,判断是否登录成功。

这样的优化是很有必要的。因为 checkIfUserExisted()getUserByEmail() 都需要查询数据库,而数据库类的 I/O 操作是比较耗时的。我们在写代码的时候,应该尽量减少 I/O 操作。

按照刚刚的思路,我们重构下代码。

java 复制代码
public class UserService {
    private UserRepo userRepo; // 通过依赖注入或者IOC框架注入

    public User login(String email, String password) {
        if (EmailValidation.validate(email)) {
            // throw InvalidEmailException...
        }
        if (PasswordValidation.validate(password)) {
            // throw InvalidPasswordException...
        }
        User user = userRepo.getUserByEmail(email);
        if (user == null || !password.equals(user.getPassword())) {
            // throw AuthenticationFailureException...
        }
        return user;
    }
}

public class UserRepo {
    public boolean checkIfUserExisted(String email, String password) {
        // query db to check if email&password exists...
    }

    public User getUserByEmail(String email) {
        // query db to get user by email...
    }
}

代码复用性(Code Reusability)

什么是代码的复用性?

首先区分三个概念: 代码复用性(Code Reusability)、代码复用(Code Reuse)、DRY 原则。

  • 代码复用表示一种行为:我们在开发新功能的时候,尽量复用已存在的代码。
  • 代码复用性表示一段代码可被复用的特性或能力:我们在编写代码的时候,尽量让代码可复用。
  • DRY 原则是一条原则:不要写重复的代码。

首先,"不重复" 不代表 "可复用"。在一个项目中,可能不存在任何重复的代码,但也不表示里面有可复用的代码,不重复和可复用完全是两个概念。所以,从这个角度来说,DRY 原则和可复用性将的是两回事。

其次,"复用" 和 "可复用性" 关注角度不同 。代码 "可复用性 " 是从代码开发者 的角度来讲的,"复用 " 是从代码使用者 角度来讲的。比如 A 同事编写了一个 UrlUrils 类,代码的 "可复用性" 很好。同事 B 在开发新功能是,直接 "复用" A 同事编写的 UrlUrils 类。

虽然复用性、复用、DRY 原则这三者从理解上有区别,但是它们的目的是一样的,都是为了较少代码量,提高代码的可读性、可维护性。此外,复用已经过测试的老代码,bug 会比从零开发的要少。

"复用" 这个概念不仅可以指导细粒度的模块、类、函数的设计开发,实际上,一些框架、类库、组件等的生产也都是为了达到复用的目的。比如,Spring 框架、UI 组件等等。

怎么提高代码复用性?

一共有 7 条规则:

  • 减少代码耦合。对于高耦合的代码,当希望复用其中的一个功能,想把这个功能的代码抽取出来成为一个独立的模块、类或者函数时,往往会牵一发而动全身。所以,高耦合度的代码会影响到代码的可复用性。
  • 满足单一职责原则。 前面讲过,如果职责不够单一,模块、类设计得大而全,那就增加了代码的耦合度(依赖它的,它依赖的代码就会比较多)。也会影响到代码的可复用性。相反,粒度越细的代码,代码的通用性会越好,容易被复用。
  • 模块化。这里的 "模块",不单单只一组类构成的模块,还可以理解为单个类、函数。我们要善于将功能独立的代码,封装成模块。独立的模块就像积木,更加容易复用,直接拿来搭建更加复杂的系统。
  • 业务与非业务逻辑分离。越是和业务无关的代码余额容易复用,越是针对特定业务的代码越难复用。所以,为了复用跟业务无关的代码,我们将业务和非业务逻辑代码分离,抽取成一些通用的框架、类库、组件等。
  • 通用代码下层。从分层角度来看,越底层的代码越通用、会被越多的模块调用,越应该设计得足够可复用。一般情况下,在代码分层之后,为了避免交叉调用导致调用关系混乱,我们只允许上层代码调用下层代码及同层代码,杜绝下层代码调用上层代码。所以,通用的代码我们尽量下沉到更下层。
  • 继承、多态、抽象、封装。在讲面向对象特性的时候,我们讲过,利用继承可以将公共代码抽取到父类,子类复用父类的属性和方法。利用多态,可以动态替换一段代码的部分逻辑,让这段代码可复用。此外,抽象和封装,从更加广义的层面、而非狭义的面向对象特性层面来理解的话,越抽象、越不依赖具体实现,越容易复用。代码封装成模块,隐藏可变细节、暴露不变的接口,就越容易复用。
  • 应用模板等设计模式。一些设计模式,也能提高代码复用性。比如,模板模式利用了多态技术来实现,可以灵活地替换其中的部分代码,整个流程模板代码可复用。

除了上面讲到的 7 点,还有一些跟编程语言相关的特性,也可以提高代码的复用性,比如泛型编程等。另外,除了上面讲到的知识,复用意识也很重要。在写代码的时候,要取多思考,这部分代码是否可以抽取出来,作为一个独立模块、类或者函数供多出使用。在设计每个模块、类、函数的时候,要像设计一个外部 API 一样,去思考它的复用性。

辩证思考和灵活应用

编写可复用的代码并不简单。如果在编写代码时,已经有复用的需求场景,那根据复用的需求去开发可复用的代码,可能还不算难。但是,如果当下没有复用的需求,只是希望现在编写的代码具有可复用的特点,能在未来某个同事开发某个新功能时复用得上。在这种没有具体复用需求的情况下,就需要去预测未来代码会如何复用,这就比较有挑战了。

实际上,除非有明确的复用需求,否则,为了暂时用不到的复用需求,花费太多时间、精力,投入太多成的开发成本,并不是一个值得推荐的做法。也违反我们之前讲到的 YAGNI 原则。

实际上,我们在第一次写代码的时候如果当下没有复用的需求,而未来的需求也不是特别明确,并且开发复用代码的成本比较高 ,那我们就不需要考虑它的复用性。在之后,开发新能够的时候,发现可以复用的之前的代码,那我们就重构它,让其变得更加复用。

总结

1.DRY 原则

讲解了三种重复的情况:实现逻辑重复、语义重复、执行逻辑重复。

  • 实现逻辑重复,但功能语义不重复,并不违反 DRY 原则。
  • 实现逻辑不重复,但是功能语义重复,则违反了 DRY 原则。
  • 此外,代码执行重复也是违反 DRY 原则。

2.代码复用性

提高代码可复用性的 7 点方法:

  • 减少代码耦合
  • 满足单一职责原则
  • 模块化
  • 业务与非业务逻辑分离
  • 通用代码下沉
  • 继承、多态、抽象、封装
  • 应用模板等设计模式

除了上面降到的方法外,复用意识也非常重要。在设计每个模块、类、函数时,要像设计一个外部 API 一样思考它的复用性。

在第一编写代码时,如果当下没有复用需求,而未来的复用需求也不是特别明确,并且开发可复用代码的成本比较高,那我们就不需要考虑代码的复用性。在之后开发新功能时,发现可以复用之前的代码,那我们就重构这段代码,让其变得更加可复用。

相对于代码可复用,DRY 原则适用性更强一些。我们可以不写可复用的代码,但一定不能写重复的代码。