正交设计

Design is there to enable you to keep changing the software easily in the long term. -- Kent Beck.

设计是什么

正如Kent Beck所说，软件设计是为了「长期」更加容易地适应未来的变化。正确的软件设计方法是为了长期地、更好更快、更容易地实现软件价值的交付。

软件设计的目标

软件设计就是为了完成如下目标，其可验证性、重要程度依次减低。

• 实现功能

• 易于重用

• 易于理解

• 没有冗余

实现功能

实现功能的目标压倒一起，这也是软件设计的首要标准。如何判定系统功能的完备性呢？通过所有测试用例。

从TDD的角度看，测试用例就是对需求的阐述，是一个闭环的反馈系统，保证其系统的正确性；及其保证设计的合理性，恰如其分，不多不少；当然也是理解系统行为最重要的依据。

易于理解

好的设计应该能让其他人也能容易地理解，包括系统的行为，业务的规则。那么，什么样的设计才算得上易于理解的呢？

• Clean Code

• Implement Patterns

• Idioms

没有冗余

没有冗余的系统是最简单的系统，恰如其分的系统，不做任何过度设计的系统。

• Dead Code

• YAGNI: You Ain't Gonna Need It

• KISS: Keep it Simple, Stupid

易于重用

易于重用的软件结构，使得其应对变化更具弹性；可被容易地修改，具有更加适应变化的能力。

最理想的情况下，所有的软件修改都具有局部性。但现实并非如此，软件设计往往需要花费很大的精力用于依赖的管理，让组件之间的关系变得清晰、一致、漂亮。

那么软件设计的最高准则是什么呢？「高内聚、低耦合」原则是提高可重用性的最高原则。为了实现高内聚，低耦合的软件设计，袁英杰提出了「正交设计」的方法论。

正交设计

「正交」是一个数学概念：所谓正交，就是指两个向量的内积为零。简单的说，就是这两个向量是垂直的。在一个正交系统里，沿着一个方向的变化，其另外一个方向不会发生变化。为此，Bob大叔将「职责」定义为「变化的原因」。

「正交性」，意味着更高的内聚，更低的耦合。为此，正交性可以用于衡量系统的可重用性。那么，如何保证设计的正交性呢？袁英杰提出了「正交设计的四个基本原则」，简明扼要，道破了软件设计的精髓所在。

正交设计原则

• 消除重复

• 分离关注点

• 缩小依赖范围

• 向稳定的方向依赖

实战

需求1： 存在一个学生的列表，查找一个年龄等于18岁的学生

快速实现

1.  
   public static Student findByAge(Student[] students) {
2.  
   for (int i=0; i<students.length; i++)
3.  
   if (students[i].getAge() == 18)
4.  
   return students[i];
5.  
   return null;
6.  
   }

上述实现存在很多设计的「坏味道」：

• 缺乏弹性参数类型：只支持数组类型，List, Set都被拒之门外；

• 容易出错：操作数组下标，往往引入不经意的错误；

• 幻数：硬编码，将算法与配置高度耦合；

• 返回null：再次给用户打开了犯错的大门；

使用for-each

按照「最小依赖原则」，先隐藏数组下标的实现细节，使用for-each降低错误发生的可能性。

1.  
   public static Student findByAge(Student[] students) {
2.  
   for (Student s : students)
3.  
   if (s.getAge() == 18)
4.  
   return s;
5.  
   return null;
6.  
   }

需求2： 查找一个名字为horance的学生

重复设计

Copy-Paste是最快的实现方法，但会产生「重复设计」。

1.  
   public static Student findByName(Student[] students) {
2.  
   for (Student s : students)
3.  
   if (s.getName().equals("horance"))
4.  
   return s;
5.  
   return null;
6.  
   }

为了消除重复，可以将「查找算法」与「比较准则」这两个「变化方向」进行分离。

抽象准则

首先将比较的准则进行抽象化，让其独立变化。

1.  
   public interface StudentPredicate {
2.  
   boolean test(Student s);
3.  
   }

将各个「变化原因」对象化，为此建立了两个简单的算子。

