之前安装了Redmine，但是无论使用本身内置的Web Server还是Mongrel都不是个很好的选择。因为本身服务器安装了Nginx，所以想在Nginx下跑Rails，于是选择了Passenger。

首先下载passenger，并执行里面安装Nginx模块的命令：

wget http://rubyforge.org/frs/download.php/75548/passenger-3.0.11.tar.gz
tar zxvf passenger-3.0.11.tar.gz
cd passenger-3.0.11/bin/
./passenger-install-nginx-module

然后按照提示进行安装。

它会检查系统是否已经安装了必须的软件：

Checking for required software...

 * GNU C++ compiler... found at /usr/bin/g++
 * The 'make' tool... found at /usr/bin/make
 * A download tool like 'wget' or 'curl'... found at /usr/bin/wget
 * Ruby development headers... found
 * OpenSSL support for Ruby... found
 * RubyGems... found
 * Rake... found at /usr/local/bin/rake
 * rack... found
 * Curl development headers with SSL support... found
 * OpenSSL development headers... found
 * Zlib development headers... found

没有安装的话，它会提示你安装的方法。

然后，它会让你选择是自动下载安装Nginx还是自定义安装：

Automatically download and install Nginx?

Nginx doesn't support loadable modules such as some other web servers do,
so in order to install Nginx with Passenger support, it must be recompiled.

Do you want this installer to download, compile and install Nginx for you?

 1. Yes: download, compile and install Nginx for me. (recommended)
    The easiest way to get started. A stock Nginx 1.0.10 with Passenger
    support, but with no other additional third party modules, will be
    installed for you to a directory of your choice.

 2. No: I want to customize my Nginx installation. (for advanced users)
    Choose this if you want to compile Nginx with more third party modules
    besides Passenger, or if you need to pass additional options to Nginx's
    'configure' script. This installer will  1) ask you for the location of
    the Nginx source code,  2) run the 'configure' script according to your
    instructions, and  3) run 'make install'.

Whichever you choose, if you already have an existing Nginx configuration file,
then it will be preserved.

Enter your choice (1 or 2) or press Ctrl-C to abort:

由于我本身已经安装有Nginx，所以选择2。然后它会让你选择源代码的路径，安装的目标路径以及编译参数。这里我的安装路径跟编译参数都跟以前安装Nginx时一致（可以运行nginx -V命令获取到以前的编译参数），这样就不会影响到以前安装的Nginx了。需要注意的事，安装Passenger模块并不会影响到已经存在的Nginx配置文件，但是为了安全起见，安装前还是先备份一下吧！

之后就是编译及安装了，成功的话你会看到这句话：Nginx with Passenger support was successfully installed.

现在我们可以编辑Nginx的配置文件让它支持Passenger，以及把一个Rails应用配置上去。

http {
    ...
    passenger_root /path/to/passenger-3.0.11;
    passenger_ruby /usr/local/bin/ruby;

    server {
        listen 80;
        server_name www.yourhost.com;
        root /somewhere/public;
        passenger_enabled on;
    }
    ...
}

提示：
1. 如果编译安装过程中遇到‘ngx_http_upstream_conf_t’ has no member named ‘module’这个错误，可能是你的Nginx版本不够高，请尝试使用一个较新的版本。

其他：
1. 更多的安装信息请参考：http://www.modrails.com/install.html

wget http://www.mirrorservice.org/sites/ftp.ruby-lang.org/pub/ruby/ruby-1.8.7-p358.tar.gz
tar zxvf ruby-1.8.7-p358.tar.gz
cd ruby-1.8.7-p358
./configure
make
make install

2. 安装RubyGem，Redmine 1.3.x要求RubyGems <= 1.7，但是我用最新版暂时没发生什么问题。

wget http://production.cf.rubygems.org/rubygems/rubygems-1.8.17.tgz
tar zxvf rubygems-1.8.17.tgz
cd rubygems-1.8.17
ruby setup.rb

3. 安装Rails。1.3.x版本的Redmine要求Rails的版本为2.3.14。

gem install rails -v=2.3.14

4. 安装必要插件，一个是用作国际化的i18n，一个是连接mysql数据库的ruby-mysql。

gem install i18n -v=0.4.2
gem install ruby-mysql

这里我使用mysql作为数据库，具体安装方法就不说了。这里假设mysql已经在服务器上安装过了。

5. 安装以及配置Redmine
首先，下载Redmine并解压：

wget http://rubyforge.org/frs/download.php/75814/redmine-1.3.1.tar.gz
tar zxvf redmine-1.3.1.tar.gz

然后，我们登录到mysql上创建必要的数据库和用户。

create database redmine character set utf8;
create user 'redmine'@'localhost' identified by 'my_password';
grant all privileges on redmine.* to 'redmine'@'localhost';

然后，进入Redmine目录，把config/database.yml.example复制成config/database.yml，并根据刚才创建的数据库及用户修改这个文件：

production:
  adapter: mysql
  database: redmine
  host: localhost
  username: redmine
  password: my_password

然后运行以下命令产生一个session store secret（存储密钥？）：

rake generate_session_store

回到应用根目录下（即redmine-1.3.1目录下），运行以下命令：

RAILS_ENV=production rake db:migrate

这个命令会创建必要的库表跟admin用户。

运行以下命令在数据库插入一些默认的设置数据。这个命令不是必须的。

RAILS_ENV=production rake redmine:load_default_data

运行后会要求你选择默认语言，选中文zh。

运行WEBrick来检验我们的安装，在应用根目录运行：

ruby script/server webrick -e production

我们在浏览器输入http://服务器ip:3000/来访问我们安装好的Redmine，管理员帐号/密码为admin/admin。

6. 修改Web Server
由于WEBrick只是用来作测试用，并不适合用在生产环境上，所以我们需要更换一个Web Server，例如Mongrel。

gem install mongrel

安装好后，在应用根目录下运行：

ruby script/server mongrel -e production

第一篇使用图像描述Javascript语法的文章很受欢迎，所以我决定使用这个方法进行一些更加高级的想法。在这片文章里，我将会解释创建对象的三个常用技术。它们是使用原型的构造函数，纯原型以及对象工厂。

我的目标是想帮助大家明白每种技术的优点和弱点，并且明白它们具体是怎样运作的。

经典的Javascript构造函数（Classical JavaScript Constructors）

首先，我们用原型创建一个简单的构造函数。这是在原生的Javascript里你能找到的最接近类的东西。它很强大和高效，但是跟你所期待的其他语言的类比起来并不太一样。

function Rectangle(width, height) {
  this.width = width;
  this.height = height;
}
Rectangle.prototype.getArea = function getArea() {
  return this.width * this.height;
};
Rectangle.prototype.getPerimeter = function getPerimeter() {
  return 2 * (this.width + this.height);
};
Rectangle.prototype.toString = function toString() {
  return this.constructor.name + " a=" + this.getArea() + " p=" + this.getPerimeter();
};

现在我们定义一个继承自Rectangle叫Square的类。要进行继承，构造函数的原型必须继承自父构造函数的原型。这里我们重写getPerimeter让它稍微高效点，同时也看看怎样重写一个函数。

function Square(side) {
  this.width = side;
  this.height = side;
}
Square.prototype.__proto__ = Rectangle.prototype;
Square.prototype.getPerimeter = function getPerimeter() {
  return this.width * 4;
};

用法很直接，分别创建一个实例并调用它们的函数。

var rect = new Rectangle(6, 4);
var sqr = new Square(5);
console.log(rect.toString())
console.log(sqr.toString())

下面是结果的数据结构，虚线表示对象的继承。

注意到rect实例跟Square.prototype没啥不同。它们都是从Rectangle.prototype继承而来的简单对象。当你深入了解Javascript你会发现它只是一系列对象的连接。唯一比较特别的对象就是函数，它们可以接受参数和含有可执行的代码，并把它指向作用域。

纯原型对象（Pure Prototypal Objects）

