Ruby on Rails - 快速指南

Ruby on Rails - 简介

什么是红宝石？

在我们开始使用 Rails 之前，让我们回顾一下 Ruby 的几个要点，Ruby 是 Rails 的基础。

Ruby 是以下元素的成功组合：

Smalltalk 的概念优雅，
Python 的易用性和学习性，以及
Perl的实用主义。

红宝石是 -

一种高级编程语言。
像 Perl、Python、Tcl/TK 一样解释。
面向对象，如 Smalltalk、Eiffel、Ada、Java。

为什么是红宝石？

红宝石起源于日本，现在在美国和欧洲也越来越受欢迎。以下因素导致其受欢迎 -

简单易学
开源（非常自由的许可）
丰富的库
非常容易扩展
真正面向对象
更少的编码，更少的错误
乐于助人的社区

尽管我们有很多理由使用 Ruby，但在实现 Ruby 之前您可能必须考虑一些缺点 -

性能问题- 尽管它可以与 Perl 和 Python 相媲美，但它仍然是一种解释性语言，我们无法将它与 C 或 C++ 等高级编程语言进行比较。
线程模型- Ruby 不使用本机线程。Ruby 线程在虚拟机中模拟，而不是作为本机操作系统线程运行。

示例 Ruby 代码

以下是打印“Hello Ruby”的示例 Ruby 代码

# The Hello Class
class Hello
   
   def initialize( name )
      @name = name.capitalize
   end

   def salute
      puts "Hello #{@name}!"
   end
   
end

# Create a new object
h = Hello.new("Ruby")

# Output "Hello Ruby!"
h.salute

输出- 这将产生以下结果 -

Hello Ruby!

嵌入式红宝石

Ruby 提供了一个名为 ERB（Embedded Ruby）的程序，由Seki Masatoshi编写。ERB 允许您将 Ruby 代码放入 HTML 文件中。ERB 逐字阅读，然后在某个时刻，当它遇到文档中嵌入的 Ruby 代码时，它开始执行该 Ruby 代码。

您只需要知道两件事即可准备 ERB 文件 -

如果您想要执行一些 Ruby 代码，请将其括在<%和%> 之间。
如果您希望将代码执行的结果作为输出的一部分打印出来，请将代码括在<%=和%>之间。

这是一个例子。将代码保存在 erbdemo.rb 文件中。请注意，Ruby 文件的扩展名是.rb -

<% page_title = "Demonstration of ERB" %>
<% salutation = "Dear programmer," %>

<html>

   <head>
      <title><%= page_title %></title>
   </head>
	
   <body>
      <p><%= salutation %></p>
      <p>This is an example of how ERB fills out a template.</p>
   </body>
	
</html>

现在，使用命令行实用程序erb运行该程序。

tp> erb erbdemo.rb

这将产生以下结果 -

<html>

   <head>
      <title>Demonstration of ERb</title>
   </head>
	
   <body>
      <p>Dear programmer,</p>
      <p>This is an example  of how ERb fills out a template.</p>
   </body>
	
</html>

什么是Rails？

一个极其高效的 Web 应用程序框架。
由 David Heinemeier Hansson 用 Ruby 编写。
使用 Rails 开发 Web 应用程序的速度至少比使用典型 Java 框架快十倍。
用于开发数据库支持的 Web 应用程序的开源 Ruby 框架。
使用数据库架构配置您的代码。
无需编译阶段。

全栈框架

包括使用模型-视图-控制器模式创建数据库驱动的 Web 应用程序所需的一切。
作为一个全栈框架意味着所有层都可以用更少的代码无缝地协同工作。
比其他框架需要更少的代码行。

约定优于配置

Rails 避开配置文件，转而采用约定、反射和动态运行时扩展。
您的应用程序代码和正在运行的数据库已经包含 Rails 需要了解的所有内容！

导轨的优势

Rails 包含许多可提高您工作效率的功能，其中许多功能是相互构建的。

元编程

其他框架从头开始使用大量代码生成，而 Rail 框架使用元编程技术来编写程序。Ruby 是元编程的最佳语言之一，Rails 很好地利用了这一功能。Rails 也使用代码生成，但更多地依赖于元编程来完成繁重的工作。

活动记录

Rails 引入了 Active Record 框架，它将对象保存到数据库中。Rails 版本的 Active Record 会发现数据库模式中的列，并使用元编程自动将它们附加到您的域对象。

约定优于配置

大多数 .NET 或 Java 的 Web 开发框架都强制您编写配置代码页。如果遵循建议的命名约定，Rails 不需要太多配置。

脚手架

您经常在开发的早期阶段创建临时代码，以帮助快速启动应用程序并了解主要组件如何协同工作。Rails 会自动创建您需要的大部分脚手架。

内置测试

Rails 创建简单的自动化测试，然后您可以扩展。Rails 还提供称为harness 和fixture 的支持代码，使测试用例更易于编写和运行。然后，Ruby 可以使用 rake 实用程序执行所有自动化测试。

三种环境

Rails 为您提供了三种默认环境：开发、测试和生产。每个的行为都略有不同，使您的整个软件开发周期更容易。例如，Rails 为每次测试运行创建一个新的测试数据库副本。

Ruby on Rails - 安装

要使用 Ruby on Rails 框架开发 Web 应用程序，您需要安装以下软件 -

红宝石
Rails 框架
网络服务器
数据库系统

我们假设您已经在计算机上安装了 Web 服务器和数据库系统。您可以使用 Ruby 附带的 WEBrick Web 服务器。然而，大多数网站在生产中使用 Apache 或 lightTPD Web 服务器。

Rails 可与许多数据库系统配合使用，包括 MySQL、PostgreSQL、SQLite、Oracle、DB2 和 SQL Server。请参阅相应的数据库系统设置手册来设置您的数据库。