1.  
   public class AgePredicate implements StudentPredicate {
2.  
   private int age;
3.  
    
4.  
   public AgePredicate(int age) {
5.  
   this.age = age;
6.  
   }
7.  
    
8.  
   @Override
9.  
   public boolean test(Student s) {
10.  
    return s.getAge() == age;
11.  
    }
12.  
    }

1.  
   public class NamePredicate implements StudentPredicate {
2.  
   private String name;
3.  
    
4.  
   public NamePredicate(String name) {
5.  
   this.name = name;
6.  
   }
7.  
    
8.  
   @Override
9.  
   public boolean test(Student s) {
10.  
    return s.getName().equals(name);
11.  
    }
12.  
    }

此刻，查找算法的方法名也应该被「重命名」，使其保持在同一个「抽象层次」上。

1.  
   public static Student find(Student[] students, StudentPredicate p) {
2.  
   for (Student s : students)
3.  
   if (p.test(s))
4.  
   return s;
5.  
   return null;
6.  
   }

客户端的调用根据场景，提供算法的配置。

1.  
   assertThat(find(students, new AgePredicate(18)), notNullValue());
2.  
   assertThat(find(students, new NamePredicate("horance")), notNullValue());

结构性重复

AgePredicate和NamePredicate存在「结构型重复」，需要进一步消除重复。经分析两个类的存在无非是为了实现「闭包」的能力，可以使用lambda表达式，「Code As Data」，简明扼要。

1.  
   assertThat(find(students, s -> s.getAge() == 18), notNullValue());
2.  
   assertThat(find(students, s -> s.getName().equals("horance")), notNullValue());

引入Iterable

按照「向稳定的方向依赖」的原则，为了适应诸如List, Set等多种数据结构，甚至包括原生的数组类型，可以将入参重构为重构为更加抽象的Iterable类型。

1.  
   public static Student find(Iterable<Student> students, StudentPredicate p) {
2.  
   for (Student s : students)
3.  
   if (p.test(s))
4.  
   return s;
5.  
   return null;
6.  
   }

需求3： 存在一个老师列表，查找第一个女老师

类型重复

按照既有的代码结构，可以通过Copy Paste快速地实现这个功能。

1.  
   public interface TeacherPredicate {
2.  
   boolean test(Teacher t);
3.  
   }

1.  
   public static Teacher find(Iterable<Teacher> teachers, TeacherPredicate p) {
2.  
   for (Teacher t : teachers)
3.  
   if (p.test(t))
4.  
   return t;
5.  
   return null;
6.  
   }

用户接口依然可以使用Lambda表达式。

assertThat(find(teachers, t -> t.female()), notNullValue());

如果使用Method Reference，可以进一步地改善表达力。

assertThat(find(teachers, Teacher::female), notNullValue());

类型参数化

分析StudentMacher/TeacherPredicate, find(Iterable<Student>)/find(Iterable<Teacher>)的重复，为此引入「类型参数化」的设计。

首先消除StudentPredicate和TeacherPredicate的重复设计。

1.  
   public interface Predicate<E> {
2.  
   boolean test(E e);
3.  
   }

再对find进行类型参数化设计。

1.  
   public static <E> E find(Iterable<E> c, Predicate<E> p) {
2.  
   for (E e : c)
3.  
   if (p.test(e))
4.  
   return e;
5.  
   return null;
6.  
   }

型变

但find的类型参数缺乏「型变」的能力，为此引入「型变」能力的支持，接口更加具有可复用性。

1.  
   public static <E> E find(Iterable<? extends E> c, Predicate<? super E> p) {
2.  
   for (E e : c)
3.  
   if (p.test(e))
4.  
   return e;
5.  
   return null;
6.  
   }

复用lambda

Parameterize all the things.

观察如下两个测试用例，如果做到极致，可认为两个lambda表达式也是重复的。从「分离变化的方向」的角度分析，此lambda表达式承载的「比较算法」与「参数配置」两个职责，应该对其进行分离。

1.  
   assertThat(find(students, s -> s.getName().equals("Horance")), notNullValue());
2.  
   assertThat(find(students, s -> s.getName().equals("Tomas")), notNullValue());

可以通过「Static Factory Method」生产lambda表达式，将比较算法封装起来；而配置参数通过引入「参数化」设计，将「逻辑」与「配置」分离，从而达到最大化的代码复用。

