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级别。这样，你就能够拥有一个安全、同步的操做，它由两个较易理解的函数组成。这两个较低层函数也能够用于其余场合。