让我们看一下 Windows 和 Linux 上 Rails 的安装说明。

Windows 上的 Rails 安装

请按照下面给出的步骤安装 Ruby on Rails。

第 1 步：检查 Ruby 版本

首先，检查您是否已经安装了 Ruby。打开命令提示符并输入ruby -v。如果 Ruby 有响应，并且显示版本号等于或高于 2.2.2，则输入gem --version。如果没有收到错误，请跳过安装 Ruby步骤。否则，我们将安装一个新的 Ruby。

第 2 步：安装红宝石

如果未安装 Ruby，请从rubyinstaller.org下载安装包。点击下载链接，然后运行生成的安装程序。这是一个 exe 文件rubyinstaller-2.2.2.x.exe，只需单击一下即可安装。这是一个非常小的软件包，您还将随该软件包一起获得 RubyGems。请查看发行说明以了解更多详细信息。

第 3 步：安装导轨

安装 Rails - 加载 Rubygems 后，您可以通过命令行使用以下命令安装所有 Rails 及其依赖项 -

C:\> gem install rails

注意- 上述命令可能需要一些时间来安装所有依赖项。确保在安装 gems 依赖项时已连接到互联网。

第 4 步：检查 Rails 版本

使用以下命令检查 Rails 版本。

C:\> rails -v

输出

Rails 4.2.4

恭喜！您现在使用的是 Windows 上的 Rails。

Linux 上的 Rails 安装

我们使用rbenv在 Linux 上安装 Ruby On Rails 。它是一个轻量级的 Ruby 版本管理工具。rbenv提供了一个简单的安装过程来管理各种版本的 Ruby，并为开发 Ruby on Rails 应用程序提供了可靠的环境。

按照下面给出的步骤使用 rbenv 工具安装 Ruby on Rails。

第 1 步：安装必备依赖项

首先，我们必须安装git - core和一些有助于安装 Ruby on Rails 的 ruby 依赖项。使用以下命令使用yum安装 Rails 依赖项。

tp> sudo yum install -y git-core zlib zlib-devel gcc-c++ patch readline readline-devel libyaml-devel libffi-devel openssl-devel make bzip2 autoconf automake libtool bison curl sqlite-devel

第2步：安装rbenv

现在我们将安装 rbenv 并设置适当的环境变量。使用以下命令集获取 git 存储库的 rbenv。

tp> git clone git://github.com/sstephenson/rbenv.git .rbenv
tp> echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
tp> echo 'eval "$(rbenv init -)"' >> ~/.bash_profile
tp> exec $SHELL

tp> git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
tp> echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' << ~/.bash_profile
tp> exec $SHELL

第三步：安装红宝石

在安装 Ruby 之前，确定要安装的 Ruby 版本。我们将安装 Ruby 2.2.3。使用以下命令安装 Ruby。

tp> rbenv install -v 2.2.3

使用以下命令将当前 Ruby 版本设置为默认版本。

tp> rbenv global 2.2.3

使用以下命令验证 Ruby 版本。

tp> ruby -v

输出

ruby 2.2.3p173 (2015-08-18 revivion 51636) [X86_64-linux]

Ruby 提供了一个关键字gem来安装支持的依赖项；我们称它们为宝石。如果您不想安装 Ruby-gems 的文档，请使用以下命令。

tp> echo "gem: --no-document" > ~/.gemrc

此后，最好安装 Bundler gem，因为它有助于管理应用程序依赖项。使用以下命令安装捆绑程序 gem。

tp> gem install bundler

第 4 步：安装导轨

使用以下命令安装 Rails 版本 4.2.4。

tp> install rails -v 4.2.4

使用以下命令使 Rails 可执行文件可用。

tp> rbenv rehash

使用以下命令检查 Rails 版本。

tp> rails -v

输出

tp> Rails 4.2.4

Ruby on Rails 框架需要 JavaScript 运行时环境 (Node.js) 来管理 Rails 的功能。接下来，我们将了解如何使用 Node.js 来管理 Rails 的一项功能 Asset Pipeline。

第 5 步：安装 JavaScript 运行时

让我们从 Yum 存储库安装 Node.js。我们将从 EPEL yum 存储库获取 Node.js。使用以下命令将 EPEL 包添加到 yum 存储库。

tp> sudo yum -y install epel-release

使用以下命令安装 Node.js 包。

tp> sudo yum install nodejs

恭喜！您现在使用的是 Rails over Linux。

第6步：安装数据库

默认情况下，Rails 使用 sqlite3，但您可能需要安装 MySQL、PostgreSQL 或其他 RDBMS。这是可选的；如果您已经安装了数据库，那么您可以跳过此步骤，并且并不强制您安装数据库来启动rails服务器。在本教程中，我们使用 PostgreSQL 数据库。因此，使用以下命令来安装 PostgreSQL。

tp> sudo yum install postgresql-server postgresql-contrib

通过回答y来接受提示。使用以下命令创建 PostgreSQl 数据库集群。

tp> sudo postgresql-setup initdb

使用以下命令启动并启用 PostgreSQL。

tp> sudo systemctl start postgresql
tp> sudo systemctl enable postgresql

保持 Rails 最新

假设您已经使用 RubyGems 安装了 Rails，那么保持其最新状态相对容易。我们可以在Windows和Linux平台上使用相同的命令。使用以下命令 -

tp> gem update rails

输出

以下屏幕截图显示了 Windows 命令提示符。Linux 终端也提供相同的输出。

这将自动更新您的 Rails 安装。下次重新启动应用程序时，它将选择最新版本的 Rails。使用此命令时，请确保您已连接到互联网。

安装验证

您可以验证一切是否按照您的要求设置。使用以下命令创建演示项目。

tp> rails new demo

输出

它将生成一个演示铁路项目；我们稍后再讨论。目前我们需要检查环境是否已设置。接下来，使用以下命令在您的计算机上运行 WEBrick Web 服务器。