让我们举些不使用构造函数的例子。这次我们只使用纯原型实现。

我们定义一个Rectangle原型，作为我们所有对象的一个模型。

var Rectangle = {
  name: "Rectangle",
  getArea: function getArea() {
    return this.width * this.height;
  },
  getPerimeter: function getPerimeter() {
    return 2 * (this.width + this.height);
  },
  toString: function toString() {
    return this.name + " a=" + this.getArea() + " p=" + this.getPerimeter();
  }
};

现在我们定义一个子对象Square并重写一些属性以改变一些特性。

var Square = {
  name: "Square",
  getArea: function getArea() {
    return this.width * this.width;
  },
  getPerimeter: function getPerimeter() {
    return this.width * 4;
  },
};
Square.__proto__ = Rectangle;

要创建这些原型的实例，我们只需要简单的创建继承自这些原型对象的新对象，然后设置它们的自己的属性。

var rect = Object.create(Rectangle);
rect.width = 6;
rect.height = 4;
var square = Object.create(Square);
square.width = 5;
console.log(rect.toString());
console.log(square.toString());

下面是结果的对象图。

这个方法没有构造函数+原型的方法强大，但是它比较容易理解，因为它使用的继承比较少。而且如果你之前的语言也是使用这种纯原型的方式实现的话，那么你应该会觉得高兴Javascript也能这么干。

对象工厂（Object Factories）

我最喜欢的其中一个创建对象的方法就是使用工厂方法。它的不同之处在于它不用创建一个包含共享函数的原型对象然后创建实例，我只需要每次简单的调用一个函数然后返回一个新对象就行了。

这个例子是一个超级简单的MVC架构。Controller函数把Model跟View作为参数传入然后输出一个新的Controller对象。所有的状态都通过作用域保存在一个闭包里。

function Controller(model, view) {
  view.update(model.value);
  return {
    up: function onUp(evt) {
      model.value++;
      view.update(model.value);
    },
    down: function onDown(evt) {
      model.value--;
      view.update(model.value);
    },
    save: function onSave(evt) {
      model.save();
      view.close();
    }
  };
}

要使用它，只需要简单调用这个函数并传入你想传入的参数。看下我们是怎样直接把它们用作事件句柄（setTimeout）而不必先把函数绑定到对象上。而且它（函数）并没有在内部使用this，所以没有必要烦恼this的值这个问题了。

var on = Controller(
  // Inline a mock model
  {
    value: 5,
    save: function save() {
      console.log("Saving value " + this.value + " somewhere");
    }
  },
  // Inline a mock view
  {
    update: function update(newValue) {
      console.log("View now has " + newValue);
    },
    close: function close() {
      console.log("Now hiding view");
    }
  }
);
setTimeout(on.up, 100);
setTimeout(on.down, 200);
setTimeout(on.save, 300);

下面是这段代码的结果的对象图。注意到我们通过函数的隐藏[scope]属性访问了两个传入的匿名对象，换句话说，我们访问了用工厂方法创建的闭包里的Model和View。

总结

我没有更多想要说的了，但是我想保持这篇文章短小精悍。如果有需要的话，我会写第三篇讲解如何写ruby式的Mixin以及其他进阶的话题。

原文：http://howtonode.org/object-graphs-2

Translated by icyfire @ 2011-10-31

要想成为一个出色的Javascript开发者，其中一个秘密就是真正的去理解这门语言。这篇文章将会用一些简单易懂的图表来解释Javasript的一些基本要素。

无处不在的引用（References Everywhere）

Javascript里的变量简单来说就是一个引用了内存里某个值的标签。这个值可以是字符串，数字或者布尔值这些基本元素，也可以是对象或者函数。

局部变量（Local Variables）

在下面的例子里，我们会在顶级作用域里创建四个局部变量然后把它们指向一些基本类型的值：

// Let's create some local variables in the top scope
var name = "Tim Caswell";
var age = 28;
var isProgrammer = true;
var likesJavaScript = true;
// Test to see if the two variables reference the same value
isProgrammer === likesJavaScript;

注意到两个布尔型变量指向了内存里的同一个值。这是因为基本元素是不可变的（immutable），解析器可以进行优化，对这些值的引用分享同一个实例。
在这段代码中，我们用 === 来检验两个引用是不是指向同一个值，结果返回是true。
在外层的代码处于最外层的闭包作用域（The outer box represents the outermost closure scope.），这些变量是顶级的局部变量，不要跟global/window对象的属性相混淆。

对象与原型链（Objects and Prototype Chains）

对象就是一个集合，包含了更多的对新对象与原型的引用。唯一特别的地方是当你试图访问一个在父对象里而不在局部对象里的属性时所用到的原型链。

// Create a parent object
var tim = {
  name: "Tim Caswell",
  age: 28,
  isProgrammer: true,
  likesJavaScript: true
}
// Create a child object
var jack = Object.create(tim);
// Override some properties locally
jack.name = "Jack Caswell";
jack.age = 4;
// Look up stuff through the prototype chain
jack.likesJavaScript;

这里我们有一个具有四个属性的对象，被变量tim所引用。同时我们创建了一个由第一个对象继承而来的新对象，被变量jack所引用。然后我们重写这个局部对象中的两个属性。
当我们要访问jack.likesJavaScript的时候，我们先会查找jack所引用的对象，然后在其中查找likesJavaScript这个属性。对象里没有这个属性，于是我们在父对象里进行查找并找到了它，并知道它引用了值true。

全局对象（The Global Object）

曾经有疑问为什么像jslint这些工具老是告诉你不要忘记用var定义变量，好吧，让我告诉你如果你忘记了的话。

var name = "Tim Caswell";
var age = 28;
var isProgrammer = true;
// Oops we forgot a var
likesJavaScript = true;

注意到likesJavaScript现在是全局对象的一个属性而不是外层闭包里的一个变量。当你把多段代码混合在一起就可能会出现问题，而事情你确实会经常这么做。
总是记得加上var使你的变量的作用域处于当前的闭包和子闭包里。你当然会很乐意遵循这个这么简单的规则。
如果你必须把东西放到全局对象上，你可以在浏览器上使用window.woo或者在node.js使用global.goo。

函数与闭包（Functions and Closures）

Javascript不仅仅是一系列的数据结构链。它包含了可执行和调用的代码，这种代码被称作函数。这些函数会创建链式作用域和闭包。

观察闭包（Visualizing Closures）

函数可以看作是特别的对象，对象包含了可执行的代码和属性。每个函数在定义时都会赋予一个特别的[scope]属性表明它正处于哪个环境。如果一个函数是在另外一个函数里被返回，那么对旧环境的引用就会被新的函数关闭在“闭包”里。
在这个例子里我们会创建一个简单的工厂方法来产生一个闭包，并返回一个函数。

function makeClosure(name) {
  return function () {
    return name;
  };
}
var description1 = makeClosure("Cloe the Closure");
var description2 = makeClosure("Albert the Awesome");
console.log(description1());
console.log(description2());

当我们调用description1()的时候，VM就会查找他引用的函数然后执行它。而这个函数会在闭包的作用域里去找一个叫做name的局部变量。这是个不错的工厂方法，每个产生的函数都有自己存放局部变量的空间。

想深入了解闭包和它的用法，可以看why use closure这篇文章。

共享函数与this（Shared Functions and this）

有时为了性能上的考虑，或者你纯粹喜欢这样，Javascript提供了this这个关键字让你在不同的作用域里重用函数对象，这取决于你是怎样调用它的。

这里我们创建了一些对象，这些对象共享了同一个函数。这个函数将会在内部引用this，向你展示它在不同的调用里会有哪些不同的表现。

var Lane = {
  name: "Lane the Lambda",
  description: function () {
    return this.name;
  }
};
var description = Lane.description;
var Fred = {
  description: Lane.description,
  name: "Fred the Functor"
};
// Call the function from four different scopes
console.log(Lane.description());
console.log(Fred.description());
console.log(description());
console.log(description.call({
  name: "Zed the Zetabyte"
}));

