EventProxy流程控制

EventProxy是一个通过控制事件触发顺序来控制业务流程的工具。

Node.js的亮点是回调函数，node.js流程控制、传参都是通过回调函数来实现的。开发中经常会遇到回调嵌套的场景，尤其是在业务复杂的场景下，会嵌套n层回调函数，这样做的原因是为了控制代码执行的流程。

下面是一个需要同步读取文件的例子

var str = '';
fs.readFile('file1.txt', function(err, data1) {
    str += data1;
    fs.readFile('file2.txt', function(err, data2) {
        str += data2;
        fs.readFile('file3.txt', function(err, data3) {
            str += data3;
        });
    });
});

上面代码有3层回调嵌套，用嵌套来保障文件的顺序读取。这样代码可读性就比较差了，而开发中用到的嵌套往往有很多层，代码很难读。

我们用EventProxy来解耦

安装：npm install eventproxy

引包：var EventProxy = require('eventproxy');
            var ep = new EventProxy();

1、异步协作 all

多个操作并行执行，每个操作完成后触发一个自定义事件.ep.all监听所有操作触发的事件，然后在回调函数里面提供各事件提供的结果

ep.all('read1', 'read2', 'read3', function(data1, data2, data3) {
    //监听事件，所有事件都触发完成后，在这里汇总结果
    console.info(data1 + '~' + data2 + '~' + data3);
});
fs.readFile('file1.txt', function(err, data1) {
    ep.emit('read1', data1);//触发事件
});
fs.readFile('file2.txt', function(err, data2) {
    ep.emit('read2', data2);//触发事件
});
fs.readFile('file3.txt', function(err, data3) {
    ep.emit('read3', data3);//触发事件
});

2、重复异步协作 after

`after`方法适合重复的操作，比如读取10个文件，调用5次数据库等。将handler注册到N次相同事件的触发上。达到指定的触发数，handler将会被调用执行，每次触发的数据，将会按触发顺序，存为数组作为参数传入。

var files = ['file1.txt', 'file2.txt', 'file3.txt'];
ep.after('readfile', files.length, function(list) {
    // 在所有文件的异步执行结束后将被执行
    // 所有文件的内容都存在list数组中

//list中值是无序的，因为for循环中ep.emit触发顺序是无序的（node异步特点），排列顺序取决于node事件触发的顺序。可以通过group来控制对应关系，后续讲。

});

for (var i = 0; i < files.length; i++) {
    fs.readFile(files[i], function(err, data) {
        // 触发结果事件
        ep.emit('readfile', data);
    });
}

3、持续性异步事件 tail

此处以股票为例，数据和模板都是异步获取，但是数据会持续刷新，视图会需要重新刷新。

ep.tail('tpl', 'data', function (tpl, data) {
  // 在所有指定的事件触发后，将会被调用执行，如果事件依旧保持触发，这里依旧多次执行
  // 参数对应各自的事件名的最新数据
});
fs.readFile('template.tpl', 'utf-8', function (err, content) {
  ep.emit('tpl', content);
});
setInterval(function () {
  db.get('some sql', function (err, result) {
    ep.emit('data', result);
  });
}, 2000);

`tail`与`all`方法比较类似，都是注册到事件组合上。不同在于，all指定事件都触发后则执行一次，tail指定事件都触发之后，执行一次，如果事件依旧持续触发，将会在每次触发时调用handler，回调函数不断返回结果，极像一条尾巴。

4、异常处理

4.1 ep.bind('error')

ep.all('file1', 'file2', 'file3', function(data1, data2, data3) {
   
});

//监听error事件
ep.bind('error', function(err) {
    // 卸载所有的handler，ep.all的将停止运行，function也不会返回结果
    ep.unbind();
});

fs.readFile('file1.txt', function(err, data1) {
    if (err) {
        // 一旦发生异常，交给error事件的handler处理
        return ep.emit('error', err);
    }
    ep.emit('file1', data1 + new Date());
});

fs.readFile('file2.txt', function(err, data2) {
    if (err) {
        // 一旦发生异常，交给error事件的handler处理
        return ep.emit('error', err);
    }
    ep.emit('file2', data2 + new Date());
});

fs.readFile('file3.txt', function(err, data3) {
    if (err) {
        // 一旦发生异常，交给error事件的handler处理
        return ep.emit('error', err);
    }
    ep.emit('file3', data3);
});

4.2 ep.fail()

ep.all('file1', 'file2', 'file3', function(data1, data2, data3) {
    console.info(data1 + '~~' + data2 + '~~' + data3);
});

//监听error事件
ep.fail(function (err) {
    //捕获err
});

fs.readFile('file1.txt', ep.done('file1'));
fs.readFile('file2.txt', ep.done('file2'));
fs.readFile('file3.txt', ep.done('file3'));

`fail`方法侦听了`error`事件，默认处理卸载掉所有handler，并调用回调函数。`fail`除了用于协助`all`方法完成外，也能协助`after`中的异常处理。

ep.fail(function(err) {});
等价于
ep.bind('error',function(err) {
    ep.unbind();
});
ep.done('file1');

等价于