tp> cd demo
tp> rails server

它将生成自动代码来启动服务器

现在打开浏览器并输入以下内容 -

http://localhost:3000

它应该显示一条消息，例如“欢迎登机”或“恭喜”。

Ruby on Rails - 框架

框架是一个程序、一组程序和/或代码库，可以为您编写大部分应用程序。当您使用框架时，您的工作是编写应用程序的各个部分，使其执行您想要的特定操作。

当您开始编写 Rails 应用程序时，抛开配置和其他杂务，您必须执行三个主要任务 -

描述和建模您的应用程序的域- 域是您的应用程序的宇宙。该域可以是音乐商店、大学、约会服务、地址簿或硬件库存。所以在这里你必须弄清楚它里面有什么，这个宇宙中存在什么实体以及其中的项目如何相互关联。这相当于对数据库结构进行建模以保留实体及其关系。
指定该域中可能发生的情况- 域模型是静态的；你必须让它充满活力。地址可以添加到地址簿中。乐谱可以从音乐商店购买。用户可以登录约会服务。学生可以在大学注册课程。您需要确定域元素可以参与的所有可能场景或操作。
选择并设计该域的公开可用视图- 此时，您可以开始用 Web 浏览器术语进行思考。一旦您确定您的域中有学生，并且他们可以注册课程，您就可以设想一个欢迎页面、注册页面和确认页面等。每个页面或视图都会向用户展示如何进行操作站在某一点上。

基于以上三个任务，Ruby on Rails 处理模型/视图/控制器（MVC）框架。

Ruby on Rails MVC 框架

模型视图控制器原理将应用程序的工作划分为三个独立但紧密协作的子系统。

模型（ActiveRecord）

它维护对象和数据库之间的关系，并处理验证、关联、事务等。

该子系统在 ActiveRecord 库中实现，该库提供关系数据库中的表与操作数据库记录的 Ruby 程序代码之间的接口和绑定。Ruby 方法名称是根据数据库表的字段名称自动生成的。

视图（动作视图）

它是以特定格式呈现数据，由控制器决定呈现数据而触发。它们是基于脚本的模板系统，如 JSP、ASP、PHP，并且非常容易与 AJAX 技术集成。

该子系统在 ActionView 库中实现，该库是一个基于嵌入式 Ruby (ERb) 的系统，用于定义数据呈现的呈现模板。每个与 Rails 应用程序的 Web 连接都会导致视图的显示。

控制器（动作控制器）

应用程序中引导流量的工具，一方面查询模型中的特定数据，另一方面将数据组织（搜索、排序、消息传递）为适合给定视图需求的形式。

该子系统在 ActionController 中实现，它是位于 ActiveRecord（数据库接口）和 ActionView（表示引擎）之间的数据代理。

MVC框架图解

下面给出的是 Ruby on Rails 框架的图示 -

MVC框架的目录表示

假设在 Linux 上进行了标准的默认安装，您可以像这样找到它们 -

tp> cd /usr/local/lib/ruby/gems/2.2.0/gems
tp> ls

您将看到子目录，包括（但不限于）以下内容 -

动作包-xyz
活动记录-xyz
轨道 xyz

通过 Windows 安装，您可以像这样找到它们 -

tp>cd ruby\lib\ruby\gems\2.2.0\gems
ruby\lib\ruby\gems\2.2.0\gems\>dir

您将看到子目录，包括（但不限于）以下内容 -

ActionView 和 ActionController 在 ActionPack 下捆绑在一起。

ActiveRecord 提供了一系列编程技术和快捷方式来操作 SQL 数据库中的数据。ActionController 和 ActionView 提供了操作和显示该数据的工具。Rails 将这一切联系在一起。

Ruby on Rails - 目录结构

当您使用 Rails 帮助程序脚本创建应用程序时，它会为应用程序创建整个目录结构。Rails 知道在这个结构中哪里可以找到它需要的东西，因此您不必提供任何输入。

这是在创建应用程序时由帮助程序脚本创建的目录树的顶级视图。除了版本之间的微小变化之外，每个 Rails 项目都将具有相同的结构和相同的命名约定。这种一致性给你带来了巨大的优势；您可以在 Rails 项目之间快速移动，而无需重新学习项目的组织。

为了理解这个目录结构，让我们使用在安装章节中创建的演示应用程序。它可以使用简单的辅助命令rails demo创建。

现在，进入演示应用程序根目录，如下所示 -

tp> cd demo
demo> dir

您将在 Windows 中找到如下目录结构 -

现在我们来解释一下每个目录的用途