1.  
   public final class StudentPredicates {
2.  
   private StudentPredicates() {
3.  
   }
4.  
    
5.  
   public static Predicate<Student> age(int age) {
6.  
   return s -> s.getAge() == age;
7.  
   }
8.  
    
9.  
   public static Predicate<Student> name(String name) {
10.  
    return s -> s.getName().equals(name);
11.  
    }
12.  
    }

1.  
   import static StudentPredicates.*;
2.  
    
3.  
   assertThat(find(students, name("horance")), notNullValue());
4.  
   assertThat(find(students, age(10)), notNullValue());

组合查询

但是，上述将lambda表达式封装在Factory的设计是及其脆弱的。例如，增加如下的需求：

需求4： 查找年龄不等于18岁的女生

最简单的方法就是往StudentPredicates不停地增加「Static Factory Method」，但这样的设计严重违反了「OCP」(开放封闭)原则。

1.  
   public final class StudentPredicates {
2.  
   ......
3.  
    
4.  
   public static Predicate<Student> ageEq(int age) {
5.  
   return s -> s.getAge() == age;
6.  
   }
7.  
    
8.  
   public static Predicate<Student> ageNe(int age) {
9.  
   return s -> s.getAge() != age;
10.  
    }
11.  
    }

从需求看，比较准则增加了众多的语义，再次运用「分离变化方向」的原则，可发现存在两类运算的规则:

• 比较运算：==, !=

• 逻辑运算：&&, ||

比较语义

先处理比较运算的变化方向，为此建立一个Matcher的抽象：

1.  
   public interface Matcher<T> {
2.  
   boolean matches(T actual);
3.  
    
4.  
   static <T> Matcher<T> eq(T expected) {
5.  
   return actual -> expected.equals(actual);
6.  
   }
7.  
    
8.  
   static <T> Matcher<T> ne(T expected) {
9.  
   return actual -> !expected.equals(actual);
10.  
    }
11.  
    }

Composition everywhere.

此刻，age的设计运用了「函数式」的思维，其行为表现为「高阶函数」的特性，通过函数的「组合式设计」完成功能的自由拼装组合，简单、直接、漂亮。

1.  
   public final class StudentPredicates {
2.  
   ......
3.  
    
4.  
   public static Predicate<Student> age(Matcher<Integer> m) {
5.  
   return s -> m.matches(s.getAge());
6.  
   }
7.  
   }

查找年龄不等于18岁的学生，可以如此描述。

assertThat(find(students, age(ne(18))), notNullValue());

逻辑语义

为了使得逻辑「谓词」变得更加人性化，可以引入「流式接口」的「DSL」设计，增强表达力。

1.  
   public interface Predicate<E> {
2.  
   boolean test(E e);
3.  
    
4.  
   default Predicate<E> and(Predicate<? super E> other) {
5.  
   return e -> test(e) && other.test(e);
6.  
   }
7.  
   }

查找年龄不等于18岁的女生，可以表述为：

assertThat(find(students, age(ne(18)).and(Student::female)), notNullValue());

重复再现

仔细的读者可能已经发现了，Student和Teacher两个类也存在「结构型重复」的问题。

1.  
   public class Student {
2.  
   public Student(String name, int age, boolean male) {
3.  
   this.name = name;
4.  
   this.age = age;
5.  
   this.male = male;
6.  
   }
7.  
    
8.  
   ......
9.  
    
10.  
    private String name;
11.  
    private int age;
12.  
    private boolean male;
13.  
    }

1.  
   public class Teacher {
2.  
   public Teacher(String name, int age, boolean male) {
3.  
   this.name = name;
4.  
   this.age = age;
5.  
   this.male = male;
6.  
   }
7.  
    
8.  
   ......
9.  
    
10.  
    private String name;
11.  
    private int age;
12.  
    private boolean male;
13.  
    }

级联反应

Student与Teacher的结构性重复，导致StudentPredicates与TeacherPredicates也存在「结构性重复」。

