At the Forge - Memcached Integration in Rails

Integrating memcached into your Rails application is easy and fast, with big benefits.

Last month, we talked about memcached, a distributed caching system
that is in widespread use among Web sites. The reason for memcached's
popularity is its simplicity. With a minimum of overhead and setup,
it's possible to set and retrieve nearly any value. Caching values
that otherwise would come from the database makes it possible to avoid
the database altogether on many occasions, speeding the throughput of
a Web application and reducing the load on the database server.

Memcached is a wonderful tool, and it is something nearly every Web
developer should have in his or her arsenal to improve site
performance. But with the release of Ruby on Rails 2.1, it got even
better. Rails now has integrated support for
memcached, allowing you to use it almost for free from within your
application. There are some caveats and tricks to its use, but once
you have those under your belt, you quickly will discover that
memcached has improved your site performance dramatically.

This month, we take a look at how to make memcached work
inside your Rails applications. We further explore some
issues you might encounter when using memcached, some of
which are easier to work around than others.

Cache Integration

Ruby on Rails has, since its inception, tried to make Web
developers' lives easier by coming out with many tools such
developers might need. It comes with an excellent object-relational
mapper (ORM), ActiveRecord. It comes with a way to test your code at
a variety of different levels (called, in Rails-speak, unit,
functional and integration). It comes with a first-class
JavaScript library and associated effects, in Prototype and
Scriptaculous. As numerous demonstrations and tutorials have shown,
Rails allows you to jump right in to Web development, writing and
testing your code with a minimum of dependencies. If you need to
include some functionality that was left out by the Rails authors,
it's not very difficult to include a Ruby gem (downloadable
library) or even a “plugin” that sits inside your Rails
application.

Rails has long come with a multilayered caching system that
programmers can tap to speed up applications. You can cache
individual pages, controller actions or even page fragments. And
indeed, judicious use of the Rails caching commands can result in
serious improvements to performance.

But, it was only in version 2.1 that Rails integrated support for
caching individual objects. The support for object caching not only
has the potential to improve your
application's performance dramatically, but it also allows you to work with a variety of different
storage facilities, so you can choose the one that's most
appropriate for you. Although this article concentrates on the use
of memcached, you should know that it's possible to work with not only
memcached, but also with caches on the local filesystem, in local memory or
even on another Rails-aware server using DRb (distributed Ruby,
available as a Ruby gem).

Caching a Simple Object

To demonstrate how to use memcached, I'm going to create a simple
Rails application, using PostgreSQL as the database:

createdb atf
rails --database=postgresql atf

Next, I create a simple object, person, for my application, with
the Rails built-in scaffolding that includes a RESTful interface:

Comment viewing options

Thanks for the write up but i seem to be having a bit of problem when i refresh my browser. I was expecting to see "undefined class/module Person" as stated but instead i get a different error message "undefined method `cache' for #