app - 它组织您的应用程序组件。它有包含视图（视图和助手）、控制器（控制器）和后端业务逻辑（模型）的子目录。
app/controllers - 控制器子目录是 Rails 寻找控制器类的地方。控制器处理来自用户的网络请求。
app/helpers - helpers 子目录包含用于协助模型、视图和控制器类的任何帮助器类。这有助于保持模型、视图和控制器代码小、集中且整洁。
app/models - models 子目录包含对存储在应用程序数据库中的数据进行建模和包装的类。在大多数框架中，应用程序的这一部分可能会变得非常混乱、乏味、冗长且容易出错。Rails 让它变得非常简单！
app/view - 视图子目录包含显示模板，用于填充应用程序中的数据，转换为 HTML，然后返回到用户的浏览器。
app/view/layouts - 保存要与视图一起使用的布局的模板文件。这模拟了包装视图的常见页眉/页脚方法。在您的视图中，使用 <tt>layout:default</tt> 定义布局并创建名为 default.html.erb 的文件。在 default.html.erb 中，调用 <% yield %> 使用此布局渲染视图。
Components - 该目录包含组件、捆绑模型、视图和控制器的小型独立应用程序。
config - 该目录包含应用程序所需的少量配置代码，包括数据库配置（在database.yml中）、Rails环境结构（environment.rb）以及传入Web请求的路由（routes.rb）。您还可以使用环境目录中的文件定制三个 Rails 环境的行为，以进行测试、开发和部署。
db - 通常，您的 Rails 应用程序将具有访问关系数据库表的模型对象。您可以使用您创建并放置在此目录中的脚本来管理关系数据库。
doc - Ruby 有一个名为 RubyDoc 的框架，它可以自动为您创建的代码生成文档。您可以通过代码中的注释来协助 RubyDoc。该目录包含所有 RubyDoc 生成的 Rails 和应用程序文档。
lib - 您将把库放在这里，除非它们明确属于其他地方（例如供应商库）。
log - 错误日志放在这里。Rails 创建脚本来帮助您管理各种错误日志。您将找到服务器 (server.log) 和每个 Rails 环境（development.log、test.log 和 production.log）的单独日志。
public - 与 Web 服务器的公共目录类似，该目录包含不会更改的 Web 文件，例如 JavaScript 文件（public/javascripts）、图形（public/images）、样式表（public/stylesheets）和 HTML 文件（民众）。
script - 此目录包含用于启动和管理将与 Rails 一起使用的各种工具的脚本。例如，有一些脚本可以生成代码（generate）和启动Web服务器（server）。
test - 您编写的测试和 Rails 为您创建的测试都在这里。你会看到一个子目录，里面有模拟（mocks）、单元测试（unit）、固定装置（fixtures）和功能测试（functioning）。
tmp - Rails 使用此目录保存临时文件以进行中间处理。
供应商- 第三方供应商提供的库（例如基本 Rails 发行版之外的安全库或数据库实用程序）位于此处。

除了这些目录之外，demo 目录中还有两个文件。

自述文件- 该文件包含有关铁路应用程序的基本详细信息以及上述目录结构的描述。
Rakefile - 该文件类似于 Unix Makefile，有助于构建、打包和测试 Rails 代码。这将由随 Ruby 安装一起提供的 rake 实用程序使用。

Ruby on Rails - 示例

在本章中，我们将创建一个简单但可操作的在线图书馆系统来保存和管理书籍。

该应用程序具有基本架构，并将使用两个 ActiveRecord 模型来构建来描述存储的数据类型 -

书籍，描述实际列表。
主题，用于将书籍分组在一起。

创建 Rails 应用程序的工作流程

创建 Rails 应用程序的推荐工作流程如下：

使用rails命令创建应用程序的基本框架。
在 PostgreSQL 服务器上创建一个数据库来保存您的数据。
配置应用程序以了解数据库所在的位置及其登录凭据。
创建 Rails Active Records（模型），因为它们是您将在控制器中使用的业务对象。
生成迁移，简化数据库表和列的创建和维护。
编写控制器代码以使您的应用程序充满活力。
创建视图以通过用户界面呈现您的数据。

那么，让我们从创建图书馆应用程序开始。

创建空的 Rails Web 应用程序

Rails 既是一个运行时 Web 应用程序框架，又是一组帮助程序脚本，可自动执行开发 Web 应用程序时执行的许多操作。在此步骤中，我们将使用一个此类帮助程序脚本来创建整个目录结构和初始文件集以启动我们的图书馆系统应用程序。

进入 ruby 安装目录来创建您的应用程序。
运行以下命令来创建库应用程序的骨架。它将在当前目录中创建目录结构。

tp> rails new library

这将为库应用程序创建一个子目录，其中包含空 Rails 应用程序的文件夹和文件的完整目录树。检查应用程序的完整目录结构。检查Rails 目录结构以获取更多详细信息。

我们的大部分开发工作将是在库/应用程序子目录中创建和编辑文件。以下是如何使用它们的快速概述 -

Rails 会在controllers子目录中查找控制器类。控制器处理来自用户的网络请求。
view子目录包含显示模板，用于填充应用程序中的数据、转换为 HTML，然后返回到用户的浏览器。
models子目录包含对存储在应用程序数据库中的数据进行建模和包装的类。在大多数框架中，应用程序的这一部分可能会变得非常混乱、乏味、冗长且容易出错。Rails 让它变得非常简单。
helpers子目录包含用于辅助模型、视图和控制器类的任何帮助器类。这有助于保持模型、视图和控制器代码小、集中且整洁。

启动网络服务器

Rails Web 应用程序几乎可以在任何 Web 服务器下运行，但开发 Rails Web 应用程序最方便的方法是使用内置的 WEBrick Web 服务器。让我们启动这个 Web 服务器，然后浏览到我们的空库应用程序 -

该服务器将从应用程序目录启动，如下所示。它在端口号 3000 上运行。

tp> cd ruby\library 
tp\ruby\library\> Rails server

它生成自动代码来启动服务器，如下所示 -

这将启动您的 WEBrick Web 服务器。

现在打开浏览器并浏览到http://127.0.0.1:3000。如果一切顺利，那么您应该会看到来自 WEBrick 的问候消息，否则您的设置有问题。如果一切顺利，它将生成如下输出。

下一步是什么？

下一章解释如何为您的应用程序创建数据库以及访问这些创建的数据库所需的配置。

此外，我们将了解 Rails Migration 是什么以及如何使用它来维护数据库表。

Ruby on Rails - 数据库设置

在开始本章之前，请确保您的数据库服务器已启动并正在运行。Ruby on Rails 建议创建三个数据库——每个数据库用于开发、测试和生产环境。按照惯例，他们的名字应该是 -

图书馆发展
图书馆生产
库测试

您应该初始化所有三个，并为它们创建具有完全读写权限的用户和密码。我们正在为我们的应用程序使用root用户 ID。

MySQL 的数据库设置

在 MySQL 中，我们的应用程序使用root用户 ID。执行此操作的 MySQL 控制台会话类似于 -

