BT

如何利用碎片时间提升技术认知与能力? 点击获取答案

博文共赏:在Node.js中使用声明式缓存

| 作者 吴颖昕 关注 0 他的粉丝 发布于 2013年12月12日. 估计阅读时间: 22 分钟 | GMTC大前端的下一站,PWA、Web框架、Node等最新最热的大前端话题邀你一起共同探讨。

Why

写了多年的 Java 程序,即使在转投 Node 之后,仍然对 Spring 框架 的 IoC 、Declarative XXX 记忆犹新,以至于当 Node 项目要用到缓存时,自然地想起了 Declarative caching,就有了山寨一把的想法。。。

问题

为什么用缓存就不说了,地球猿都知道,直接看问题,假设我们有一个查询客户信息的函数:

/** Find customer from db by id.
  @param id [Integer|String] customer id
  @param cb [Function] callback (err, customer)
*/
function findCustomer(id, cb) {
  db.query("SELECT * FROM tbl_customers WHERE id = ?", [id], cb);
}
  • 本文的示例代码假设读者了解 Node 及异步编程,如果了解 Underscore.js, Async.js 会更有帮助
  • 简单起见,示例代码忽略了数据库/Cache Server 连接的建立、释放,以及部分的异常处理

要对 customers 进行缓存,无非是先检查 cache ,命中则直接返回,否则查询数据库,先缓存结果然后返回。 最显而易见的实现大概是这样的:

// The cached version of findCustomer.
function findCustomerWithCache(id, cb) {
  fromCache('customer:' + id, function(err, cust) {
    if (err) return cb(err);

    if (cust) {  // cache hit
      cb(null, cust);
    }
    else {  // cache missed
      loadAndCacheCustomer(id, cb);
    }
  });
}

以下是辅助函数的定义,假设 cached 是我们使用的缓存服务实例:

/** Try to retrieve item with key k from cache.
  @param k [String] key of the cached item
  @param cb [Function] callback (err, v) v is the cached item, false if NOT found
*/
var fromCache = cached.get;

/** Save value v to cache with key k.
  @param dur [Integer] seconds before cache expires
  @param k [String] key of the cached item
  @param v [Any] item to be cached
  @param cb [Function] callback (err, v)
*/
function toCache(dur, k, v, cb) {
  cached.set(k, v, dur, function(err) {
    cb(err, v);
  });
}

// find customer from db, and cache it before return the result
function loadAndCacheCustomer(id, cb) {
  var _cacheCust, _loadAndCache;
  _cacheCust = function(cust, cb) {
    toCache(86400, 'customer:' + id, cust, cb);  // caching for 1 day
  };

  _loadAndCache = async.compose(_cacheCust, findCustomer);
  _loadAndCache(id, cb);
}

很好,现在调用 findCustomerWithCache 函数就能够利用到缓存了。

现在的问题是:

  1. 凡是有一个需要缓存的 findXXX 函数,都要编写配套的 findXXXWithCache loadAndCacheXXX
  2. 使用或不使用缓存,需要调用不同的函数,这意味着一旦切换,就要修改所有的函数调用处

利用高阶函数重用代码

首先考虑通过函数重用来解决第一个问题:如果有一个通用的函数能够代为处理缓存相关的事务,只在缓存没有命中时调用实际的查询过程,就达到目的了。

API 设计

设计一个函数 (api) 最好的方法就是首先把期望的使用形式写出来。所以这个关于缓存的高阶函数,暂且命名为 withCache ,或许这么用起来会不错:

// The cached version of findCustomer.
function findCustomerWithCache(id, cb) {
  var _getKey = function(id) { return 'customer:' + id; };
  withCache(86400, _getKey, findCustomer, id, cb);
}

也就是说,我们只要把数据查询过程 findCustomer 委托给一个高阶函数 withCache ,并且设定缓存时长以及 key 的生成规则,就可以了,缓存检查、更新的整个流程都由这个函数封装,从而达到重用的目的。

封装缓存流程