1.  
   public final class StudentPredicates {
2.  
   ......
3.  
    
4.  
   public static Predicate<Student> age(Matcher<Integer> m) {
5.  
   return s -> m.matches(s.getAge());
6.  
   }
7.  
   }

1.  
   public final class TeacherPredicates {
2.  
   ......
3.  
    
4.  
   public static Predicate<Teacher> age(Matcher<Integer> m) {
5.  
   return t -> m.matches(t.getAge());
6.  
   }
7.  
   }

为此需要进一步消除重复。

提取基类

第一个直觉，通过「提取基类」的重构方法，消除Student和Teacher的重复设计。

1.  
   class Human {
2.  
   protected Human(String name, int age, boolean male) {
3.  
   this.name = name;
4.  
   this.age = age;
5.  
   this.male = male;
6.  
   }
7.  
    
8.  
   ...
9.  
    
10.  
    private String name;
11.  
    private int age;
12.  
    private boolean male;
13.  
    }

从而实现了进一步消除了Student和Teacher之间的重复设计。

1.  
   public class Student extends Human {
2.  
   public Student(String name, int age, boolean male) {
3.  
   super(name, age, male);
4.  
   }
5.  
   }
6.  
    
7.  
   public class Teacher extends Human {
8.  
   public Teacher(String name, int age, boolean male) {
9.  
   super(name, age, male);
10.  
    }
11.  
    }

类型界定

此时，可以通过引入「类型界定」的泛型设计，使得StudentPredicates与TeacherPredicates合二为一，进一步消除重复设计。

1.  
   public final class HumanPredicates {
2.  
   ......
3.  
    
4.  
   public static <E extends Human>
5.  
   Predicate<E> age(Matcher<Integer> m) {
6.  
   return s -> m.matches(s.getAge());
7.  
   }
8.  
   }

消灭继承关系

Student和Teacher依然存在「结构型重复」的问题，可以通过Static Factory Method的设计方法，并让Human的构造函数「私有化」，删除Student和Teacher两个子类，彻底消除两者之间的「重复设计」。

1.  
   public class Human {
2.  
   private Human(String name, int age, boolean male) {
3.  
   this.name = name;
4.  
   this.age = age;
5.  
   this.male = male;
6.  
   }
7.  
    
8.  
   public static Human student(String name, int age, boolean male) {
9.  
   return new Human(name, age, male);
10.  
    }
11.  
     
12.  
    public static Human teacher(String name, int age, boolean male) {
13.  
    return new Human(name, age, male);
14.  
    }
15.  
     
16.  
    ......
17.  
    }

消灭类型界定

Human的重构，使得HumanPredicates的「类型界定」变得多余，从而进一步简化了设计。

1.  
   public final class HumanPredicates {
2.  
   ......
3.  
    
4.  
   public static Predicate<Human> age(Matcher<Integer> m) {
5.  
   return s -> m.matches(s.getAge());
6.  
   }
7.  
   }

绝不返回null

Billion-Dollar Mistake

在最开始，我们遗留了一个问题：find返回了null。用户调用返回null的接口时，常常忘记null的检查，导致在运行时发生NullPointerException异常。

按照「向稳定的方向依赖」的原则，find的返回值应该设计为Optional<E>，使用「类型系统」的特长，取得如下方面的优势：

• 显式地表达了不存在的语义；

• 编译时保证错误的发生；

1.  
   import java.util.Optional;
2.  
    
3.  
   public <E> Optional<E> find(Iterable<? extends E> c, Predicate<? super E> p) {
4.  
   for (E e : c) {
5.  
   if (p.test(e)) {
6.  
   return Optional.of(e);
7.  
   }
8.  
   }
9.  
   return Optional.empty();
10.  
    }

回顾

通过4个需求的迭代和演进，通过运用「正交设计」和「组合式设计」的基本思想，加深对「正交设计基本原则」的理解。

鸣谢

「正交设计」的理论、原则、及其方法论出自前ThoughtWorks软件大师「袁英杰」先生。英杰既是我的老师，也是我的挚友；他高深莫测的软件设计的修为，及其对软件设计独特的哲学思维方式，是我等后辈学习的楷模。

原文转自： https://segmentfault.com/a/1190000004552525

https://blog.csdn.net/basonson/article/details/50924466