mysql> create database library_development;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on library_development.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

您可以对另外两个数据库Library_Production和Library_Test执行相同的操作。

配置数据库.yml

此时，您需要让 Rails 了解数据库的用户名和密码。您可以在文件database.yml中执行此操作，该文件位于您创建的Rails 应用程序的library\config子目录中。该文件包含 MySQL 数据库的实时配置部分。在您使用的每个部分中，您需要更改用户名和密码行以反映您所创建的数据库的权限。

完成后，它应该看起来像这样 -

development:
   adapter: mysql
   database: library_development
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: library_test
   username: root
   password: [password]
   host: localhost
   
production:
   adapter: mysql
   database: library_production
   username: root
   password: [password]
   host: localhost

PostgreSQL 的数据库设置

默认情况下，PostgreSQL不提供任何用户。我们必须创建新用户。使用以下命令创建名为rubyuser的用户。

tp> sudo -u postgres createuser rubyuser -s

如果要为新用户创建密码，请使用以下命令。

tp> sudo -u postgres psql

postgres=# \password rubyuser

使用以下命令创建数据库library_development。

postgres=# CREATE DATABASE library_development OWNER rubyuser; 

CREATE DATABASE

使用以下命令创建数据库Library_Production。

postgres=# CREATE DATABASE library_production OWNER rubyuser; 

CREATE DATABASE

使用以下命令创建数据库library_test。

postgres=# CREATE DATABASE library_test OWNER rubyuser; 

CREATE DATABASE

按Ctrl+D终止 PosgreSQL。

配置数据库.yml

此时，您需要让 Rails 知道数据库的用户名和密码。您可以在文件database.yml中执行此操作，该文件位于您创建的Rails 应用程序的library\config子目录中。该文件具有 PostgreSQL 数据库的实时配置部分。在每个部分中，您需要更改用户名和密码行以反映您所创建的数据库的权限。

完成后，它应该如下所示 -

default: &default
   adapter: postgresql
   encoding: unicode
  
development:
   adapter: postgresql
   encoding: unicode
   database: library_development
   username: rubyuser
   password: <Password for rubyuser>

test:
   adapter: postgresql
   encoding: unicode
   database: library_test
   username: rubyuser
   password: <Password for rubyuser>
 
production:
   adapter: postgresql
   encoding: unicode
   database: library_production
   username: rubyuser
   password: <Password for rubyuser>

下一步是什么？

接下来的两章解释如何对数据库表进行建模以及如何使用 Rails 迁移来管理这些表。

Ruby on Rails - 活动记录

Rails Active Record 是Rails 提供的对象/关系映射(ORM) 层。它紧密遵循标准 ORM 模型，如下所示 -

表映射到类，
行映射到对象和
列映射到对象属性。

Rails Active Records 提供了关系数据库中的表与操作数据库记录的 Ruby 程序代码之间的接口和绑定。Ruby 方法名称是根据数据库表的字段名称自动生成的。

每个 Active Record 对象都有用于数据库访问的CRUD（创建、读取、更新和删除）方法。该策略允许简单的设计以及数据库表和应用程序对象之间的直接映射。

将领域模型转换为 SQL

将域模型转换为 SQL 通常很简单，只要您记住必须编写 Rails 友好的 SQL。实际上，你必须遵循某些规则 -

每个实体（例如书籍）在数据库中都有一个以其名称命名的表，但以复数形式（书籍）。
每个这样的实体匹配表都有一个名为id的字段，其中包含插入表中的每条记录的唯一整数。
给定实体x和实体y，如果实体y属于实体x，则表y有一个名为x_id的字段。
任何表中的大部分字段都存储该实体的简单属性（任何数字或字符串）的值。

创建 Active Record 文件（模型）

要为上一章中介绍的库应用程序的实体创建 Active Record 文件，请从应用程序目录的顶层发出以下命令。

library\> ruby script/generate model Book
library\> ruby script/generate model Subject

上面的rails生成模型书命令生成自动代码如下 -

您告诉生成器创建名为“书籍”和“主题”的模型来存储书籍和主题的实例。请注意，您将 Book 和主题大写并使用单数形式。这是每次创建模型时都应该遵循的 Rails 范例。

当您使用生成工具时，Rails 会创建实际的模型文件，其中包含模型特有的所有方法和您定义的业务规则、用于执行测试驱动开发的单元测试文件、要使用的示例数据文件（称为固定装置）通过单元测试和 Rails 迁移，可以轻松创建数据库表和列。

除了创建许多其他文件和目录之外，这还将在app/models目录中创建名为book.rb和subject.rb的文件，其中包含框架定义。

book.rb 中提供的内容 -

class Book < ActiveRecord::Base
end

subject.rb 中提供的内容 -

class Subject < ActiveRecord::Base
end

创建模型之间的关联

当 Rails 应用程序中有多个模型时，您需要在这些模型之间创建连接。您可以通过协会来做到这一点。Active Record 支持三种类型的关联 -

一对一- 当一个项目恰好具有另一个项目之一时，就存在一对一关系。例如，一个人只有一个生日，或者一只狗只有一个主人。
一对多- 当单个对象可以是许多其他对象的成员时，就存在一对多关系。例如，一门学科可以有多本书。
多对多- 当第一个对象与第二个对象中的一个或多个相关，并且第二个对象与第一个对象中的一个或多个相关时，存在多对多关系。

您可以通过向模型添加声明来指示这些关联：has_one、has_many、belongs_to 和 has_and_belongs_to_many。

现在，您需要告诉 Rails 您想要在图书馆数据系统中建立什么关系。为此，请将 book.rb 和 subject.rb 修改为如下所示 -

class Book < ActiveRecord::Base
   belongs_to :subject
end

我们在上面的示例中使用了单个主题，因为一本书可以属于单个主题。