在这种图表里，我们看到就算Fred.description被设为Lane.description，它事实上只是引用那个函数。因此三个引用都是引用相同的匿名函数。因此我尽量不会用构造函数原型这个“方法”去调用函数，因为这样意味着会把这个函数绑定到构造函数以及他的“类”上（This is why I try to not call functions on constructor prototypes "methods", because that implies some sort of binding of the function to the constructor and it's "class"）。（想知道更多关于this的动态性质请看what is this）

总结

使用图表去表现这些数据结构是件很有趣的事情。我希望这个能帮助像我们一样通过视觉学习（visual learner）的人更好的掌握Javascript的语法。我具有前端设计/开发以及后台开发的经验，我希望我独特的视觉能给那些从事设计以及正在深入学习Javascript这个美妙的语言的人带来帮助。

(所有图表都是graphviz的点文件（dot file），可以在这里查看)

原文：http://howtonode.org/object-graphs

Translated by icyfire @ 2011-09-02 updated @ 2011-10-28

第二部分将会继续完成第一部分剩余的内容。我们会继续我们的Poll应用以及聚焦到Django自动生成的admin页面。

激活admin网页（Activate the admin site）

Django的admin页面默认是没有激活的，要想激活它，你需要做三件事情：

• 添加"django.contrib.admin"到你的INSTALLED_APPS设置里。
• 运行python manage.py syncdb。既然你已经添加了一个新的应用到INSTALLED_APPS里，数据库里的表自然也需要更新。
• 编辑文件mysite/urls.py反注释跟admin有关的行 —— 一共有三行需要注释。这个文件是一个url配置文件，我们将会在下一个教程深入URL的配置。现在，你所需要知道的就是它会把URL映射到应用上。 做完这些后，文件urls.py应该类似下面这样：

  from django.conf.urls import patterns, include, url
  
  # 反注释下两行开启admin功能：
  from django.contrib import admin
  admin.autodiscover()
  
  urlpatterns = patterns('',
      # 例子：
      # url(r'^$', '{{ project_name }}.views.home', name='home'),
      # url(r'^{{ project_name }}/', include('{{ project_name }}.foo.urls')),
  
      # 反注释admin/doc这一行开启管理文档url：
      # url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
  
      # 反注释下一行开启管理页面url：
      url(r'^admin/', include(admin.site.urls)),
  )

  (需要反注释的是行4，5，16。)

启动开发服务器（Start the development server）

我们启动开发用服务器，然后打开admin页面。

还记得教程1里你这样启动开发用服务器吧：

python manage.py runserver

现在，打开浏览器访问你本地域名上的"/admin/" —— 例如，http://127.0.0.1:8000/admin/。你应该可以看到admin的登录界面：

进入admin页面（Enter the admin site）

现在我们试试登录。（你在教程1里已经创建过一个超级用户帐号，还记得吗？如果你没有或者忘记了密码，你可以再创建一个。）登录后你会看到Django的admin首页：

你应该会看到一些其他的可编辑内容，包括群组，用户和网站。这些核心的功能默认包含在Django里。

让poll应用可修改（Make the poll app modifiable in the admin）

但是我们的poll应用在哪呢？它没有在admin的首页显示。

我们只需做一件事：告诉admin，Poll对象需要一个admin界面。在你的polls文件夹里创建一个名字叫admin.py的文件，然后编辑成以下样子：

from polls.models import Poll
from django.contrib import admin

admin.site.register(Poll)

要看到这些修改生效，你需要重启开发用服务器。通常，当你修改文件后服务器会自动重载代码，但是创建一个新文件并不会触发自动重载。

admin功能探索（Explore the free admin functionality）

现在我们已经注册好Poll了，Django知道要把它显示在admin首页上。

点击"Polls"。现在你在polls的"change list"页面上。这个页面显示了数据库里所有的poll，你可以选择其中一个进行编辑。我们可以看到我们教程1里创建的"What's up?" poll：

点击"What's up?"进行编辑：

这里需要注意几点：

• 表格是根据Poll模型自动生成的。
• 不同模型字段类型(DateTimeField，CharField)对应到相应的HTML的input组件。 Django的admin知道每种类型的字段该怎么显示。
• 每个DateTimeField都有一些Javascript快捷操作功能。日期有"Today"快捷操作和弹出的日历，时间有"Now"快捷操作和列出常用时间输入的弹出窗口。

页面的底部有一些选项：

• 保存 -- 保存修改并返回到这类型对象的修改列表页面。
• 保存并继续编辑 -- 保存修改并重新加载这个对象的admin页面。
• 保存并添加新记录 -- 保存修改并加载一个这个类型对象的新的空白表格。
• 删除 -- 显示一个确认删除的页面。

点击"Today"和"Now"修改"Date published"，然后点击"Save and continue editing"。再点击右上的"History"，你会看到一个页面列出了这个对象所有的通过admin的修改历史，包括修改时间和修改者等信息：

自定义admin表单（Customize the admin form）

花几分钟时间去感叹下你少写了多少代码！通过用admin.site.register(Poll)注册Poll模型，Django可以构建一个默认的表单显示出来。通常你会想自定义admin表单的样子和功能，这时你可以在注册对象的时候告诉Django你想要的选项。

让我们通过重新排列编辑表单的字段顺序来看看这是怎么做到的。把admin.site.register(Poll)这一行换成：

class PollAdmin(admin.ModelAdmin):
    fields = ['pub_date', 'question']

admin.site.register(Poll, PollAdmin)

你需要使用这个模式 —— 在你想修改一个对象的admin选项时，先创建一个模型的admin对象，然后作为第二个参数传进admin.site.register()里。

上面的修改使"Publication date"位于"Question"字段的前面：

就两个字段的话没什么大不了，但是如果是对于有几十个字段的表单来说，选择更为直观的顺序对可用性来说是一个重要的细节。

说到有几十个字段的表格，你可能会想把表格的字段分组：

class PollAdmin(admin.ModelAdmin):
    fieldsets = [
        (None,               {'fields': ['question']}),
        ('Date information', {'fields': ['pub_date']}),
    ]

admin.site.register(Poll, PollAdmin)

在fieldsets里，元组（tuple）的第一个元素是fieldset的标题。现在我们的表格看起来会像这样：

你可以给fieldset分配任意的HTML类名。Django提供了一个"collapse"类，使特定的一个fieldset在初始时闭合显示。当你有一个很长的表单包含若干不常用的字段时，这个类就会很有用。

class PollAdmin(admin.ModelAdmin):
    fieldsets = [
        (None,               {'fields': ['question']}),
        ('Date information', {'fields': ['pub_date'], 'classes': ['collapse']}),
    ]

添加关联对象（Adding related objects）

好了，我们有了Poll的管理页面了。但是一个Poll有多个Choices，而管理页面并没有显示choice。

有两个方法解决这个问题。第一个方法是在admin那注册一个Choice，就跟我们刚才注册Poll一样。这个很简单：

from polls.models import Choice

admin.site.register(Choice)

现在"Choices"选项已经出现在Django的admin里了。"Add choice"表单看起来就像这样：

在这个表单里，"Poll"字段是一个下拉框，它包含了数据库里所有的poll。Django知道应该把外键（ForeignKey）呈现为一个下拉框。所以在我们这里，下拉框只有一个poll。

注意到"Poll"旁边有个"Add Another"链接。每一个用外键关联的对象都有这么一个链接。当年点击"Add Another"的时候，将会弹出一个包含"Add poll"表单的窗口。如果你在这个窗口添加了一个poll并点击"Save"，Django就会把这个poll保存到数据库里并动态的把它加到下拉框里。

但是事实上，这是一个很低效的添加Choice对象的方法。如果能直接在创建Poll对象时添加一些Choice，这才是更好的方法。让我们来实现它吧。

