控制结构(5) 必经之地(using)

// 上一篇：局部化（localization）

// 下一篇：最近最少使用（LRU）

---

基于语言提供的基本控制结构，更好地组织和表达程序，需要良好的控制结构。

前情回顾

上一周，我们谈到了分支／卫语句／状态机／局部化。它们是相互补充协作的关系，并且我们都只使用函数就达到了说明的目的。为什么仅仅使用函数来说明呢？回到第一篇提到的分枝／叶子，可以看到，无论上层代码怎样组织，在对象层面做了怎样的抽象封装，最终是要在函数这个级别实现具体的调用动作的。在对象层面的组织，有很多书和文章，但是无论是老手还是新手，都有许多程序员不能良好的组织函数内代码，使得其具有更好的可读／可维护。我们看一个小例子：

function initApp(){
    let appMetaPath = path.join(__dirname,'appmeta.json');
    let packageDir = path.join(__dirname, 'test/packages');
    let appMeta = JSON.parse(fs.readFileSync(appMetaPath));

    let uid = appMeta.uid;
    let token = appMeta.token;

    let app = new Application();
    let appInfo = JSON.parse(fs.readFileSync(path.join(__dirname,'test/packages/app.json')));
    let packageConfigPath = path.join(packageDir,'calculator/config.json');
    let packageConfig = JSON.parse(fs.readFileSync(packageConfigPath));
    app.init(appInfo, function(err,info){
        // ... 用到相关信息
    });

}

很短的一个叶子代码，简单调整顺序改进下：

function initApp(){
    let appMetaPath = path.join(__dirname,'appmeta.json');
    let appMeta = JSON.parse(fs.readFileSync(appMetaPath));

    let appConfigPath = path.join(__dirname,'test/packages/app.json');
    let appInfo = JSON.parse(fs.readFileSync(appConfigPath));

    let pacakgeConfigPath = path.join(__dirname, 'test/packages/calculator/config.json');
    let packageConfig = JSON.parse(fs.readFileSync(pacakgeConfigPath));

    let app = new Application();
    app.init(appInfo,function(err,info){
        //... 用到相关信息
    });
}

其实不复杂，代码如果读起来是顺序结构就更好读，也更利于维护。

典型代码

• 例子1

int write(char* buffer){
    thisLock.lock();
    //....
    if(err1){
        thisLock.unlock();
        return RESULT.ERROR1;
    }
    //...
    if(err2){
        thisLock.unlock();
        return RESULT.ERROR2;
    }
    //...
    thisLock.unlock();
    return RESULT.SUCCESS;
}

• 例子2

function findItemByBindedGroupID(groupID, onComplete){
    var mysql = require('mysql');
    var pool  = mysql.createPool(...);

    pool.getConnection(function(err, connection) {
      connection.query('SELECT * FROM group WHERE ?', {groupID: groupID},
          function (error, groups) {
            if (error||groups.length===0){
                connection.release();
                return onComplete(1);
            }

            let group=groups[0];
            let itemID = group.bindedItemID;
            connection.query('SELECT * FROM item WHERE ?', {itemID:itemID},
                function(error, items){
                    connection.release();
                    if (error||items.length===0){
                        onComplete(1);
                    }else{
                        onComplete(0, items[0]);
                    }
                });
          });
    });
}

结构分析

这是一段典型的打开资源、读／写、关闭资源的操作，问题在于当你要写很多这样的代码时，代码就会显得繁琐，在每个返回分支都要记得关闭资源也是一个很容易被忘记的动作，于是就会出现典型的资源泄露。在不同语言里，如何对资源做自动释放，在日常开发中出现的频率很高。不同语言有不同的做法。例如C++语言里的Lock代码，有多种方式改进它：

• goto方式

int write(char* buffer){
    thisLock.lock();
    int ret = 0;

    //....
    if(err){
        ret = RESULT.ERROR1;
        goto quit;
    }
    //...
    if(err2){
        ret = RESULT.ERROR2;
        goto quit;
    }
    //...
    ret = RESULT.SUCCESS;

    quit:
    thisLock.unlock();
    return ret;
}

• do-while方式

int write(char* buffer){
    thisLock.lock();

    do{
        //...
        if(err){
            ret = RESULT.ERROR1;
            break;
        }
        //...
        if(err2){
            ret = RESULT.ERROR2;
            break;
        }
        // ...
        ret = RESULT.SUCCESS;
    }while(true);

    thisLock.unlock();
}