class Subject < ActiveRecord::Base
   has_many :books
end

我们在这里使用了多本书，因为一个主题可以有多本书。

对模型实施验证

验证的实现是在 Rails 模型中完成的。您输入数据库的数据是在实际的 Rails 模型中定义的，因此只有在同一位置定义有效数据所包含的内容才有意义。

验证是 -

标题字段的值不应为 NULL。
价格字段的值应该是数字。

打开app\model子目录中的book.rb并输入以下验证 -

class Book < ActiveRecord::Base
   belongs_to :subject
   validates_presence_of :title
   validates_numericality_of :price, :message=>"Error Message"
end

validates_presence_of - 保护“NOT NULL”字段免受丢失用户输入的影响。
validates_numericality_of - 防止用户输入非数字数据。

除了上面提到的验证之外，还有其他常见的验证。检查Rails 快速指南。

下一步是什么？

在下一章中，我们将学习 Rails 迁移，它允许您使用 Ruby 定义对数据库模式的更改，从而可以使用版本控制系统使内容与实际代码保持同步。

Ruby on Rails - 迁移

Rails Migration 允许您使用 Ruby 定义对数据库模式的更改，从而可以使用版本控制系统使内容与实际代码保持同步。

这有很多用途，包括 -

开发人员团队- 如果一个人进行架构更改，其他开发人员只需更新并运行“rake migrate”。
生产服务器- 当您推出新版本时运行“rake migrate”以使数据库也保持最新。
多台机器- 如果您在台式机和笔记本电脑上或在多个位置进行开发，迁移可以帮助您保持它们全部同步。

Rails 迁移可以做什么？

创建表（名称，选项）
drop_table（名称）
重命名表（旧名称，新名称）
add_column(表名、列名、类型、选项)
重命名列（表名，列名，新列名）
更改列（表名、列名、类型、选项）
删除列（表名，列名）
add_index（表名，列名，索引类型）
删除索引（表名，列名）

迁移支持所有基本数据类型- 以下是迁移支持的数据类型列表 -

string - 用于小数据类型，例如标题。
text - 用于较长的文本数据，例如描述。
整数- 表示整数。
float - 用于小数。
日期时间和时间戳- 将日期和时间存储到列中。
日期和时间- 仅存储日期或仅存储时间。
二进制- 用于存储图像、音频或电影等数据。
布尔值- 用于存储真值或假值。

有效的列选项是- 以下是有效列选项的列表。

限制（：限制=>“50”）
默认（：默认=>“废话”）
null (:null => false 意味着NOT NULL )

注意- Rails Migration 完成的活动可以使用任何前端 GUI 或直接在 SQL 提示符上完成，但 Rails Migration 使所有这些活动变得非常容易。

有关这些的详细信息，请参阅Rails API 。

创建迁移

这是创建迁移的通用语法 -

application_dir> rails generate migration table_name

这将创建文件 db/migrate/001_table_name.rb。迁移文件包含描述数据库表的数据结构的基本 Ruby 语法。

注意- 在运行迁移生成器之前，建议清理模型生成器生成的现有迁移。

我们将创建与我们的三个表相对应的两个迁移 - books 和subjects。

书籍迁移应如下 -

tp> cd library
library> rails generate migration books

上述命令生成以下代码。

主体迁移应如下 -

tp> cd library
library> rails generate migration subjects

上述命令生成以下代码。

请注意，在创建迁移时，您使用小写字母表示书籍和主题以及复数形式。这是每次创建迁移时都应该遵循的 Rails 范例。

编辑代码

转到应用程序的 db/migrate 子目录，并使用任何简单的文本编辑器一一编辑每个文件。

修改 001_books.rb 如下 -

ID 列将自动创建，因此也不要在此处执行此操作。

class Books < ActiveRecord::Migration
   
   def self.up
      create_table :books do |t|
         t.column :title, :string, :limit => 32, :null => false
         t.column :price, :float
         t.column :subject_id, :integer
         t.column :description, :text
         t.column :created_at, :timestamp
      end
   end

   def self.down
      drop_table :books
   end
end

self.up方法用于迁移到新版本时，self.down用于在需要时回滚任何更改。此时，上面的脚本将用于创建books表。

修改 002_subjects.rb 如下 -

class Subjects < ActiveRecord::Migration
   def self.up
      
      create_table :subjects do |t|
         t.column :name, :string
      end
	
      Subject.create :name => "Physics"
      Subject.create :name => "Mathematics"
      Subject.create :name => "Chemistry"
      Subject.create :name => "Psychology"
      Subject.create :name => "Geography"
   end

   def self.down
      drop_table :subjects
   end
end

上面的脚本将用于创建主题表，并将在主题表中创建 5 条记录。

运行迁移

现在您已经创建了所有必需的迁移文件。现在是针对数据库执行它们的时候了。为此，请转到命令提示符并转到应用程序所在的库目录，然后键入rake migrate ，如下所示 -

library> rake db:migrate

如果不存在，这将创建一个“schema_info”表，该表跟踪数据库的当前版本 - 每个新迁移都将是一个新版本，并且任何新迁移都将运行，直到数据库处于当前版本为止。

Rake是一个类似于 Unix make程序的 Ruby 构建程序，Rails 利用它来简化复杂任务的执行，例如更新数据库结构等。

运行生产和测试数据库的迁移

如果您想指定用于迁移的 Rails 环境，请使用 RAILS_ENV shell 变量。

例如 -

library> export RAILS_ENV = production
library> rake db:migrate
library> export RAILS_ENV = test
library> rake db:migrate
library> export RAILS_ENV = development
library> rake db:migrate

注意- 在 Windows 中，使用“set RAILS_ENV = production”而不是导出命令。

下一步是什么？

现在我们有了数据库和所需的表。在后续的两章中，我们将探讨两个重要的组件，称为控制器（ActionController）和视图（ActionView）。