把为Choice模型调用的register()删掉，然后编辑注册Poll的代码：

class ChoiceInline(admin.StackedInline):
    model = Choice
    extra = 3

class PollAdmin(admin.ModelAdmin):
    fieldsets = [
        (None,               {'fields': ['question']}),
        ('Date information', {'fields': ['pub_date'], 'classes': ['collapse']}),
    ]
    inlines = [ChoiceInline]

admin.site.register(Poll, PollAdmin)

这段代码告诉Django：“Choice对象放到Poll的管理页面里进行编辑。页面默认提供足够添加3个choice的字段。”

打开"Add poll"页面看看效果，你可能需要重启开发服务器：

它是这样工作的：在页面上有三行空间用来关联Choice——由extra指定。每次你回到一个已经创建好的对象的"Change"页面时，除了已经存在的关联的choice外，你还可以看到另外三个额外的空间用来创建新的Choice。

还有一个小问题，要显示这三个用来关联Choice对象的所有字段，需要霸占很大的屏幕空间，因此，Django提供了一个表格方式来显示这些关联的对象。你只需要把ChoiceInline改成下面这样：

class ChoiceInline(admin.TabularInline):
    #...

使用TabularInline（而不是StackedInline）后，关联的对象就会以一个更紧凑的表格式显示出来：

自定义修改列表页面（Customize the admin change list）

现在Poll管理页面看起来还不错，让我们对"change list"页面——显示所有poll的那个页面做点调整。

现在它是这个样子的：

Django默认会调用每个对象的str()作显示。但是有时我们会想显示某些个别更有用的字段。这个时候，我们需要用到list_display这个选项，它是一个要显出的字段名字的元组（tuple），这些名字将会作为列名显示在对象的修改列表页面上。

class PollAdmin(admin.ModelAdmin):
    # ...
    list_display = ('question', 'pub_date')

Just for good measure, let's also include the was_published_today custom method from Tutorial 1:

class PollAdmin(admin.ModelAdmin):
    # ...
    list_display = ('question', 'pub_date', 'was_published_today')

现在poll的修改列表页面看起来会是这样：

你可以点击的列头进行排序——除了was_published_today那一列，因为现在还不支持对方法输出的值进行排序。同时还需要注意的是，was_published_today那一列的列头的名字默认是方法的名字（下划线会用空格代替）。但是你可以通过给方法（在models.py里）一个short_description属性来修改它。

def was_published_today(self):
    return self.pub_date.date() == datetime.date.today()
was_published_today.short_description = 'Published today?'

再次编辑admin.py对Poll的修改列表页面加个功能：过滤（Filters）。在PollAdmin里增加如下代码：

list_filter = ['pub_date']

它会增加一个"Filter"侧边栏让用户可以通过pub_date字段对修改列表进行过滤：

显示的过滤类型取决于要进行过滤的字段的类型。因为pub_date是一个DateTimeField，Django知道默认需要给DateTimeFields这些过滤选项："Any date"， "Today"， "Past 7 days"， "This month"和"This year"。

目前情况进展的还不错。让我们添加一些搜索的功能：

search_fields = ['question']

它会在修改列表顶部增加一个搜索框。当输入一些搜索词，Django会去搜索question字段。只要你喜欢，你可以使用任意多的字段——但是因为它背后是使用LIKE进行查询，所以尽量合理一点，以免你的数据库不高兴。

最后，因为Poll对象有日期，所以如果能根据日期进行筛选就会显得比较方便。增加以下代码：

date_hierarchy = 'pub_date'

它会在修改列表页面的顶部根据日期增加一个层级性导航。在最顶层他会显示所有有效的年份，然后逐层深入到月份和天。

修改列表页面自带分页功能，默认每页显示50条记录。分页，搜索框，过滤，日期层级和排序，它们就像你所期待的那样一起运作着。

自定义管理界面（Customize the admin look and feel）

很明显，在每个管理页面的顶部显示Django administratio是很荒谬的，它只是个占位用文本。

但这个使用Django的模板系统很容易就能修改。Django的管理系统是使用Django自身实现的，它的界面使用的是Django本事的模板系统。

打开配置文件（mysite/settings.py）并找到TEMPLATE_DIRS这个设置。TEMPLATE_DIRS是一个文件系统路径的元组（tuple），在加载Django模板时会对它进行检查。它是一个搜索路径。

TEMPLATE_DIRS默认是空的。所以，我们增加一行代码进去，告诉Django我们的模板放在哪：

TEMPLATE_DIRS = (
    '/home/my_username/mytemplates', # 这里改为你自己的路径。
)

现在把模板文件admin/base_site.html从Django源码(django/contrib/admin/templates)的admin模板目录里复制到你在TEMPLATE_DIRS里设置的目录里的一个子目录admin。例如，如果你的TEMPLATE_DIRS包含'/home/my_username/mytemplates'，就像上面设置一样，那么就复制django/contrib/admin/templates/admin/base_site.html到
/home/my_username/mytemplates/admin/base_site.html。别忘了admin这个子目录。

然后，编辑那个模板文件，并把Django那段通用文本替换成你想要显示的网站名。