function (err, content) {
  if (err) {
    // 一旦发生异常，一律交给error事件的handler处理
    return ep.emit('error', err);
  }
  ep.emit('file1', content);
}

当然手工emit的方式并不太好，我们更进一步的版本：

ep.done('file1', function (tpl) {
  // 将内容更改后，返回即可
  return file1.trim();
});

##注意事项

如果emit需要传递多个参数时，ep.done('file1',function(){})的方式不能满足需求，还是需要ep.done(function(){})，进行手工emit多个参数。

5、ep.group()

在`after`的回调函数中，结果顺序是与用户`emit`的顺序有关。为了满足返回数据按发起异步调用的顺序排列，`EventProxy`提供了`group`方法。

var files = ['file1.txt', 'file2.txt', 'file3.txt'];
ep.after('readfile', files.length, function(list) {
    // 在所有文件的异步执行结束后将被执行
    // 所有文件的内容都存在list数组中，for循环ep.emit事件是同步的，所以list中的值是有序的。
    console.info(new Buffer(list[0])+"~~"+new Buffer(list[1])+"~~"+new Buffer(list[2]));
});

for (var i = 0; i < files.length; i++) {
    fs.readFile(files[i], ep.group('readfile'));
}

`group`秉承`done`函数的设计，它包含异常的传递。同时它还隐含了对返回数据进行编号，在结束时，按顺序返回。

ep.group('readfile');
// 约等价于
function (err, data) {
  if (err) {
    return ep.emit('error', err);
  }
  ep.emit('readfile', data);
};

当回调函数的数据还需要进行加工时，可以给`group`带上回调函数，只要在操作后将数据返回即可：

ep.group('readfile', function (data) {
  // some code
  return data;
});

6、异步事件触发: emitLater && doneLater

在node中，`emit`方法是同步的，EventProxy中的`emit`，`trigger`等跟node的风格一致，也是同步的。看下面这段代码，可能眼尖的同学一下就发现了隐藏的bug:

var ep = EventProxy.create();

db.check('key', function (err, permission) {
  if (err) {
    return ep.emit('error', err);
  }
  ep.emit('check', permission);
});

ep.once('check', function (permission) {
  permission && db.get('key', function (err, data) {
    if (err) {
      return ep.emit('error');
    }
    ep.emit('get', data);
  });
});

ep.once('get', function (err, data) {
  if (err) {
    retern ep.emit('error', err);
  }
  render(data);
});

ep.on('error', errorHandler);

没错，万一`db.check`的`callback`被同步执行了，在`ep`监听`check`事件之前，它就已经被抛出来了，后续逻辑没办法继续执行。尽管node的约定是所有的`callback`都是需要异步返回的，但是如果这个方法是由第三方提供的，我们没有办法保证`db.check`的`callback`一定会异步执行，所以我们的代码通常就变成了这样:

var ep = EventProxy.create();

ep.once('check', function (permission) {
  permission && db.get('key', function (err, data) {
    if (err) {
      return ep.emit('error');
    }
    ep.emit('get', data);
  });
});

ep.once('get', function (err, data) {
  if (err) {
    retern ep.emit('error', err);
  }
  render(data);
});

ep.on('error', errorHandler);

db.check('key', function (err, permission) {
  if (err) {
    return ep.emit('error', err);
  }
  ep.emit('check', permission);
});

我们被迫把`db.check`挪到最后，保证事件先被监听，再执行`db.check`。`check`->`get`->`render`的逻辑，在代码中看起来变成了`get`->`render`->`check`。如果整个逻辑更加复杂，这种风格将会让代码很难读懂。

这时候，我们需要的就是 __异步事件触发__：

var ep = EventProxy.create();

db.check('key', function (err, permission) {
  if (err) {
    return ep.emitLater('error', err);
  }
  ep.emitLater('check', permission);
});

ep.once('check', function (permission) {
  permission && db.get('key', function (err, data) {
    if (err) {
      return ep.emit('error');
    }
    ep.emit('get', data);
  });
});

ep.once('get', function (err, data) {
  if (err) {
    retern ep.emit('error', err);
  }
  render(data);
});

ep.on('error', errorHandler);

上面代码中，我们把`db.check`的回调函数中的事件通过`emitLater`触发，这样,就算`db.check`的回调函数被同步执行了，事件的触发也还是异步的，`ep`在当前事件循环中监听了所有的事件，之后的事件循环中才会去触发`check`事件。代码顺序将和逻辑顺序保持一致。
当然，这么复杂的代码，必须可以像`ep.done()`一样通过`doneLater`来解决：

var ep = EventProxy.create();

db.check('key', ep.doneLater('check'));

ep.once('check', function (permission) {
  permission && db.get('key', ep.done('get'));
});

ep.once('get', function (data) {
  render(data);
});

ep.fail(errorHandler);

最终呈现出来的，是一段简洁且清晰的代码。

## 注意事项
- 请勿使用`all`作为业务中的事件名。该事件名为保留事件。
- 异常处理部分，请遵循Node的最佳实践(回调函数首个参数为异常传递位)。

参考文献：

EventProxy Readme