创建控制器（动作控制器）。
创建视图（操作视图）。

Ruby on Rails - 控制器

Rails 控制器是应用程序的逻辑中心。它协调用户、视图和模型之间的交互。该控制器也是许多重要辅助服务的所在地。

它负责将外部请求路由到内部操作。它可以很好地处理人性化的 URL。
它管理缓存，可以使应用程序的性能得到数个数量级的提升。
它管理帮助程序模块，这些模块扩展了视图模板的功能，而无需增加代码量。
它管理会话，给用户留下与我们的应用程序持续交互的印象。

创建控制器的过程非常简单，它与我们已经用于创建模型的过程类似。我们将在这里创建一个控制器 -

library\> rails generate controller Book

请注意，您将 Book 大写并使用单数形式。这是每次创建控制器时都应该遵循的 Rails 范例。

该命令完成多项任务，其中以下内容与此处相关 -

它创建一个名为app/controllers/book_controller.rb的文件

如果你查看 book_controller.rb，你会发现它如下 -

class BookController < ApplicationController
end

控制器类继承自ApplicationController，它是控制器文件夹中的另一个文件：application.rb。

ApplicationController包含可以在所有控制器中运行的代码，它继承自 Rails ActionController ::Base类。

目前您还不需要担心 ApplicationController ，因此我们只需在book_controller.rb中定义一些方法存根即可。根据您的要求，您可以在此文件中定义任意数量的函数。

修改文件如下所示并保存更改。请注意，您想为这些方法指定什么名称取决于您，但最好指定相关名称。

class BookController < ApplicationController
   def list
   end
   
   def show
   end
   
   def new
   end
   
   def create
   end
   
   def edit
   end
   
   def update
   end
   
   def delete
   end
   
end

现在让我们一一实现所有的方法。

实现列表方法

list 方法为您提供数据库中所有书籍的列表。该功能将通过以下代码行来实现。在 book_controller.rb 文件中编辑以下行。

def list
   @books = Book.all
end

list 方法中的@books = Book.all行告诉 Rails 搜索 books 表并将找到的每一行存储在 @books 实例对象中。

实现show方法

show 方法仅显示单本书的更多详细信息。该功能将通过以下代码行来实现。

def show
   @book = Book.find(params[:id])
end

show 方法的@book = Book.find(params[:id])行告诉 Rails 仅查找具有 params[:id] 中定义的 id 的书。

params 对象是一个容器，使您能够在方法调用之间传递值。例如，当您在 list 方法调用的页面上时，您可以单击特定书籍的链接，它会通过 params 对象传递该书籍的 id，以便 show 可以找到特定书籍。

实施新方法

新方法让 Rails 知道您将创建一个新对象。所以只需在这个方法中添加如下代码即可。

def new
   @book = Book.new
   @subjects = Subject.all
end

当您向用户显示页面以接受用户输入时，将调用上述方法。第二行从数据库中获取所有主题并将它们放入名为 @subjects 的数组中。

实现创建方法

使用 HTML 表单获取用户输入后，就可以在数据库中创建记录了。为此，请编辑 book_controller.rb 中的创建方法以匹配以下内容 -

def create
   @book = Book.new(book_params)
	
   if @book.save
      redirect_to :action => 'list'
   else
      @subjects = Subject.all
      render :action => 'new'
   end
   
end

def book_params
   params.require(:books).permit(:title, :price, :subject_id, :description)
end

第一行创建一个名为 @book 的新实例变量，它保存根据用户提交的数据构建的 Book 对象。book_params方法用于收集对象:books中的所有字段。数据是从新方法传递来使用 params 对象创建的。

下一行是条件语句，如果对象正确保存到数据库，则将用户重定向到列表方法。如果不保存，用户将被发送回新方法。redirect_to 方法类似于在网页上执行元刷新：它会自动将您转发到目的地，无需任何用户交互。

然后@subjects = subject.all是必需的，以防它没有成功保存数据并且它变得与新选项类似的情况。

实现编辑方法

edit 方法看起来与 show 方法几乎相同。这两种方法都用于根据 id 检索单个对象并将其显示在页面上。唯一的区别是 show 方法不可编辑。

def edit
   @book = Book.find(params[:id])
   @subjects = Subject.all
end

将调用该方法将数据显示在屏幕上以供用户修改。第二行从数据库中获取所有主题并将它们放入名为@subjects 的数组中。

实现更新方法

当用户修改数据并希望将更改更新到数据库中时，将在编辑方法之后调用此方法。update方法与create方法类似，将用于更新数据库中现有的书籍。

def update
   @book = Book.find(params[:id])
	
   if @book.update_attributes(book_param)
      redirect_to :action => 'show', :id => @book
   else
      @subjects = Subject.all
      render :action => 'edit'
   end
   
end

def book_param
   params.require(:book).permit(:title, :price, :subject_id, :description)
end

update_attributes 方法与 create 使用的 save 方法类似，但它不是在数据库中创建新行，而是覆盖现有行的属性。

然后@subjects = subject.all行是必需的，以防它没有成功保存数据，然后它变得类似于编辑选项。

实现删除方法

如果您想从数据库中删除一条记录，那么您将使用此方法。按如下方式实现该方法。

def delete
   Book.find(params[:id]).destroy
   redirect_to :action => 'list'
end

第一行根据通过 params 对象传递的参数找到分类，然后使用 destroy 方法将其删除。第二行使用redirect_to 调用将用户重定向到列表方法。

显示主题的其他方法

假设您想为用户提供一种工具来浏览基于给定主题的所有书籍。因此，您可以在 book_controller.rb 中创建一个方法来显示所有主题。假设方法名称是show_subjects -

def show_subjects
   @subject = Subject.find(params[:id])
end

最后你的book_controller.rb文件将如下所示 -