这个模板文件包含了很多像{% block branding %}和{{ title }}这样的文本。{%和{{标签是Django模板语言中的一部分。当Django渲染admin/base_site.html时，这个模板语言将会被评估产生出最后的HTML页面。如果你现在对模板还没啥概念的话，别担心，我们将在教程3里深入Django的模板语言。

所有的Django的默认admin模板都可以被重写，要重写一个模板，你只需要重复刚才操作base_site.html的步骤——从默认目录复制到你自定义的目录里并修改。

精明的读者也许会问：如果TEMPLATE_DIRS默认为空，Django是怎样找到默认的admin模板的？答案是，Django默认会自动在每个app包里寻找templates/这个子目录。想知道全部信息，可以看template loader documentation。

自定义管理首页（Customize the admin index page）

基于近似的理由，你可能像自定义Django管理系统的首页。

在默认情况下，admin会显示注册过的所有在INSTALLED_APPS设置的app，并按字母进行排序。你也许想要把界面弄得更有意义，毕竟，首页可能是admin里最重要的页面了，它应该做到易于使用。

需要自定义的模板是admin/index.html。（像前一部分对admin/base_site.html做的那样——把它从默认目录复制到你的自定义模板目录里。）编辑这个文件，你会看到它使用了一个模板变量叫app_list。这个变量包含了所有已经安装的Django app。如果你不想使用它，你可以在你想要放置的位置硬编码链接到对象相应的admin页面。再次的，如果你搞不懂模板语言，我们将会在教程3进行详情讲解。

如果你对管理网站感觉良好，那么可以开始关于poll公共视图的教程的第三部分了。

教程第二部分原文：https://docs.djangoproject.com/en/dev/intro/tutorial02/

Written by icyfire @ 2011.09.26 updated @ 2011.10.26

另外WIFI使用的安全类型是WPA2，所以此方法只适用于WPA安全类型的WIFI。

WPA类型的WIFI设置

首先，先看看一些网络的初始状态：

# iwconfig wlan0
wlan0     IEEE 802.11abgn  ESSID:off/any
          Mode:Managed  Access Point: Not-Associated   Tx-Power=0 dBm
          Retry  long limit:7   RTS thr:off   Fragment thr:off
          Encryption key:off
          Power Management:off

# ifconfig wlan0
wlan0     Link encap:Ethernet  HWaddr 00:21:6b:66:5c:24
          inet6 addr: fe80::221:6bff:fe66:5c24/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:18 errors:0 dropped:0 overruns:0 frame:0
          TX packets:16 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:5514 (5.5 KB)  TX bytes:1752 (1.7 KB)

OK，正式开始。

首先，我们用wpa_passphrase命令生成一个网络配置文件：

# wpa_passphrase ESSID KEY >> /etc/wpa_supplicant.conf

ESSID就是WIFI的essid，KEY就是WIFI的密码。此命令将会在/etc下生成一个名为wpa_supplicant.conf的文件。

然后，我们运行以下两个命令启动无线网卡。

# iwconfig wlan0 power on
# ifconfig wlan0 up

再次运行iwconfig wlan0，我们可以发现wlan0的状态已经发生改变：

# iwconfig wlan0
wlan0     IEEE 802.11abgn  ESSID:off/any
          Mode:Managed  Access Point: Not-Associated   Tx-Power=15 dBm
          Retry  long limit:7   RTS thr:off   Fragment thr:off
          Encryption key:off
          Power Management:on

运行以下命令连上WIFI：

# wpa_supplicant -B -Dwext -iwlan0 -c/etc/wpa_supplicant.conf

再次运行iwconfig wlan0命令，发现wlan0的状态再次发生变化：

# iwconfig wlan0
wlan0     IEEE 802.11abgn  ESSID:"MY_ESSID"
          Mode:Managed  Frequency:2.447 GHz  Access Point: 34:08:04:0B:73:4E
          Bit Rate=1 Mb/s   Tx-Power=15 dBm
          Retry  long limit:7   RTS thr:off   Fragment thr:off
          Encryption key:off
          Power Management:on
          Link Quality=70/70  Signal level=-14 dBm
          Rx invalid nwid:0  Rx invalid crypt:0  Rx invalid frag:0
          Tx excessive retries:0  Invalid misc:5   Missed beacon:0

最后运行一下命令获取IP：

# dhclient wlan0

验证一下是否成功：

# ifconfig wlan0
wlan0     Link encap:Ethernet  HWaddr 00:21:6b:66:5c:24
          inet addr:192.168.0.107  Bcast:192.168.0.255  Mask:255.255.255.0
          inet6 addr: fe80::221:6bff:fe66:5c24/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:108 errors:0 dropped:0 overruns:0 frame:0
          TX packets:25 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:29588 (29.5 KB)  TX bytes:2990 (2.9 KB)

搞定。

对Django这个框架感兴趣好久了，却一直懒于研究学习，现在跟随官网的教程跑一遍，学学Django同时也继续学学Python。

在开始之前，我们先把Python和Django这个框架安装好。

官网：https://www.djangoproject.com/
下载：http://www.djangoproject.com/download/1.3/tarball/

由于兼容性问题，Django并不支持Python3+，只支持版本2.4到2.7，所以如果你的系统（本人使用的是SUSE Linux Enterprise Server 10 SP3，以下都是以这个系统为例）没有安装Python，或者版本不符合，那么就先要安装一个合适的版本，我使用的是2.7.2版本:

wget http://www.python.org/ftp/python/2.7.2/Python-2.7.2.tar.bz2
tar jxvf Python-2.7.2.tar.bz2
cd Python-2.7.2
./configure
make && make install

下载完后运行python setup.py install进行安装：

wget http://media.djangoproject.com/releases/1.3/Django-1.3.tar.gz
tar xzvf Django-1.3.tar.gz
cd Django-1.3
python setup.py install

安装完成后，验证下是否成功，输入python进入命令行，然后输入如下语句导入django并且输出django的版本号：

>>> import django
>>> print django.get_version()
1.3

OK，下面我们可以正式开始了。

在这个教程里，我们会创建一个简单的投票应用。它包括两部分：

• 一个公共网页让人查看投票和进行投票。
• 一个管理网页让你添加，修改和删除投票

创建项目

下面开始建立一个项目。首先cd到存放项目的目录，然后运行django-admin.py startproject mysite命令创建项目：

cd /home/python
django-admin.py startproject mysite

执行完后将会在当前目录创建一个名为mysite的项目。

如果你是通过python setup.py安装Django的话，django-admin.py应该会在你的系统路径下。如果它不在这个路径上的话，你可以在site-packages/django/bin里找到它，site-packages是你安装Python的目录。你可以考虑把某个路径软链接到django-admin.py，例如/usr/local/bin。

回到正题，startproject创建的目录结构如下：

mysite/
    __init__.py
    manage.py
    settings.py
    urls.py

这些文件的用途是：

• __init__.py: 一个空文件让Python知道这个目录是一个Python包。(如果你是一个Python初学者，可以看官方的Python文档了解更多关于包的内容)
• manage.py: 一个命令行工具用于跟项目的各种交互。详情查看django-admin.py和manage.py这两个文件。
• settings.py: 当前项目的设置和配置。详情可以查看Django settings。
• urls.py: 当前项目的URL定义。详情可以查看URL dispatcher。

开发用服务器

下面启动Django development server来检查下成果。进入项目目录mysite运行命令python manage.py runserver：

Validating models...

0 errors found
Django version 1.3, using settings 'mysite.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

你已经启动了Django的开发服务器，一个用纯Python编写的轻量级Web server。我们已经把它包含在Django里，这样你就可以进行快速的开发而不需要去配置诸如apache这样的Production服务器，除非你已经准备好要发布了。

注意不要把这个服务器当作发布环境用，它是专门在开发环境中使用的。

现在服务已经启动了，你可以在浏览器上访问http://127.0.0.1:8000/。你将会看到欢迎页面，如下图：

python manage.py runserver 8080

python manage.py runserver 0.0.0.0:8000

数据库配置

现在，编辑settings.py文件。修改DATABASES的default项里下面的值：

• ENGINE：django.db.backends.postgresql_psycopg2或者django.db.backends.mysql和django.db.backends.sqlite3。也支持其他数据库。
• NAME：数据库名。如果使用的是SQLite的话，数据库则是系统里的一个文件，所以NAME应该设为包含这个文件名字的绝对路径（注意路径要使用斜杠/，无论在什么系统上）。这个文件不需要创建，在第一次进行数据库同步的时候会自动创建这个文件。
• USER：用户名。使用SQLite的话则不需要。
• PASSWORD：密码。使用SQLite的话则不需要。
• HOST：主机地址。使用SQLite的话则不需要。如果数据库安装在同一台机器上，也可以不指定。

如果你对数据库不太熟悉的话，建议你使用SQLite（把ENGINE设为django.db.backends.sqlite3）。SQLite已经作为Python 2.5以上版本的一部分包含在里面，所以你不需要作任何的安装。

在编辑settings.py的时候，你会注意到文件底部的INSTALLED_APPS配置项。这些变量保存了那些随着Django实例启动的Django应用(以下用app表示)的名字。app可以被使用到多个项目里，你也可以把它们打包和发布出去供其他人使用。

INSTALLED_APPS默认包含了以下app，这些app全部由Django自带：

• django.contrib.auth -- 一个认证系统。
• django.contrib.contenttypes -- 内容类型框架。
• django.contrib.sessions -- session框架。
• django.contrib.sites -- 多网站管理框架。
• django.contrib.messages -- 消息管理框架。
• django.contrib.staticfiles -- 静态文件管理框架。

为了方便使用，这些通常网站都会用到的应用已经默认包含在项目里。

这些app每个都至少要用到一个以上的数据库表，所以在使用这些应用前我们先要创建这些表。运行一下命令：

python manage.py syncdb

syncdb命令会根据settings.py文件里的INSTALLED_APPS设置创建必需的数据表。你会看到创建表的信息以及会提示你为认证系统创建超级用户，跟着提示做就行了。

创建模型

现在环境已经搭好了，可以正式开工了。

在Django里，你写的每个应用都包含一个Python的包，这个包会根据一个特定的约定放在Python path里。Django会自动为每个app创建一些基本的目录结构，所以你可以专心写代码而不必在创建目录上费心。

你的应用可以存放在Python path上的任何地方。简单起见，我们在mysite目录里创建一个投票应用。确认你的当前目录为mysite，并输入命令：

python manage.py startapp polls

这样会创建一个目录polls，如下：

polls/
    __init__.py
    models.py
    tests.py
    views.py

这个目录结构将会存放这个poll应用。

在Django里写一个有数据库操作的网页应用第一步要做的就是定义模型（Model），模型实质上就是附带元数据的数据层(database layout)。

在我们这个简单的投票应用里，我们创建了两个模型：polls和choices。一个poll包含有一个问题和一个发表日期。一个choice有两个字段：选项文字和投票计数。每一个choice都跟一个poll关联。

这个概念将由一个简单的Python类来实现。编辑文件polls/models.py：

from django.db import models

class Poll(models.Model):
    question = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')

class Choice(models.Model):
    poll = models.ForeignKey(Poll)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()

代码很直白。每个模型都由一个django.db.models.Model的子类实现。每个模型包含一些变量，每个变量对应一个数据库里的字段。

每个字段由类Field的一个实例表示，例如字符类型的字段由CharField实现，时间类型的字段则由DateTimeField实现，这样Django就知道每个字段保存的是什么类型的数据了。

每个Field实例的名字（例如question和pub_date）都是机器友好格式的字段名。这些字段会用在你的Python代码里，而数据库则会把它用作字段名。

你可以在Field的第一个参数指定一个可读的名字，这个名字会用在Django内部多个地方。如果没有指定这个名字，Django会使用机器可读的名字。在这个例子里，我们只为Poll.pub_date定义了人可读的名字，模型里其他所有的字段，机器可读名字已经可作为人可读名字。

一些Field类有必须含有的元素，例如CharField，必须给它指定max_length。这个不仅会用在数据库schema里，也会用在数据验证里，我们很快会看到。

最后，注意到用ForeignKey定义了一个关系。它告诉Django每个Choice会关联到一个Poll。Django支持所有的常用数据库关系：多对已，多对多和一对一。

激活模型

Django通过模型里的那点代码获取到了很多的信息，通过这些信息，Django可以：

• 为应用创建数据库模式(CREATE TABLE语句) 。
• 创建访问Poll和Choice对象的Python数据库访问API。

但是首先我们先要让我们的项目知道polls这个应用已经安装。

再次编辑文件settings.py，修改设置INSTALLED_APPS包含字符串'polls'。修改后的配置如下：

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'polls'
)

现在Django知道要去包含polls这个应用了。我们执行另外一个命令：

python manage.py sql polls

你应该会看到类似下面的东西(poll应用的CREATE TABLE SQL语句):

BEGIN;
CREATE TABLE "polls_poll" (
    "id" integer NOT NULL PRIMARY KEY,
    "question" varchar(200) NOT NULL,
    "pub_date" datetime NOT NULL
)
;
CREATE TABLE "polls_choice" (
    "id" integer NOT NULL PRIMARY KEY,
    "poll_id" integer NOT NULL REFERENCES "polls_poll" ("id"),
    "choice" varchar(200) NOT NULL,
    "votes" integer NOT NULL
)
;
COMMIT;

注意以下几点：

• 实际输出的东西会根据你所使用的数据库而不同。
• 表名由应用的名称(polls)和小写的模型名称 —— poll和choice组合而成并自动生成。(你可以重写这个规则。)
• 主键(IDs)会被自动添加。(同样能可以重写它)
• 为了方便，Django会添加"_id"到外键的字段名上。对的，你同样可以重写它。
• 外键关系由一个REFERENCES语句明确确定。
• 它是为你所使用的数据库量身定制的，所以数据库特有的字段如auto_increment (MySQL)，serial (PostgreSQL)或者integer primary key (SQLite)都会自动帮你处理，同样字段名的引号也是如此，例如，是使用双引号还是单引号。这篇教程的作者使用PostgreSQL，所以例子里的输出都是PostgreSQL语法。
• sql命令并不会在你的数据库里执行SQL语句，它只是在屏幕上显示给你看Django认为需要执行哪些SQL语句。如果你想的话，可以复制和粘贴这些SQL语句到你的数据库命令行。但是，我们很快就能看到，Django提供了一个更为简单的方式去执行这些SQL到数据库上。

如果你有兴趣，可以运行以下的命令：

• python manage.py validate -- 检查模型的结构错误。
• python manage.py sqlcustom polls -- 输出所有为应用定义的自定义SQL语句 (例如表修改和约束)。
• python manage.py sqlclear polls -- 根据已存在的表，输出这个应用中必要的DROP TABLE语句。
• python manage.py sqlindexes polls -- 输出这个应用CREATE INDEX语句。
• python manage.py sqlall polls -- sql，sqlcustom和sqlindexes命令产生的SQL语句的结合。

看这些命令的输出可以帮助你更好的理解底层发生的事情。

现在，再次运行syncdb在数据库上创建这些模型的表：

python manage.py syncdb

syncdb命令会为在INSTALLED_APPS里没有相应数据表的应用运行'sqlall'产生的sql语句。它会为自上次运行syncdb以来新添加的应用建立所有的表，初始化数据和索引。你可以在任何时候执行syncdb，它只会创建不存在的表。

阅读django-admin.py documentation以获取manage.py这个工具所能做的事情的所有信息。

使用API

现在，我们进入Python的交互shell并使用Django提供的API。要进入Python shell，使用这个命令：

python manage.py shell

我在这里遇到了ImportError: No module named readline这个错误，解决方法是下载readline，编译安装，然后重新编译和安装python就可以解决这个问题。

我们使用这个而不是简单的输入"python"，是因为manage.py会帮你创建项目的环境。“创建项目环境”包括两件事：

• 把polls添加到sys.path里。为了灵活性，Django中的模块通过加点的路径来引用(例如'polls.models')。为了实现这个，polls包必须在sys.path里。
  我们已经遇到过一个这样的例子了：the INSTALLED_APPS设置里的列表就是使用点路径表示法。
• 设置DJANGO_SETTINGS_MODULE环境变量，为Django指定了你的settings.py文件的路径。

在shell里面时，可以探索下database API：

>>> from polls.models import Poll, Choice # 导入我们刚写的模型。

# 系统里还没有poll。
>>> Poll.objects.all()
[]

# 创建一个新poll。
>>> import datetime
>>> p = Poll(question="What's up?", pub_date=datetime.datetime.now())

# 把对象保存进数据库里。你需要明确调用save()。
>>> p.save()

# 现在它有个ID了。注意这里也可能显示1L而不是1，
# 取决于你使用的是什么数据库。不过这没什么打不了，
# 它只是表明数据库更倾向于把整型返回成Python的长整型对象。
>>> p.id
1

# 通过Python属性访问数据库列
>>> p.question
"What's up?"
>>> p.pub_date
datetime.datetime(2007, 7, 15, 12, 00, 53)

# 通过修改属性来修改值，然后调用save()。
>>> p.pub_date = datetime.datetime(2007, 4, 1, 0, 0)
>>> p.save()

# objects.all()显示数据库所有的poll。
>>> Poll.objects.all()
[<Poll: Poll object>]

等等。<Poll: Poll object>完全不能表现出这个对象的有用信息。我们可以编辑poll模型(在文件polls/models.py 里)添加一个__unicode__()方法给Poll和Choice来解决这个问题：

class Poll(models.Model):
    # ...
    def __unicode__(self):
        return self.question

class Choice(models.Model):
    # ...
    def __unicode__(self):
        return self.choice

为你的模型添加__unicode__()方法是很有必要的。不仅是为了让你自己更好理解交互提示，而且因为对象的表现的使用会贯穿于整个Django自动产生的admin。

注意这些都是普通的Python方法，让我们添加一个自定义的方法，用作示范：

import datetime
# ...
class Poll(models.Model):
    # ...
    def was_published_today(self):
        return self.pub_date.date() == datetime.date.today()

添加import datetime会引用Python的datetime模块。

保存这些修改然后再次运行python manage.py shell新开一个Python交互shell：

>>> from polls.models import Poll, Choice

# 确保我们新加的__unicode__()正常工作。
>>> Poll.objects.all()
[<Poll: What's up?>]

# Django提供了丰富的数据库查找API，
# 这些API完全由关键字参数驱动。
>>> Poll.objects.filter(id=1)
[<Poll: What's up?>]
>>> Poll.objects.filter(question__startswith='What')
[<Poll: What's up?>]

# 获取年份为2007的poll。
>>> Poll.objects.get(pub_date__year=2007)
<Poll: What's up?>

>>> Poll.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Poll matching query does not exist.

# 通过主键查找是很常用的一种方式，
# 所以Django为这种查找方法提供一个便捷的方式。
# 下面相当于Poll.objects.get(id=1)。
>>> Poll.objects.get(pk=1)
<Poll: What's up?>

# 确认我们的自定义方法正常工作。
>>> p = Poll.objects.get(pk=1)
>>> p.was_published_today()
False

# 给Poll加上几个Choice。
# 调用创建函数创建choice对象，会调用INSERT语句，
# 把choice添加到已存choice的集合里，并返回这个新创建的Choice对象。
# Django会创建一个集合保存外键关联，这个集合可以通过API进行访问。
>>> p = Poll.objects.get(pk=1)

# 显示关联的所有choice —— 目前还没有。
>>> p.choice_set.all()
[]

# 创建三个choice。
>>> p.choice_set.create(choice='Not much', votes=0)
<Choice: Not much>
>>> p.choice_set.create(choice='The sky', votes=0)
<Choice: The sky>
>>> c = p.choice_set.create(choice='Just hacking again', votes=0)

# Choice对象可通过API访问它关联的Poll对象。
>>> c.poll
<Poll: What's up?>

# 反之亦然：Poll对象访问Choice对象。
>>> p.choice_set.all()
[<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]
>>> p.choice_set.count()
3

# API会根据你的需要自动追踪关系。
# 使用双下划线分隔这些关系。
# 你可以深入到任意的层级，这个没有限制。
# 查找pub_date在2007年的poll的所有choice。
>>> Choice.objects.filter(poll__pub_date__year=2007)
[<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]

# 我们使用delete()删除一个choice。
>>> c = p.choice_set.filter(choice__startswith='Just hacking')
>>> c.delete()

更多关于模型关系的信息，可以看Accessing related objects。想知道更多关于如何使用双下划线通过API实现字段的查找，看Field lookups。要获取数据库API的所有信息，请看Database API reference。

好吧，开篇就到这里，更详细请查看：

https://docs.djangoproject.com/en/dev/intro/tutorial01/

Written by icyfire @ 2011.08.05 updated @ 2011.10.09

据说带着问题学习更有效，那就先看一个MongoDB服务器的top命令结果：

shell> top -p $(pidof mongod)
Mem:  32872124k total, 30065320k used,  2806804k free,   245020k buffers
Swap:  2097144k total,      100k used,  2097044k free, 26482048k cached

 VIRT  RES  SHR %MEM
1892g  21g  21g 69.6

这台MongoDB服务器有没有性能问题？大家可以一边思考一边继续阅读。

先讲讲Linux是如何管理内存的

在Linux里（别的系统也差不多），内存有物理内存和虚拟内存之说，物理内存是什么自然无需解释，虚拟内存实际是物理内存的抽象，多数情况下，出于方便性的考虑，程序访问的都是虚拟内存地址，然后操作系统会把它翻译成物理内存地址。

很多人会把虚拟内存和Swap混为一谈，实际上Swap只是虚拟内存引申出的一种技术而已：操作系统一旦物理内存不足，为了腾出内存空间存放新内容，就会把当前物理内存中的内容放到交换分区里，稍后用到的时候再取回来，需要注意的是，Swap的使用可能会带来性能问题，偶尔为之无需紧张，糟糕的是物理内存和交换分区频繁的发生数据交换，这被称之为Swap颠簸，一旦发生这种情况，先要明确是什么原因造成的，如果是内存不足就好办了，加内存就可以解决，不过有的时候即使内存充足也可能会出现这种问题，比如MySQL就有可能出现这样的情况，解决方法是限制使用Swap：

shell> sysctl -w vm.swappiness=0

查看内存情况最常用的是free命令：

shell> free -m
             total       used       free     shared    buffers     cached
Mem:         32101      29377       2723          0        239      25880
-/+ buffers/cache:       3258      28842
Swap:         2047          0       2047

新手看到used一栏数值偏大，free一栏数值偏小，往往会认为内存要用光了。其实并非如此，之所以这样是因为每当我们操作文件的时候，Linux都会尽可能的把文件缓存到内存里，这样下次访问的时候，就可以直接从内存中取结果，所以cached一栏的数值非常的大，不过不用担心，这部分内存是可回收的，操作系统会按照LRU算法淘汰冷数据。还有一个buffers，也是可回收的，不过它是保留给块设备使用的。

知道了原理，我们就可以推算出系统可用的内存是free + buffers + cached：

shell> echo "29377 - 239 - 25880" | bc -l
3258

除了free命令，还可以使用sar命令：

shell> sar -r
kbmemfree kbmemused  %memused kbbuffers  kbcached
  3224392  29647732     90.19    246116  26070160

shell> sar -W
pswpin/s pswpout/s
    0.00      0.00

希望你没有被%memused吓到，如果不幸言中，重读本文。

再说说MongoDB是如何使用内存的

目前，MongoDB使用的是内存映射存储引擎，它会把磁盘IO操作转换成内存操作，如果是读操作，内存中的数据起到缓存的作用，如果是写操作，内存还可以把随机的写操作转换成顺序的写操作，总之可以大幅度提升性能。MongoDB并不干涉内存管理工作，而是把这些工作留给操作系统的虚拟内存管理器去处理，这样的好处是简化了MongoDB的工作，但坏处是你没有方法很方便的控制MongoDB占多大内存，事实上MongoDB会占用所有能用的内存，所以最好不要把别的服务和MongoDB放一起。

有时候，即便MongoDB使用的是64位操作系统，也可能会遭遇臭名昭著的OOM问题，出现这种情况，多半是因为限制了虚拟内存的大小所致，可以这样查看当前值：

shell> ulimit -a | grep 'virtual'

多数操作系统缺省都是把它设置成unlimited的，如果你的操作系统不是，可以这样修改：

shell> ulimit -v unlimited

有时候，MongoDB连接数过多的话，也可能影响性能，连接数可以这样查询：

mongo> db.serverStatus().connections

每个连接都是一个线程，需要一个Stack，而Linux下缺省的Stack设置一般比较大：

# ulimit -a | grep stack
stack size              (kbytes, -s) 10240

所有连接消耗的内存加起来会相当惊人，推荐把Stack设置小一点，比如说1024：

shell> ulimit -s 1024

注：ulimit的使用是有上下文的，最好放在MongoDB的启动脚本里。

有时候，出于某些原因，你可能想释放掉MongoDB占用的内存，不过前面说了，内存管理工作是由虚拟内存管理器控制的，所以通常你只能通过重启服务来释放内存，你一定不齿于这样的方法，幸好可以使用MongoDB内置的closeAllDatabases命令达到目的：

mongo> use admin
mongo> db.runCommand({closeAllDatabases:1})

另外，通过调整内核参数drop_caches也可以释放缓存：

shell> sysctl -w vm.drop_caches=1

平时可以通过mongo命令行来监控MongoDB的内存使用情况，如下所示：

mongo> db.serverStatus().mem:
{
    "resident" : 22346,
    "virtual" : 1938524,
    "mapped" : 962283
}

还可以通过mongostat命令来监控MongoDB的内存使用情况，如下所示：

shell> mongostat
mapped  vsize    res faults
  940g  1893g  21.9g      0

其中内存相关字段的含义是：

• mapped：映射到内存的数据大小
• visze：占用的虚拟内存大小
• res：占用的物理内存大小

注：如果操作不能在内存中完成，结果faults列的数值不会是0，视大小可能有性能问题。

在上面的结果中，vsize是mapped的两倍，而mapped等于数据文件的大小，所以说vsize是数据文件的两倍，之所以会这样，是因为本例中，MongoDB开启了journal，需要在内存里多映射一次数据文件，如果关闭journal，则vsize和mapped大致相当。

如果想验证这一点，可以在开启或关闭journal后，通过pmap命令来观察文件映射情况：

shell> pmap $(pidof mongod)

到底MongoDB配备多大内存合适？宽泛点来说，多多益善，如果要确切点来说，这实际取决于你的数据及索引的大小，内存如果能够装下全部数据加索引是最佳情况，不过很多时候，数据都会比内存大，比如本文所涉及的MongoDB实例：

mongo> db.stats()
{
    "dataSize" : 1004862191980,
    "indexSize" : 1335929664
}

本例中索引只有1G多，内存完全能装下，而数据文件则达到了1T，估计很难找到这么大内存，此时保证内存能装下热数据即可，至于热数据是多少，取决于具体的应用。如此一来内存大小就明确了：内存 > 索引 + 热数据，最好有点富余，因为前面提到过，连接本身也要消耗一定的内存，另外，操作系统本身正常运转也需要消耗一部分内存。

关于MongoDB与内存的话题，大家还可以参考官方文档中的相关介绍。

原文：MongoDB与内存
作者：老王

本文将会从实际应用场景出发，介绍一致性哈希算法（Consistent Hash）及其在分布式系统中的应用。首先本文会描述一个在日常开发中经常会遇到的问题场景，借此介绍一致性哈希算法以及这个算法如何解决此问题；接下来会对这个算法进行相对详细的描述，并讨论一些如虚拟节点等与此算法应用相关的话题。

分布式缓存问题

假设我们有一个网站，最近发现随着流量增加，服务器压力越来越大，之前直接读写数据库的方式不太给力了，于是我们想引入Memcached作为缓存机制。现在我们一共有三台机器可以作为Memcached服务器，如下图所示。

很显然，最简单的策略是将每一次Memcached请求随机发送到一台Memcached服务器，但是这种策略可能会带来两个问题：一是同一份数据可能被存在不同的机器上而造成数据冗余，二是有可能某数据已经被缓存但是访问却没有命中，因为无法保证对相同key的所有访问都被发送到相同的服务器。因此，随机策略无论是时间效率还是空间效率都非常不好。

要解决上述问题只需做到如下一点：保证对相同key的访问会被发送到相同的服务器。很多方法可以实现这一点，最常用的方法是计算哈希。例如对于每次访问，可以按如下算法计算其哈希值：

h = Hash(key) % 3

其中Hash是一个从字符串到正整数的哈希映射函数。这样，如果我们将Memcached Server分别编号为0、1、2，那么就可以根据上式和key计算出服务器编号h，然后去访问。

这个方法虽然解决了上面提到的两个问题，但是存在一些其它的问题。如果将上述方法抽象，可以认为通过：

h = Hash(key) % N

这个算式计算每个key的请求应该被发送到哪台服务器，其中N为服务器的台数，并且服务器按照0 – (N-1)编号。

这个算法的问题在于容错性和扩展性不好。所谓容错性是指当系统中某一个或几个服务器变得不可用时，整个系统是否可以正确高效运行；而扩展性是指当加入新的服务器后，整个系统是否可以正确高效运行。

现假设有一台服务器宕机了，那么为了填补空缺，要将宕机的服务器从编号列表中移除，后面的服务器按顺序前移一位并将其编号值减一，此时每个key就要按h = Hash(key) % (N-1)重新计算；同样，如果新增了一台服务器，虽然原有服务器编号不用改变，但是要按h = Hash(key) % (N+1)重新计算哈希值。因此系统中一旦有服务器变更，大量的key会被重定位到不同的服务器从而造成大量的缓存不命中。而这种情况在分布式系统中是非常糟糕的。

一个设计良好的分布式哈希方案应该具有良好的单调性，即服务节点的增减不会造成大量哈希重定位。一致性哈希算法就是这样一种哈希方案。

一致性哈希算法

算法简述

一致性哈希算法（Consistent Hash）最早在论文《Consistent Hashing and Random Trees: Distributed Caching Protocols for Relieving Hot Spots on the World Wide Web》中被提出。简单来说，一致性哈希将整个哈希值空间组织成一个虚拟的圆环，如假设某哈希函数H的值空间为0 - 2³²-1（即哈希值是一个32位无符号整形），整个哈希空间环如下：

整个空间按顺时针方向组织。0和2³²-1在零点中方向重合。

下一步将各个服务器使用H进行一个哈希，具体可以选择服务器的ip或主机名作为关键字进行哈希，这样每台机器就能确定其在哈希环上的位置，这里假设将上文中三台服务器使用ip地址哈希后在环空间的位置如下：

接下来使用如下算法定位数据访问到相应服务器：将数据key使用相同的函数H计算出哈希值h，通根据h确定此数据在环上的位置，从此位置沿环顺时针“行走”，第一台遇到的服务器就是其应该定位到的服务器。

例如我们有A、B、C、D四个数据对象，经过哈希计算后，在环空间上的位置如下：

根据一致性哈希算法，数据A会被定为到Server 1上，D被定为到Server 3上，而B、C分别被定为到Server 2上。

容错性与可扩展性分析

下面分析一致性哈希算法的容错性和可扩展性。现假设Server 3宕机了：

可以看到此时A、C、B不会受到影响，只有D节点被重定位到Server 2。一般的，在一致性哈希算法中，如果一台服务器不可用，则受影响的数据仅仅是此服务器到其环空间中前一台服务器（即顺着逆时针方向行走遇到的第一台服务器）之间数据，其它不会受到影响。

下面考虑另外一种情况，如果我们在系统中增加一台服务器Memcached Server 4：

此时A、D、C不受影响，只有B需要重定位到新的Server 4。一般的，在一致性哈希算法中，如果增加一台服务器，则受影响的数据仅仅是新服务器到其环空间中前一台服务器（即顺着逆时针方向行走遇到的第一台服务器）之间数据，其它不会受到影响。

综上所述，一致性哈希算法对于节点的增减都只需重定位环空间中的一小部分数据，具有较好的容错性和可扩展性。

虚拟节点

一致性哈希算法在服务节点太少时，容易因为节点分部不均匀而造成数据倾斜问题。例如我们的系统中有两台服务器，其环分布如下：

此时必然造成大量数据集中到Server 1上，而只有极少量会定位到Server 2上。为了解决这种数据倾斜问题，一致性哈希算法引入了虚拟节点机制，即对每一个服务节点计算多个哈希，每个计算结果位置都放置一个此服务节点，称为虚拟节点。具体做法可以在服务器ip或主机名的后面增加编号来实现。例如上面的情况，我们决定为每台服务器计算三个虚拟节点，于是可以分别计算“Memcached Server 1#1”、“Memcached Server 1#2”、“Memcached Server 1#3”、“Memcached Server 2#1”、“Memcached Server 2#2”、“Memcached Server 2#3”的哈希值，于是形成六个虚拟节点：

同时数据定位算法不变，只是多了一步虚拟节点到实际节点的映射，例如定位到“Memcached Server 1#1”、“Memcached Server 1#2”、“Memcached Server 1#3”三个虚拟节点的数据均定位到Server 1上。这样就解决了服务节点少时数据倾斜的问题。在实际应用中，通常将虚拟节点数设置为32甚至更大，因此即使很少的服务节点也能做到相对均匀的数据分布。

总结

目前一致性哈希基本成为了分布式系统组件的标准配置，例如Memcached的各种客户端都提供内置的一致性哈希支持。本文只是简要介绍了这个算法，更深入的内容可以参看论文《Consistent Hashing and Random Trees: Distributed Caching Protocols for Relieving Hot Spots on the World Wide Web》，同时提供一个C语言版本的实现供参考。

原文:http://www.cnblogs.com/leoo2sk/archive/2011/08/11/consistent-hash-intro.html
作者:张洋