Separate Query from Modifier (将查询函数和修改函数分离)

Summary： 某个函数即返回对象状态值，又修改对象状态。建立两个不同的函数，其中一个负责查询，另一个负责修改。                                               

动机:

  如果某个函数只是向你提供一个值，没有任何看得见的副作用，那么这是个很有价值的东西。你可以任意调用这个函数，也可以把调用动作搬到函数的其他地方。简而言之，需要操心的事情少多了。

明确表现出“有副作用”与“无副作用”两种函数之间的差异，是个很好的想法。下面是一条好规则：任何有返回值的函数，都不应该有看得到的副作用。有些程序员甚至将此作为一条必须遵守的规则。就像对待任何东西一样，我们并不需要绝对遵守它，不过还是要尽量遵守。

如果你遇到一个“既有返回值又有副作用”的函数，就应该试着将查询动作从修改动作中分割出来。

你也许已经注意到了：我们使用“看得到的副作用”这种说法。有一种常见的优化办法是：将查询所得结果缓存与某个字段中，这么一来后续的重复查询就可以大大加快速度。虽然这种做法改变了对象的状态，但这一修改是察觉不到的，因为无论如何查询，你总是获得相同结果。

做法:

1.新建一个查询函数，令它返回的值与原函数相同。

à观察原函数，看它返回什么东西。如果返回的是一个临时变量，找出临时变量的位置。

2.修改原函数，令它调用查询函数，并返回获得的结果。

à原函数中的每个return语句都应该像这样：return new Query(),而不应该返回其他东西。

à如果调用者将返回值赋给了一个临时变量，你应该能够去除这个临时变量。

3.编译，测试。

4.将调用原函数的代码改为调用查询函数。然后，在调用查询函数的那一行之前，加上对原函数的调用。每次修改后，编译并测试。

5.将原函数的返回值改为void，并删掉其中所有的return语句。

        范例：

        有这样一个函数：一旦有人入侵安全系统，它会告诉我们入侵者的名字，并发送一个警报。如果入侵者不止一个，也只发送一条警报：

String foundMiscreant(String[] people){
    for(int i=0; i < people.lenght; i++){
        if(people[i].equals("Don")){
            sendAlert();
            return "Don";
        }
        if(people[i].equals("John")){
            sendAlert();
            return "John";
        }
    }
    return "";
}

改函数被下列代码调用

void checkSecurity(String[] people){
    String found = foundMiscreant(people);
    someLaterCode(found);
}

为了将查询动作和修改动作分开，首先建立一个适当的查询函数，使其与修改函数返回相同的值，但不造成任何副作用：

String foundPerson(String[] people){
    for(int i=0; i < people.lenght; i++){
        if(people[i].equals("Don")){
            return "Don";
        }
        if(people[i].equals("John")){
            return "John";
        }
    }
    return "";
}

然后逐一替换原函数内所有的return语句，改调用新建的查询函数。每次替换后，编译并测试。这一步完成之后，原函数如下所示：

String foundMiscreant(String[] people){
    for(int i=0; i < people.lenght; i++){
        if(people[i].equals("Don")){
            sendAlert();
            return foundPerson(people);
        }
        if(people[i].equals("John")){
            sendAlert();
            return foundPerson(people);
        }
    }
    return foundPerson(people);
}

现在，修改调用者，将原本单一调用动作替换为两个调用：先调用修改函数，然后调用查询函数：

void checkSecurity(String[] people){
    foundMiscreant(people);
    String found = foundPerson(people)；
    someLaterCode(found);
}

所有调用都替换完毕后，就可以将修改函数的返回值改为void

void foundMiscreant(String[] people){
    for(int i=0; i < people.lenght; i++){
        if(people[i].equals("Don")){
            sendAlert();
            return;
        }
        if(people[i].equals("John")){
            sendAlert();
            return;
        }
    }
}

现在，为原函数改个名称可能会更好些：

void sendAlert(String[] people){
    for(int i=0; i < people.lenght; i++){
        if(people[i].equals("Don")){
            sendAlert();
            return;
        }
        if(people[i].equals("John")){
            sendAlert();
            return;
        }
    }
}

当然，这种情况下，我们得到了大量重复代码，因为修改函数之中使用了与查询函数相同的代码。现在我们可以对修改函数实施Substitute Algorithm，设法让它再简洁一些：

void sendAlert(String[] people){
    if(!foundPerson(people).equals("")){
        sendAlert();
    }
}

并发问题：

   如果你在一个多线程系统工作，肯定知道这样一个重要的惯用手法：在同一个动作中完成检查和赋值。这是否和Separate Query from Modifier互相矛盾呢？其实不，但你需要做一些额外工作。将查询动作和修改动作分开来任然是很有价值的。但你需要保留第三个函数，并声明为synchronized。如果查询函数和修改函数未被声明为synchronized，那么你还应该将它们的可见范围限制在包级别或private级别。这样，你就可以拥有一个安全、同步的操作，它由两个较易理解的函数组成。这两个较低层函数也可以用于其他场合。

转载于:https://my.oschina.net/u/134516/blog/214977