class BooksController < ApplicationController

   def list
      @books = Book.all
   end

   def show
      @book = Book.find(params[:id])
   end
  
   def new
      @book = Book.new
      @subjects = Subject.all
   end

   def book_params
      params.require(:books).permit(:title, :price, :subject_id, :description)
   end

   def create
      @book = Book.new(book_params)

      if @book.save
         redirect_to :action => 'list'
      else
         @subjects = Subject.all
         render :action => 'new'
      end
   end
   
   def edit
      @book = Book.find(params[:id])
      @subjects = Subject.all
   end
   
   def book_param
      params.require(:book).permit(:title, :price, :subject_id, :description)
   end
   
   def update
      @book = Book.find(params[:id])
      
      if @book.update_attributes(book_param)
         redirect_to :action => 'show', :id => @book
      else
         @subjects = Subject.all
         render :action => 'edit'
      end
   end
   
   def delete
      Book.find(params[:id]).destroy
      redirect_to :action => 'list'
   end
   
   def show_subjects
      @subject = Subject.find(params[:id])
   end

end

现在保存您的控制器文件。

下一步是什么？

您已经创建了几乎所有可在后端运行的方法。接下来我们将为操作定义路由（URL）。

Ruby on Rails - 路线

路由模块提供原生 Ruby 中的 URL 重写。这是一种将传入请求重定向到控制器和操作的方法。它取代了 mod_rewrite 规则。最重要的是，Rails 的路由适用于任何 Web 服务器。路由在 app/config/routes.rb 中定义。

将创建路线视为根据您的请求绘制地图。地图根据一些预定义的模式告诉他们要去哪里 -

Rails.application.routes.draw do
   Pattern 1 tells some request to go to one place
   Pattern 2 tell them to go to another
   ...
end

例子

让我们考虑我们的图书馆管理应用程序包含一个名为 BookController 的控制器。我们必须为那些在 BookController 类中定义为方法的操作定义路由。

打开library/config/目录中的routes.rb文件并使用以下内容进行编辑。

Rails.application.routes.draw do
   get 'book/list'
   get 'book/new'
   post 'book/create'
   patch 'book/update'
   get 'book/list'
   get 'book/show'
   get 'book/edit'
   get 'book/delete'
   get 'book/update'
   get 'book/show_subjects'
end

routes.rb 文件定义应用程序中可用的操作以及操作类型，例如 get、post 和 patch。

使用以下命令列出所有定义的路由，这对于跟踪应用程序中的路由问题很有用，或者让您很好地了解您想要熟悉的应用程序中的 URL。

library> rake routes

下一步是什么？

接下来，我们将创建代码来生成屏幕以显示数据并接受用户输入。

Ruby on Rails - 视图

Rails View 是一个 ERb 程序，它通过可相互访问的变量与控制器共享数据。

如果您查看库应用程序的 app/views 目录，您将看到我们创建的每个控制器都有一个子目录：book。当使用生成脚本创建同名控制器时，每个子目录都会自动创建。

Rails 让您知道您需要为每个新方法创建视图文件。您在控制器中定义的每个方法都需要有一个相应的erb文件，其名称与该方法相同，以显示该方法正在收集的数据。

因此，让我们为 book_controller.rb 中定义的所有方法创建视图文件。在执行这些视图时，同时检查这些操作是否适用于数据库。

为列表方法创建视图文件

使用您喜欢的文本编辑器创建一个名为list.html.erb的文件，并将其保存到 app/views/book 中。创建并保存文件后，刷新您的网络浏览器。您应该看到一个空白页；如果不这样做，请检查文件的拼写并确保它与控制器的方法完全相同。

现在，显示实际内容。让我们将以下代码放入list.html.erb中。

<% if @books.blank? %>
<p>There are not any books currently in the system.</p>
<% else %>
<p>These are the current books in our system</p>

<ul id = "books">
   <% @books.each do |c| %>
   <li><%= link_to c.title, {:action => 'show', :id => c.id} -%></li>
   <% end %>
</ul>

<% end %>
<p><%= link_to "Add new Book", {:action => 'new' }%></p>

要执行的代码是检查@books数组中是否有任何对象。.空白？如果数组为空，则方法返回 true；如果数组包含任何对象，则返回 false。这个 @books 对象是在控制器的 list 方法中创建的。

<%= %> 标记之间的代码是link_to方法调用。link_to 的第一个参数是要在 <a> 标记之间显示的文本。第二个参数是单击链接时调用的操作。在本例中，它是 show 方法。最后一个参数是通过 params 对象传递的书籍的 id。

现在，尝试刷新您的浏览器，您应该会看到以下屏幕，因为我们的图书馆中没有任何书籍。

为新方法创建视图文件

到目前为止，我们的图书馆还没有任何书。我们必须在系统中创建几本书。因此，让我们设计一个与 book_controller.rb 中定义的新方法相对应的视图。

使用您喜欢的文本编辑器创建一个名为 new.html.erb 的文件，并将其保存到 app/views/book 中。将以下代码添加到 new.html.erb 文件中。

<h1>Add new book</h1>

<%= form_tag :action => 'create' do %>
<p><label for = "book_title">Title</label>:

<%= text_field 'books', 'title' %></p>
<p><label for = "book_price">Price</label>:

<%= text_field 'books', 'price' %></p>
<p><label for = "book_subject_id">Subject</label>:

<%= collection_select(:books, :subject_id, @subjects, :id, :name, prompt: true) %></p>
<p><label for = "book_description">Description</label><br/>

<%= text_area 'books', 'description' %></p>
<%= submit_tag "Create" %>

<% end -%>
<%= link_to 'Back', {:action => 'list'} %>

这里form_tag方法使用提供给它的所有信息将 Ruby 代码解释为常规 HTML <form> 标记。例如，此标签输出以下 HTML -

<form action = "/book/create" method = "post