可以看到，很多人限制了不能用goto，但do-while并不比goto少多少代码，还多了一层嵌套。最后，就是用C++的对象方式（RAII）解决：

• RAII方式

class AutoLock{
    AutoLock(lock){
        this.m_lock = lock;
        this.m_lock.lock();
    }
    ~AutoLock(){
        this.m_lock.unlock();
    }
}
int write(char* buffer){
    AutoLock lock(thisLock); //对象析构的时候自动unlock
    //...
    if(err){
        return RESULT.ERROR1;
    }
    //....
    if(err2){
        return RESULT.ERROR2;
    }
    //...
    return RESULT.SUCCESS;
}

我们再看下JavaScript的例子，同样JavaScript里也有多种做法，例如使用之前提到过的状态机方式，不过此次我们希望只用基本的控制结构和函数来封装，同时不改变代码的通常读法。

class Connection{
    constructor(){
        this.m_database = ...
    }

    open(onComplete) {
        let self = this;
        self.m_database.getPOOL().getConnection(function(err, conn) {
            if (err) {
                self.m_conn = null;
                return onComplete(err);
            }
            self.m_conn = conn;
            onComplete(0);
        });
    }

    close() {
        let self = this;
        if(self.m_conn){
            self.m_conn.release();
            self.m_conn = null;
        }
    }

    executeQuery(action, sql, values, onComplete) {
        let self = this;
        let r = self.m_conn.query(sql, values, function (err, results) {
            if (err) {
                log.error(`do ${action} failed, err:${err}`);
                onComplete(err, results);
            } else {
                log.info(`do ${action} success.`);
                onComplete(0, results);
            }
        });
        log.info(`action: ${action}, sql: ${r.sql}`);
    }

    usingQuery(action, onComplete){
        let self = this;

        /**对onComplete做一层wrapper，调用之前先关闭连接*/
        let hasClose = false;
        let theComplete = function (err, results) {
            if (hasClose) {
                return;
            }
            self.close();
            onComplete(err, results);
        };

        /**只打开连接一次*/
        let hasOpen = false;
        let open = function(callback){
            if (hasOpen){
                return callback(0);
            }
            hasOpen = true;
            self.open(function(err){
                callback(err);
            });
        };

        /**
          * 返回一个查询上下文，包含：
          * - 带自动关闭连接的onComplete
          * - 在首次查询时自动open的query接口，
          */
        let context = {
            onComplete: theComplete,
            query: function(sql, values, callback){
                open(function(err){
                    if(err){
                        callback(err);
                    }else{
                        self.executeQuery(action, sql, values, callback);
                    }
                });
            }
        };

        return context;
    }
}

于是，我们可以这样使用，现在只需关心查询本身的逻辑即可：

function findItemByBindedGroupID(groupID, onComplete){
    let conn = new Connection();
    let context = conn. usingQuery('findItemByBindedGroupID', onComplete);

    context.query('SELECT * FROM group WHERE ?', {groupID: groupID},
        function (error, groups) {
            if (error||groups.length===0){
                return context.onComplete(1);
            }

            let group=groups[0];
            let itemID = group.bindedItemID;
            context.query('SELECT * FROM item WHERE ?', {itemID:itemID},
                function(error, items){
                    if (error||items.length===0){
                        return context.onComplete(1);
                    }

                    context.onComplete(0, items[0]);
                });
        });
}

语义分析

打开资源，对资源做一些操作，关闭资源。看上去很简单的一组动作，如果遇到中间有多次操作，每次操作都可能有错误，每次错误的时候都需要释放资源，即容易忘记，又繁琐。

我们只要能识别函数退出路径里必经之地，对必经之地做一层浅浅的hook，就能实现资源自动释放动作。

例如，在C++里，函数超出作用域之后，一定会调用栈上对象的析构函数，语言提供了这种保证，我们就可以在这个函数退出必经之地做自动释放。

例如，在JavaScript里，异步调用的时候，我们可以依赖于一个前置假设：“异步接口一定通过回掉函数退出”，那么我们就可以对这个异步回调的必经之地做一个浅封装，达到资源的自动释放目的，同时又不会剧烈改变代码的直观逻辑。

例如，C#语言内置提供了using语句，使得在using作用域退出的时候能自动释放实现了IDispose接口的对象。