/** The generic caching routine.
  @param dur [Integer] seconds before cache expires
  @param keyBuilder [Function] (args...) given the arguments, return a unique cache key
  @param fn [Function] the actual data loading routine
  @param args... [Any...] arguments applys to fn to load data
  @param cb [Function] callback (err, data) applys to fn to receive data
 */
function withCache(dur, keyBuilder, fn) {
  var args, cb, key;
  args = Array.prototype.slice.call(arguments, 3, -1);
  cb   = _.last(arguments);             // the callback function
  key  = keyBuilder.apply(null, args);  // compute cache key

  fromCache(key, function(err, data) {
    if (err) return cb(err);

    if (data) {  // cache hit
      cb(null, data);
    }
    else {  // cache missed
      loadAndCacheData.call(null, dur, key, fn, args, cb);
    }
  });
}

/** Load from db using fn.
  and cache it using the given key before return the result.
 */
function loadAndCacheData(dur, key, fn, args, cb) {
  var _cacheData = _.partial(toCache, dur, key);
  async.compose(_cacheData, fn).apply(null, args.concat(cb));
}

一旦缓存流程被封装起来,重用就变得容易了,现在我们可以对任意的数据查询函数应用缓存了。

用高阶函数封装过程,这也是函数式编程重用代码的一种最基本的方法,就像 each map reduce 等函数对集合应用的封装一样。

注意到 withCache 函数的签名,参数的排列顺序不是随意的,而是考虑了它们的适用范围 (或稳定程度),使得函数重用更为方便,现在很容易做到:

var withOneDayCache = _.partial(withCache, 86400);

// the same as: withCache(86400, _getKey, findCustomer, id, cb);
var _getKey = function(id) { return 'customer:' + id; };
withOneDayCache(_getKey, findCustomer, id, cb);

// exactly the same as the findCustomerWithCache function above
var findCustomerWithOneDayCache = _.partial(withOneDayCache, _getKey, findCustomer);

函数代理

现在我们距离声明式缓存仅一步之遥,不过在此之前,我们还可以再进一步:我们想要以更接近‘声明式’地获取 findCustomerWithOneDayCache 这样的函数。

Spring Declarative annotation-based caching 为参照:

@Cacheable("customers")
public Customer findCustomer(Integer id);

Node 中,我们希望能够以以下方式‘声明’某个函数‘应该使用缓存’:

findCustomerWithCache = cacheable(findCustomer, { ns: 'customer', dur: 86400 });

为便于理解,可将 cacheable 类比为 Spring ProxyFactoryBean,通过它,我们可以获得一个代理,其表现形式无异于原函数 (如本例中 findCustomer),却能够在背后默默地帮我们完成缓存的相关处理。

为实现这一机制,我们首先需要一个通用的 cache key 生成方式:

/** Generates cache key using function arguments.
  @param ns [String] namespace, prefix of the cache key
  @param args [Array] arguments for loading data
 */
function getKey(ns, args) { return ns + ':' + ... }

使用前缀 + 参数列表自动生成 cache key ,对于含有多个参数的情况,可以使用 hash (参考Default Key Generation),这里我就不写了。

接下来就简单了,利用之前的成果,我们很容易就可以写出满足上述形式的 cacheable 函数:

/** Wrap the given function fn to use the caching service.
  @param fn [Function] (args..., cb) the actual data loading routine
  @param opts [Object] options
    ns:  [String] namespace, prefix of the cache key
    dur: [Integer] seconds before cache expires
 */
function cacheable(fn, opts) { return _.partial(withCache, opts, getKey, fn); }

当然, withCache 需要稍稍改动:接受一个 options 对象作为参数。

声明式缓存

好了,就差最后一步:如何能够在不影响代码的情况下,随意设置缓存参数 (是否缓存、缓存时长等)?

老办法,首先设定我们的期望,假设 findCustomer 是由 customers 模块提供的,可以这样使用:

var custs = require('customers');
custs.findCustomer(1, function(err, customer) {
  // do something with the customer
  ...
});

我们希望缓存对 findCustomer 的使用者是透明的,即无论缓存与否或缓存多长时间,上述代码都不需要修改。

要解决这个问题,可以利用 Node 模块的缓存特性。 即,我们可以在应用 (进程) 初始化时 (通常叫做 prelude script),将 customers 模块的 findCustomer 替换成 cacheable 的版本,只要模块缓存没有被清空,随后所有对于该模块的 require 都将得到修订后的版本, findCustomer 函数自然就是 cacheable 版的了。

为此我们先准备一个函数,帮助我们修订指定的模块:

/** Replace the function fn in a module m, to a cacheable one.
  @see http://nodejs.org/api/modules.html#modules_caching
  @param m [Object] module object
  @param fn [String] name of the function
  @param opts [Object] cache options
    ns:  [String] namespace, prefix of the cache key
    dur: [Integer] seconds before cache expires
 */
function cache(m, fn, opts) { m[fn] = cacheable(m[fn], opts); }

现在我们建立一个 caches.js ,如何命名这个文件并不重要,重要的是它需要被包含在 prelude script 中。 请把它类比为 Spring Beans 定义文件 (通常是 XML),我们把缓存相关的‘声明’都放在这儿:

var custs  = require('customers'),
  whatever = require('whatever');

cache(custs,    'findCustomer',       { ns: 'customer', dur: 86400 });
cache(custs,    'findCustomerByName', { ns: 'customer', dur: 86400 });
cache(whatever, 'findWhatever',       { ns: 'whatever', dur: 0     });
...

好了,现在我们可以‘声明’某个特定的函数是否以及如何使用缓存,而且随时修改这些‘声明’都不会对代码造成冲击。

最后

需要了解的是, Spring Cache Abstraction 主要包括了缓存 api 的抽象,以便在不影响代码的情况下随意切换不同的缓存服务,本文讨论更多的是类似 Declarative annotation-based caching 的特性。

相比于切换缓存服务,缓存配置变更的概率显然要大得多,更值得我们去仔细的管理,所以就不在此讨论 caching api 的抽象了。

另外,本文中讨论的实现方法依赖 Node Module Caching 特性 (如果模块被解析为同一个文件,则永远得到同一个对象),因此该方法有效的前提是:

  1. 同一个模块不会被解析到不同的文件,详情参考 Node 文档
  2. 模块缓存不会被清除

所以在应用这一方法之前,还请仔细评估上诉的前提条件。

原文地址:在 Node.js 中使用声明式缓存

作者简介

吴颖昕:作为Java程序员在华为混了几年,现供职于LightInTheBox,仍然从事Java开发,也开始接触到Node.js。 没有什么显赫的经历,属于半路出家、自学成才,什么都会点,又什么都不精的典型。 曾经深信面向对象是世上最好的编程范式,没有之一,而今天终于相信,多样性对于软件开发领域同样是不可或缺的,按需选择,最合适的才是最好的。 最近着迷于函数式编程,希望通过接触多种编程范式开拓自己的思路。
电邮: yingxinwu.g@gmail.com
博客: xinthink.com


感谢田永强对本文的审校。

给InfoQ中文站投稿或者参与内容翻译工作,请邮件至editors@cn.infoq.com。也欢迎大家通过新浪微博(@InfoQ)或者腾讯微博(@InfoQ)关注我们,并与我们的编辑和其他读者朋友交流。

评价本文

专业度
风格

您好,朋友!

您需要 注册一个InfoQ账号 或者 才能进行评论。在您完成注册后还需要进行一些设置。

获得来自InfoQ的更多体验。

告诉我们您的想法

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

bearcat 可以完成的更好 by fni fantasyni

spring 对 cache 的抽象本质上是通过 aop 来完成的,这样可以通过注解来完成声明式的缓存,node.js 也可以通过 bearcat 提供的 aop 来完成

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

1 讨论

登陆InfoQ,与你最关心的话题互动。


找回密码....

Follow

关注你最喜爱的话题和作者

快速浏览网站内你所感兴趣话题的精选内容。

Like

内容自由定制

选择想要阅读的主题和喜爱的作者定制自己的新闻源。

Notifications

获取更新

设置通知机制以获取内容更新对您而言是否重要

BT