Ruby on Rails 快速指南

什么是 Ruby？

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

Ruby 是以下内容的成功结合：

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

Ruby 是：

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

为什么选择 Ruby？

Ruby 起源于日本，现在在美国和欧洲也越来越受欢迎。以下因素促成了它的流行：

易于学习
开源（非常宽松的许可证）
丰富的库
非常容易扩展
真正的面向对象
代码量少，错误更少
乐于助人的社区

尽管我们有很多理由使用 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

Ruby 提供了一个名为 ERB（嵌入式 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 的优势

Rails 充满了使您更高效的功能，其中许多功能建立在彼此之上。

元编程

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

Active Record

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

约定优于配置

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

脚手架

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

内置测试

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

三个环境

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

Ruby on Rails - 安装

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

Ruby
Rails 框架
Web 服务器
数据库系统

我们假设您已经在计算机上安装了 Web 服务器和数据库系统。您可以使用 WEBrick Web 服务器，它随 Ruby 一起提供。但是，大多数网站在生产环境中使用 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

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

步骤 3：安装 Rails

安装 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

步骤 3：安装 Ruby

在安装 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的关键字来安装支持的依赖项；我们称之为gems。如果您不想安装 Ruby-gems 的文档，请使用以下命令。

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

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

tp> gem install bundler

步骤 4：安装 Rails

使用以下命令安装 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

恭喜！您现在在 Linux 上使用 Rails 了。

步骤 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

输出

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

tp> cd demo
tp> rails server

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

现在打开您的浏览器并键入以下内容：

https://:3000

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

Ruby on Rails - 框架

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

当你着手编写 Rails 应用程序时，撇开配置和其他日常事务，你需要执行三个主要任务 -

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

基于以上三个任务，Ruby on Rails 处理 Model/View/Controller (MVC) 框架。

Ruby on Rails MVC 框架

Model View Controller 原则将应用程序的工作划分为三个独立但紧密协作的子系统。

模型 (ActiveRecord)

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

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

视图 (ActionView)

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

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

控制器 (ActionController)

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

此子系统在 ActionController 中实现，它是一个数据代理，位于 ActiveRecord（数据库接口）和 ActionView（呈现引擎）之间。

MVC 框架的图形表示

以下是 Ruby on Rails 框架的图形表示 -

MVC 框架的目录表示

假设在 Linux 上进行标准默认安装，你可以在以下位置找到它们 -

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

你会看到包括（但不限于）以下子目录 -

actionpack-x.y.z
activerecord-x.y.z
rails-x.y.z

在 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 项目之间快速移动，而无需重新学习项目的组织方式。

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

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

tp> cd demo
demo> dir

你会在 Windows 中找到如下目录结构 -

现在让我们解释每个目录的目的

app - 它组织你的应用程序组件。它包含用于保存视图（视图和帮助器）、控制器（控制器）和后端业务逻辑（模型）的子目录。
app/controllers - controllers 子目录是 Rails 查找控制器类的地方。控制器处理来自用户的 Web 请求。
app/helpers - helpers 子目录保存任何用于辅助模型、视图和控制器类的帮助器类。这有助于使模型、视图和控制器代码保持简洁、专注和整洁。
app/models - models 子目录保存对应用程序数据库中存储的数据进行建模和封装的类。在大多数框架中，应用程序的这一部分可能会变得非常杂乱、乏味、冗长且容易出错。Rails 使其变得非常简单！
app/view - views 子目录保存显示模板，以便使用应用程序中的数据填充、转换为 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）。你还可以使用 environments 目录中找到的文件，为测试、开发和部署的三个 Rails 环境定制行为。
db - 通常，你的 Rails 应用程序将拥有访问关系数据库表的模型对象。你可以使用你创建并放置在此目录中的脚本管理关系数据库。
doc - Ruby 具有一个名为 RubyDoc 的框架，可以自动为你创建的代码生成文档。你可以通过代码中的注释来辅助 RubyDoc。此目录保存所有 RubyDoc 生成的 Rails 和应用程序文档。
lib - 你会将库放在这里，除非它们明确地属于其他地方（例如供应商库）。
log - 错误日志放在这里。Rails 创建了帮助你管理各种错误日志的脚本。你会找到服务器的单独日志（server.log）和每个 Rails 环境的日志（development.log、test.log 和 production.log）。
public - 与 Web 服务器的 public 目录类似，此目录包含不会更改的 Web 文件，例如 JavaScript 文件（public/javascripts）、图形（public/images）、样式表（public/stylesheets）和 HTML 文件（public）。
script - 此目录保存用于启动和管理你将与 Rails 一起使用的各种工具的脚本。例如，有一些脚本可以生成代码（generate）和启动 Web 服务器（server）。
test - 你编写的测试和 Rails 为你创建的测试都放在这里。你会看到用于模拟（mocks）、单元测试（unit）、夹具（fixtures）和功能测试（functional）的子目录。
tmp - Rails 使用此目录来保存用于中间处理的临时文件。
vendor - 由第三方供应商提供的库（例如安全库或超出基本 Rails 发行版的数据库实用程序）放在这里。

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

README - 此文件包含有关 Rail 应用程序的基本详细信息以及上面解释的目录结构的描述。
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 目录结构以获取更多详细信息。

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

controllers子目录是 Rails 查找控制器类的地方。控制器处理来自用户的 Web 请求。
views子目录保存显示模板，以便使用应用程序中的数据填充、转换为 HTML 并返回到用户的浏览器。
models子目录保存对应用程序数据库中存储的数据进行建模和封装的类。在大多数框架中，应用程序的这一部分可能会变得非常杂乱、乏味、冗长且容易出错。Rails 使其变得非常简单。
helpers 子目录包含任何用于辅助模型、视图和控制器类的帮助器类。这有助于使模型、视图和控制器代码保持简洁、重点突出且井井有条。

启动 Web 服务器

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 迁移以及如何使用它来维护数据库表。

Ruby on Rails - 数据库设置

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

library_development
library_production
library_test

您应该初始化所有三个数据库，并为它们创建一个具有完全读写权限的用户和密码。我们正在使用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执行相同的操作。

配置 database.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。

配置 database.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 - Active Records

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

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

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

每个 Active Record 对象都有用于数据库访问的 CRUD（Create、Read、Update 和Delete）方法。此策略允许在数据库表和应用程序对象之间进行简单设计和直接映射。

将领域模型转换为 SQL

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

每个实体（如书籍）在数据库中都有一个以其命名但使用复数形式的表（books）。
每个这样的实体匹配表都有一个名为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 generate model book命令生成如下自动代码 -

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

当您使用 generate 工具时，Rails 会创建包含模型特有的所有方法以及您定义的业务规则的实际模型文件、用于执行测试驱动开发的单元测试文件、用于与单元测试一起使用的示例数据文件（称为 fixture）以及使创建数据库表和列变得容易的 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

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

class Subject < ActiveRecord::Base
   has_many :books
end

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

在模型上实现验证

验证的实现是在 Rails 模型中完成的。您输入数据库的数据在实际的 Rails 模型中定义，因此在同一位置定义有效数据意味着什么才是合乎逻辑的。

验证为 -

title 字段的值不能为 NULL。
price 字段的值应为数字。

在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 迁移允许您使用 Ruby 定义对数据库模式的更改，从而可以使用版本控制系统使内容与实际代码保持同步。

这有许多用途，包括 -

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

Rails 迁移可以做什么？

create_table(name, options)
drop_table(name)
rename_table(old_name, new_name)
add_column(table_name, column_name, type, options)
rename_column(table_name, column_name, new_column_name)
change_column(table_name, column_name, type, options)
remove_column(table_name, column_name)
add_index(table_name, column_name, index_type)
remove_index(table_name, column_name)

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

string - 用于标题等小型数据类型。
text - 用于较长的文本数据，例如描述。
integer - 用于整数。
float - 用于小数。
datetime 和 timestamp - 将日期和时间存储到列中。
date 和 time - 只存储日期或时间。
binary - 用于存储图像、音频或电影等数据。
Boolean - 用于存储 true 或 false 值。

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

limit ( :limit => “50” )
default (:default => “blah” )
null (:null => false 表示NOT NULL)

注意 - Rails 迁移执行的操作可以使用任何前端 GUI 或直接在 SQL 提示符下执行，但 Rails 迁移使所有这些操作都非常容易。

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

创建迁移

以下是创建迁移的通用语法 -

application_dir> rails generate migration table_name

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

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

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

Books 迁移应如下所示 -

tp> cd library
library> rails generate migration books

以上命令生成以下代码。

主题迁移应如下所示 -

tp> cd library
library> rails generate migration subjects

以上命令生成以下代码。

请注意，在创建迁移时，您使用的是小写的 book 和 subject 以及复数形式。这是一个 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

上述脚本将用于创建subjects表，并在 subjects 表中创建五条记录。

运行迁移

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

library> rake db:migrate

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

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

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

如果您想指定要用于迁移的 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”代替export命令。

接下来是什么？

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

创建控制器（Action Controller）。
创建视图（Action View）。

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 方法

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 可以找到特定的书籍。

实现 new 方法

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

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

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

实现 create 方法

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

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收集所有字段。数据是从 new 方法通过 params 对象传递给 create 的。

下一行是一个条件语句，如果对象成功保存到数据库，则将用户重定向到list方法。如果未保存，则用户将被送回 new 方法。redirect_to 方法类似于在网页上执行元刷新：它会在没有任何用户交互的情况下自动将您转发到您的目标。

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

实现 edit 方法

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

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

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

实现 update 方法

此方法将在 edit 方法之后调用，当用户修改数据并希望将更改更新到数据库中时。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行是必需的，以防它没有成功保存数据，那么它就类似于 edit 选项。

实现 delete 方法

如果要从数据库中删除记录，则可以使用此方法。请按如下方式实现此方法。

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

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

显示主题的其他方法

假设您想为用户提供根据给定主题浏览所有书籍的功能。因此，您可以在 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 视图是一个 ERb 程序，它通过相互可访问的变量与控制器共享数据。

如果您查看 library 应用程序的 app/views 目录，您将看到我们创建的每个控制器的子目录：book。这些子目录中的每一个都是在使用 generate 脚本创建同名控制器时自动创建的。

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

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

为 list 方法创建视图文件

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

现在，显示实际内容。让我们将以下代码放入 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 数组中是否有任何对象。如果数组为空，.blank?方法返回 true，如果数组包含任何对象，则返回 false。此 @books 对象是在控制器中的 list 方法内部创建的。

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

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

为新方法创建视图文件

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

使用您喜欢的文本编辑器创建一个名为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">

下一个方法是text_field，它输出一个<input>文本字段。text_field的参数是对象和字段名称。在本例中，对象是book，名称是title。

Rails方法称为collection_select，它根据数组（例如@books）创建一个HTML选择菜单。有五个参数，如下所示 -

:book - 您正在操作的对象。在本例中，它是一个book对象。
:subject_id - 保存书籍时填充的字段。
@books - 您正在使用的数组。
:id - 存储在数据库中的值。在HTML方面，这是<option>标签的value参数。
:name - 用户在下拉菜单中看到的输出。这是<option>标签之间的值。

接下来使用的是submit_tag，它输出一个<input>按钮，用于提交表单。最后，有一个end方法，它简单地转换为</form>。

转到您的浏览器并访问https://:3000/book/new。这将为您提供以下屏幕。

在此表单中输入一些数据，然后单击创建按钮。在这里，我在字段中添加了以下详细信息 -

Title: Advance Physics
Price: 390
Subject: Physics
Description: This is test to create new book

当您单击创建按钮时，它将调用create方法，该方法不需要任何视图，因为此方法使用list或new方法查看结果。因此，当您单击创建按钮时，数据应成功提交并重定向到列表页面，其中您现在有一个列出的项目，如下所示 -

如果您单击链接，您应该会看到另一个模板丢失错误，因为您尚未为show方法创建模板文件。

为show方法创建视图文件

此方法将显示库中任何书籍的完整详细信息。在app/views/book下创建一个show.html.erb文件，并使用以下代码填充它 -

<h1><%= @book.title %></h1>

<p>
   <strong>Price: </strong> $<%= @book.price %><br />
   <strong>Subject :</strong> <%= @book.subject.name %><br />
   <strong>Created Date:</strong> <%= @book.created_at %><br />
</p>

<p><%= @book.description %></p>

<hr />

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

这是您第一次充分利用关联，它使您能够轻松地从相关对象中提取数据。

使用的格式是@variable.relatedObject.column。在本例中，您可以通过@book变量使用belongs_to关联来提取主题的名称值。如果单击任何列出的记录，它将显示以下屏幕。

为edit方法创建视图文件

创建一个名为edit.html.erb的新文件，并将其保存到app/views/book。使用以下代码填充它 -

<h1>Edit Book Detail</h1>

<%= form_for @book, :url =>{:action => "update", :id =>@book} do |f| %>

<p>Title: <%= f.text_field 'title' %></p>
<p>Price: <%= f.text_field  'price' %></p>
<p>Subject: <%= f.collection_select :subject_id, Subject.all, :id, :name %></p>
<p>Description<br/>

<%= f.text_area 'description' %></p>
<%= f.submit "Save changes" %>
<% end %>

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

此代码与new方法非常相似，只是要更新操作而不是创建并定义ID。

在这种情况下，我们对表单操作使用了form_for标签。它的性能将优于form_tag。为什么呢？因为它可以轻松地与模型交互。因此，当您需要模型和表单字段之间的交互时，最好使用form_for标签。

此时，我们需要修改list方法的视图文件。转到<li></li>元素并将其修改为如下所示 -

<li>
   <%= link_to c.title, {:action => "show", :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => "edit",
   :id => c.id} %></b>
</li>

现在，尝试使用https://:3000/book/list浏览书籍。它将为您提供所有书籍的列表以及编辑选项。当您单击编辑选项时，您将看到下一个屏幕，如下所示 -

现在，编辑此信息，然后单击保存更改按钮。这将导致调用控制器文件中可用的update方法，它将更新所有更改的属性。请注意，update方法不需要任何视图文件，因为它使用show或edit方法显示其结果。

为delete方法创建视图文件

使用Ruby on Rails从数据库中删除信息几乎太容易了。您不需要为delete方法编写任何视图代码，因为此方法使用list方法显示结果。因此，让我们再次修改list.html.erb并添加一个删除链接。

转到<li></li>元素并将其修改为如下所示 -

<li>
   <%= link_to c.title, {:action => 'show', :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => 'edit', :id => c.id} %></b>
   <b> <%= link_to "Delete", {:action => 'delete', :id => c.id},
   :confirm => "Are you sure you want to delete this item?" %></b>
</li>

:confirm参数会显示一个JavaScript确认框，询问您是否真的要执行此操作。如果用户单击“确定”，则操作继续，并且项目被删除。

现在，尝试使用https://:3000/book/list浏览书籍。它将为您提供所有书籍的列表以及编辑和删除选项，如下所示 -

现在，使用删除选项，您可以删除任何列出的记录。

为show_subjects方法创建视图文件

在app/views/book目录中创建一个新文件show_subjects.html.erb，并将以下代码添加到其中 -

<h1><%= @subject.name -%></h1>

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

您正在利用关联通过单个主题的许多书籍列表进行迭代。

现在修改show.html.erb的Subject:行，以便主题列表显示一个链接。

<strong>Subject: </strong> <%= link_to @book.subject.name,
:action => "show_subjects", :id => @book.subject.id %><br />

这将在索引页面上输出主题列表，以便用户可以直接访问它们。

修改list.html.erb以将以下内容添加到文件的顶部 -

<ul id = "subjects">
   <% Subject.find(:all).each do |c| %>
   <li><%= link_to c.name, :action => "show_subjects", :id => c.id %></li>
   <% end %>
</ul>

现在尝试使用https://:3000/book/list浏览书籍。它将显示所有主题及其链接，以便您可以浏览与该主题相关的所有书籍。

接下来是什么？

希望您现在对Rails的所有操作都感到满意。

下一章将解释如何使用布局以更好的方式呈现您的数据。我们将向您展示如何在Rails应用程序中使用CSS。

Ruby on Rails - 布局

布局定义了HTML页面的周围环境。它是定义最终输出的通用外观和感觉的地方。布局文件位于app/views/layouts中。

此过程涉及定义布局模板，然后让控制器知道它存在并使用它。首先，让我们创建模板。

将一个名为standard.html.erb的新文件添加到app/views/layouts。您通过文件名让控制器知道要使用哪个模板，因此建议遵循相同的命名方案。

将以下代码添加到新的standard.html.erb文件并保存您的更改 -

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">

   <head>
      <meta http-equiv = "Content-Type" content = "text/html; charset = iso-8859-1" />
      <meta http-equiv = "Content-Language" content = "en-us" />
      <title>Library Info System</title>
      <%= stylesheet_link_tag "style" %>
   </head>

   <body id = "library">
      <div id = "container">
         
         <div id = "header">
            <h1>Library Info System</h1>
            <h3>Library powered by Ruby on Rails</h3>
         </div>

         <div id = "content">
            <%= yield -%>
         </div>

         <div id = "sidebar"></div>
         
      </div>
   </body>
   
</html>

您刚刚添加的所有内容都是标准的HTML元素，除了两行。stylesheet_link_tag辅助方法输出一个样式表<link>。在本例中，我们链接了style.css样式表。yield命令让Rails知道它应该放置此处调用的方法的html.erb。

现在打开book_controller.rb并在第一行下方添加以下行 -

class BookController < ApplicationController
layout 'standard'
def list
@books = Book.all
end
...................

它指示控制器我们想要使用standard.html.erb文件中可用的布局。现在尝试浏览书籍，这将产生以下屏幕。

添加样式表

到目前为止，我们还没有创建任何样式表，因此Rails正在使用默认样式表。现在让我们创建一个名为style.css的新文件，并将其保存到/public/stylesheets。将以下代码添加到此文件。

body {
   font-family: Helvetica, Geneva, Arial, sans-serif;
   font-size: small;
   font-color: #000;
   background-color: #fff;
}

a:link, a:active, a:visited {
   color: #CD0000;
}

input { 
   margin-bottom: 5px;
}

p { 
   line-height: 150%;
}

div#container {
   width: 760px;
   margin: 0 auto;
}

div#header {
   text-align: center;
   padding-bottom: 15px;
}

div#content {
   float: left;
   width: 450px;
   padding: 10px;
}

div#content h3 {
   margin-top: 15px;
}

ul#books {
   list-style-type: none;
}

ul#books li {
   line-height: 140%;
}

div#sidebar {
   width: 200px;
   margin-left: 480px;
}

ul#subjects {
   width: 700px;
   text-align: center;
   padding: 5px;
   background-color: #ececec;
   border: 1px solid #ccc;
   margin-bottom: 20px;
}

ul#subjects li {
   display: inline;
   padding-left: 5px;
}

现在刷新您的浏览器并查看差异 -

接下来是什么？

下一章将解释如何使用Rails脚手架开发应用程序，以允许用户访问数据库中任何记录的添加、删除和修改。

Ruby on Rails - 脚手架

在开发Rails应用程序时，特别是那些主要为您提供数据库中数据的简单界面的应用程序，使用脚手架方法通常很有用。

脚手架提供的不仅仅是廉价的演示快感。以下是一些好处 -

您可以快速向用户提供代码以获取反馈。
您会因更快的成功而受到激励。
您可以通过查看生成的代码来了解Rails的工作原理。
您可以使用脚手架作为基础来启动您的开发。

脚手架示例

为了理解脚手架，让我们创建一个名为cookbook的数据库和一个名为recipes的表。

创建空的 Rails Web 应用程序

打开命令窗口并导航到您要创建此cookbook Web应用程序的位置。因此，运行以下命令以创建完整的目录结构。

tp> rails new cookbook

设置数据库

以下是创建数据库的方法 -

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

mysql> grant all privileges on cookbook.*
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)

要指示Rails如何查找数据库，请编辑配置文件cookbook\config\database.yml并将数据库名称更改为cookbook。将密码留空。完成后，它应如下所示 -

development:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
production:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost

Rails允许您在开发模式、测试模式或生产模式下运行，使用不同的数据库。此应用程序对每个模式使用相同的数据库。

生成的脚手架代码

使用脚手架操作，Rails会动态生成它需要的所有代码。通过将scaffold作为脚本运行，我们可以将所有代码写入磁盘，在那里我们可以对其进行检查，然后开始根据我们的需求对其进行调整。

所以现在，让我们再次开始使用脚手架辅助脚本手动生成脚手架代码 -

cookbook> rails generate scaffold recipe

它生成如下所示的自动文件 -

控制器

让我们看看控制器背后的代码。此代码由scaffold生成器生成。如果打开app/controllers/recipes_controller.rb，您将找到如下内容 -

class RecipesController < ApplicationController
   before_action :set_recipe, only: [:show, :edit, :update, :destroy]
   
   # GET /recipes
   # GET /recipes.json
   def index
      @recipes = Recipe.all
   end
   
   # GET /recipes/1
   # GET /recipes/1.json
   def show
   end
   
   # GET /recipes/new
   def new
      @recipe = Recipe.new
   end
   
   # GET /recipes/1/edit
   def edit
   end
   
   # POST /recipes
   # POST /recipes.json
   def create
      @recipe = Recipe.new(recipe_params)
      
      respond_to do |format|
         if @recipe.save
            format.html { redirect_to @recipe, notice: 'Recipe was successfully created.' }
            format.json { render :show, status: :created, location: @recipe }
         else
            format.html { render :new }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # PATCH/PUT /recipes/1
   # PATCH/PUT /recipes/1.json
   def update
      respond_to do |format|
         if @recipe.update(recipe_params)
            format.html { redirect_to @recipe, notice: 'Recipe was successfully updated.' }
            format.json { render :show, status: :ok, location: @recipe }
         else
            format.html { render :edit }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # DELETE /recipes/1
   # DELETE /recipes/1.json
   def destroy
      @recipe.destroy
         respond_to do |format|
         format.html { redirect_to recipes_url, notice: 'Recipe was successfully destroyed.' }
         format.json { head :no_content }
      end
   end
   
   private
   
   # Use callbacks to share common setup or constraints between actions.
   def set_recipe
      @recipe = Recipe.find(params[:id])
   end
   
   # Never trust parameters from the scary internet, only allow the white list through.
   def recipe_params
      params.require(:recipe).permit(:tittle, :instructions)
   end
end

当Rails应用程序的用户选择一个操作（例如“显示”）时，控制器将执行相应部分中的任何代码 - “def show” - 然后默认情况下将呈现同名的模板 - “show.html.erb”。此默认行为可以被覆盖。

控制器使用ActiveRecord方法（如find、find_all、new、save、update_attributes和destroy）将数据移动到数据库表和数据库表之间。请注意，您不必编写任何SQL语句，rails会自动处理它。

这单行代码将使数据库表活跃起来。它将提供一个简单的界面来访问您的数据，以及以下方法 -

创建新条目
编辑当前条目
查看当前条目
销毁当前条目

在创建或编辑条目时，脚手架将为您完成所有繁重的工作，如表单生成和处理，甚至提供智能表单生成，支持以下类型的输入 -

简单的文本字符串
文本区域（或大块文本）
日期选择器
日期时间选择器

您可以使用Rails迁移创建和维护表。

rake db:migrate RAILS_ENV=development

现在，转到cookbook目录并使用以下命令运行Web服务器 -

cookbook> rails server

现在，打开浏览器并导航到http://127.0.0.1:3000/recipe/new。这将为您提供一个屏幕，用于在recipes表中创建新条目。屏幕截图如下所示 -

按下创建按钮创建新食谱后，您的记录将添加到recipes表中，并显示以下结果 -

您可以看到编辑、显示和销毁记录的选项。因此，请尝试使用这些选项。

您还可以使用URL http://127.0.0.1:3000/recipe/list列出recipes表中所有可用的食谱。

增强模型

Rails 会自动为你提供很多错误处理功能。为了理解这一点，请在空的 recipe 模型中添加一些验证规则 -

修改 app/models/recipe.rb 如下，然后测试你的应用程序 -

class Recipe < ActiveRecord::Base
   validates_length_of :title, :within => 1..20
   validates_uniqueness_of :title, :message => "already exists"
end

这些条目将提供自动检查。

validates_length_of - 字段不能为空且长度不能过长。
validates_uniqueness_of - 重复值会被捕获。这里我们给出了自定义消息，而不是默认的 Rails 错误消息。

创建脚手架的另一种方法

如上所示创建应用程序，以及生成的脚手架代码如下所示

rails g scaffold Recipe tittle:string instructions:text

以上代码使用 sqlite3 生成包含数据库的自动文件，标题和说明列如下面的图片所示。

我们需要使用以下语法迁移数据库。

$ rake db:migrate RAILS_ENV=development

最后，使用以下命令行运行应用程序 -

rails server

它将生成如上所示的输出图像的结果。

视图

所有视图和相应的控制器方法都是由scaffold命令创建的，它们位于 app/views/recipes 目录中。

脚手架有什么不同？

如果你已经阅读了前面的章节，你一定已经看到我们创建了列出、显示、删除和创建数据等方法，但脚手架会自动完成这项工作。

Ruby on Rails - AJAX

Ajax 代表异步JavaScript和XML。Ajax 不是一项单一的技术，它是一套多种技术的组合。Ajax 包含以下内容 -

用于网页标记的 XHTML
用于样式的 CSS
使用 DOM 进行动态显示和交互
使用 XML 进行数据操作和交换
使用 XMLHttpRequest 检索数据
JavaScript 作为将所有这些粘合在一起的胶水

Ajax 使你能够检索网页数据，而无需刷新整个页面的内容。在基本的 Web 架构中，用户单击链接或提交表单。表单提交到服务器，然后服务器发送回响应。然后在新的页面上向用户显示响应。

当你与支持 Ajax 的网页交互时，它会在后台加载 Ajax 引擎。该引擎是用 JavaScript 编写的，它负责与 Web 服务器通信并将结果显示给用户。当你使用支持 Ajax 的表单提交数据时，服务器会返回一个包含服务器响应的 HTML 片段，并且只显示新的或更改的数据，而不是刷新整个页面。

有关 AJAX 的完整详细信息，你可以查看我们的 AJAX 教程

Rails 如何实现 Ajax

Rails 拥有一个简单一致的模型来实现 Ajax 操作。一旦浏览器渲染并显示了初始网页，不同的用户操作会导致它显示一个新的网页（就像任何传统的 Web 应用程序一样）或触发一个 Ajax 操作 -

某些触发器触发 - 此触发器可能是用户单击按钮或链接、用户更改表单或字段中的数据，或者只是一个周期性触发器（基于计时器）。
Web 客户端调用服务器 - JavaScript 方法XMLHttpRequest将与触发器关联的数据发送到服务器上的操作处理程序。数据可能是复选框的 ID、条目字段中的文本或整个表单。
服务器执行处理 - 服务器端操作处理程序（Rails 控制器操作）对数据执行某些操作并将 HTML 片段返回给 Web 客户端。
客户端接收响应 - Rails 自动创建的客户端 JavaScript 接收 HTML 片段并使用它来更新当前页面 HTML 的指定部分，通常是<div>标签的内容。

这些步骤是在 Rails 应用程序中使用 Ajax 的最简单方法，但只需稍加努力，你就可以让服务器返回任何类型的数据以响应 Ajax 请求，并且可以在浏览器中创建自定义 JavaScript 来执行更复杂的交互。

AJAX 示例

此示例基于脚手架，删除概念基于 ajax。

在此示例中，我们将对 ponies 表执行列出、显示和创建操作。如果你不理解脚手架技术，我们建议你首先阅读前面的章节，然后再继续学习 Rails 上的 AJAX。

创建应用程序

让我们从创建应用程序开始，操作如下 -

rails new ponies

以上命令创建了一个应用程序，现在我们需要使用 cd 命令调用 app 目录。它将进入应用程序目录，然后我们需要调用 scaffold 命令。操作如下 -

rails generate scaffold Pony name:string profession:string

以上命令生成包含 name 和 profession 列的脚手架。我们需要如下命令迁移数据库

rake db:migrate

现在运行 Rails 应用程序，命令如下

rails s

现在打开 Web 浏览器并调用 url https://:3000/ponies/new，输出如下

创建 Ajax

现在使用合适的文本编辑器打开 app/views/ponies/index.html.erb。使用 :remote => true, :class => 'delete_pony' 更新你的 destroy 行。最后，它看起来如下所示。

创建一个文件 destroy.js.erb，将其放在其他 .erb 文件旁边（在 app/views/ponies 下）。它应该如下所示 -

现在在 destroy.js.erb 中输入如下所示的代码

$('.delete_pony').bind('ajax:success', function() {
   $(this).closest('tr').fadeOut();
});

现在打开你的控制器文件，该文件位于 app/controllers/ponies_controller.rb 中，并在 destroy 方法中添加如下所示的代码 -

# DELETE /ponies/1
# DELETE /ponies/1.json
def destroy
   @pony = Pony.find(params[:id])
   @pony.destroy
   
   respond_to do |format|
      format.html { redirect_to ponies_url }
      format.json { head :no_content }
      format.js   { render :layout => false }
   end
   
end

最后，控制器页面如下图所示。

现在运行应用程序，从 https://:3000/ponies/new 调用的输出，它将如下图所示

按下创建小马按钮，它将生成如下结果

现在单击后退按钮，它将显示所有创建的小马信息，如下图所示

到目前为止，我们一直在使用脚手架，现在单击删除按钮，它将调用一个弹出窗口，如下图所示，该弹出窗口基于 Ajax。

如果单击确定按钮，它将从 pony 中删除记录。这里我单击了确定按钮。最终输出如下 -

Ruby on Rails - 文件上传

你可能需要让你的网站访问者将文件上传到你的服务器上。Rails 使得处理此需求变得非常容易。现在我们将继续进行一个简单的小型 Rails 项目。

像往常一样，让我们从一个名为testfile的新 Rails 应用程序开始。让我们使用简单的 rails 命令创建应用程序的基本结构。

tp> rails new testfile

在开始应用程序开发之前，我们应该安装如下所示的 gem 文件 -

gem install carrierwave
gem install bootstrap-sass

打开你的 gemfile 并将以下两个 gem 添加到底部，如下图所示 -

在 gem 文件中添加 gem 后，我们需要在控制台中运行以下命令 -

bundle install

创建模型

我们需要创建一个包含两个字符串的模型，分别为 name 和 attachment，如下所示 -

rails g model Resume name:string attachment:string

我们需要创建数据库迁移，如下所示 -

rake db:migrate

我们需要生成控制器，如下所示 -

rails g controller Resumes index new create destroy

太好了！现在我们已经设置了基本结构。现在我们需要创建一个上传器。上传器来自 carrierwave gem，它告诉 carrierwave 如何处理文件。简而言之，它包含所有文件处理功能。运行以下命令以创建上传器

rails g uploader attachment

现在打开 resume 模型并调用上传器，如下所示。Resume 模型位于 app/models/resume.rb 中 -

class Resume < ActiveRecord::Base
   mount_uploader :attachment, AttachmentUploader # Tells rails to use this uploader for this model.
   validates :name, presence: true # Make sure the owner's name is present.
end

在处理控制器之前，我们需要修改我们的 config/routes.db，如下所示 -

CarrierWaveExample::Application.routes.draw do
   resources :resumes, only: [:index, :new, :create, :destroy]
   root "resumes#index"
end

让我们编辑控制器，如下所示。

class ResumesController < ApplicationController
   def index
      @resumes = Resume.all
   end
   
   def new
      @resume = Resume.new
   end
   
   def create
      @resume = Resume.new(resume_params)
      
      if @resume.save
         redirect_to resumes_path, notice: "The resume #{@resume.name} has been uploaded."
      else
         render "new"
      end
      
   end
   
   def destroy
      @resume = Resume.find(params[:id])
      @resume.destroy
      redirect_to resumes_path, notice:  "The resume #{@resume.name} has been deleted."
   end
   
   private
      def resume_params
      params.require(:resume).permit(:name, :attachment)
   end
   
end

让我们在 css 文件中添加 bootstrap 实现。css 文件可能在 app/assets/stylesheets/resumes.css.scss 中

@import "bootstrap";

现在打开 app/views/layouts/application.html.erb 并添加如下所示的代码 -

<!DOCTYPE html>
<html>
   
   <head>
      <title>Tutorialspoint</title>
      <%= stylesheet_link_tag "application", media: "all", "data-turbolinks-track" => true %>
      <%= javascript_include_tag "application", "data-turbolinks-track" => true %>
      <%= csrf_meta_tags %>
   </head>
   
   <body>
      <div class = "container" style = "padding-top:20px;">
         <%= yield %>
      </div>
   </body>

</html>

现在我们需要设置索引视图，如下所示 -

<% if !flash[:notice].blank? %>
   <div class = "alert alert-info">
      <%= flash[:notice] %>
   </div>
<% end %>

<br />

<%= link_to "New Resume", new_resume_path, class: "btn btn-primary" %>
<br />
<br />

<table class = "table table-bordered table-striped">
   <thead>.
      <tr>
         <th>Name</th>
         <th>Download Link</th>
         <th> </th>
      </tr>
   </thead>
   
   <tbody>
      <% @resumes.each do |resume| %>
         
         <tr>
            <td><%= resume.name %></td>
            <td><%= link_to "Download Resume", resume.attachment_url %></td>
            <td><%= button_to "Delete",  resume, method: :delete, class: "btn btn-danger", confirm: "Are you sure that you wish to delete #{resume.name}?" %></td>
         </tr>
         
      <% end %>
   </tbody>
   
</table>

现在，让我们编辑 new.html.erb 并添加我们的表单代码。

<% if !@resume.errors.empty? %>
   <div class = "alert alert-error">
      
      <ul>
         <% @resume.errors.full_messages.each do |msg| %>
            <li><%= msg %></li>
         <% end %>
      </ul>
      
   </div>
<% end %>

<div class = "well">
   <%= form_for @resume, html: { multipart: true } do |f| %>
      <%= f.label :name %>
      <%= f.text_field :name %>
      <%= f.label :attachment %>
      <%= f.file_field :attachment %>
      <%= f.submit "Save", class: "btn btn-primary" %>
   <% end %>
</div>

现在启动服务器并访问 https://:3000。它将生成类似于以下屏幕的屏幕 -

我们需要做的最后一件事是过滤允许的文件类型列表。为此，我们需要在 app/uploaders/attachment_uploader.rb 中添加如下所示的简单代码

class AttachmentUploader < CarrierWave::Uploader::Base
   storage :file
   
   def store_dir
      "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
   end
   
   def extension_white_list
      %w(pdf doc htm html docx)
   end
end

现在启动服务器并访问 https://:3000。现在输入错误的格式，它将生成错误消息，如下所示 -

有关文件对象的完整详细信息，你需要查阅Ruby 参考手册。

Ruby on Rails - 发送邮件

Action Mailer是 Rails 组件，它使应用程序能够发送和接收电子邮件。在本章中，我们将了解如何使用 Rails 发送电子邮件。让我们开始使用以下命令创建emails项目。

tp> rails new mailtest

这将创建继续所需的框架。现在，我们将从配置 ActionMailer 开始。

Action Mailer - 配置

在继续实际工作之前，您需要按照以下步骤完成配置 -

转到 emails 项目的 config 文件夹并打开 environment.rb 文件，并在该文件的底部添加以下行。

config.action_mailer.delivery_method = :smtp

它告诉 ActionMailer 你想使用 SMTP 服务器。如果使用基于 Unix 的操作系统（例如 Mac OS X 或 Linux），也可以将其设置为 :sendmail。

在 environment.rb 的底部添加以下代码行。

config.action_mailer.smtp_settings = {
   address:              'smtp.gmail.com',
   port:                 587,
   domain:               'example.com',
   user_name:            '<username>',
   password:             '<password>',
   authentication:       'plain',
   enable_starttls_auto: true  
}

将每个哈希值替换为你自己的简单邮件传输协议 (SMTP) 服务器的正确设置。如果你还不知道，可以从你的互联网服务提供商那里获取此信息。如果你使用的是标准 SMTP 服务器，则无需更改端口号 25 和身份验证类型。

你也可以更改默认的电子邮件消息格式。如果你希望以 HTML 而不是纯文本格式发送电子邮件，请在 config/environment.rb 中添加以下行 -

ActionMailer::Base.default_content_type = "text/html"

ActionMailer::Base.default_content_type 可以设置为 "text/plain"、"text/html" 和 "text/enriched"。默认值为 "text/plain"。

下一步将是创建一个邮件程序

生成邮件程序

使用以下命令生成邮件程序，如下所示 -

tp> cd emails
emails> rails generate mailer Usermailer

这将在 app\mailer 目录中创建一个文件 user_mailer.rb。检查此文件的内容，如下所示 -

class Emailer < ActionMailer::Base
end

让我们创建一个方法，如下所示 -

class UserMailer < ApplicationMailer
   default from: 'notifications@example.com'
   
   def welcome_email(user)
      @user = user
      @url  = 'http://www.gmail.com'
      mail(to: @user.email, subject: 'Welcome to My Awesome Site')
   end
   
end

default Hash - 这是从该邮件程序发送的任何电子邮件的默认值的哈希。在这种情况下，我们正在将 :from 标头设置为此类中所有消息的值。可以在每个电子邮件的基础上覆盖此设置
mail - 实际的电子邮件消息，我们正在传递 :to 和 :subject 标头。

在 app/views/user_mailer/ 中创建一个名为 welcome_email.html.erb 的文件。这将是用于电子邮件的模板，以 HTML 格式显示 -

<html>
   
   <head>
      <meta content = 'text/html; charset = UTF-8' http-equiv = 'Content-Type' />
   </head>
   
   <body>
      <h1>Welcome to example.com, <%= @user.name %></h1>
      
      <p>
         You have successfully signed up to example.com,your username is: 
         <%= @user.login %>.<br>
      </p>
      
      <p>
         To login to the site, just follow this link: 
         <%= @url %>.
      </p>
      
      <p>Thanks for joining and have a great day!</p>
      
   </body>
</html>

接下来，我们将为此应用程序创建一个文本部分，如下所示 -

Welcome to example.com, <%= @user.name %>
===============================================
 
You have successfully signed up to example.com,
your username is: <%= @user.login %>.
 
To login to the site, just follow this link: <%= @url %>.
 
Thanks for joining and have a great day!

调用邮件程序

首先，让我们创建一个简单的 User 脚手架

$ bin/rails generate scaffold user name email login
$ bin/rake db:migrate

Action Mailer 与 Active Job 很好地集成在一起，因此你可以在请求-响应周期之外发送电子邮件，因此用户不必等待它 -

class UsersController < ApplicationController
   # POST /users
   # POST /users.json
   def create
   @user = User.new(params[:user])
   
      respond_to do |format|
         if @user.save
            # Tell the UserMailer to send a welcome email after save
            UserMailer.welcome_email(@user).deliver_later
            
            format.html { redirect_to(@user, notice: 'User was successfully created.') }
            format.json { render json: @user, status: :created, location: @user }
         else
            format.html { render action: 'new' }
            format.json { render json: @user.errors, status: :unprocessable_entity }
         end
         
      end
      
   end
end

现在，使用 http://127.0.0.1:3000/users/new 测试你的应用程序。它显示以下屏幕，并使用此屏幕，你将能够向任何人发送消息。

这将发送您的消息，并显示文本消息“消息发送成功”，输出如下：

sent mail to kittuprasad700@gmail.com (2023.Sms)
[ActiveJob] [ActionMailler::DeliveryJob] [2cfde3c-260e-4a33-1a6ada13a9b] Date: Thu, 09 Jul 2015 11:44:05 +0530
From: notification@example.com
To: kittuprasad700@gmail.com
Message-Id: <559e112d63c57_f1031e7f23467@kiranPro.mail>
Subject: Welcome to My Awesome Site
Mime-Version: 1.0
Content-Type: multipart/alternative;
boundary="--mimepart_559e112d601c8_f1031e7f20233f5";
charset=UTF-8
Content-Transfer-Encoding:7bit

有关如何使用 Rails 发送电子邮件的更多信息，请参阅 ActionMailer。

打印页面

Ruby on Rails 快速指南

Ruby on Rails - 简介

什么是 Ruby？

为什么选择 Ruby？

Ruby 代码示例

嵌入式 Ruby

什么是 Rails？

全栈框架

约定优于配置

Rails 的优势

元编程

Active Record

约定优于配置

脚手架

内置测试

三个环境

Ruby on Rails - 安装

在 Windows 上安装 Rails

步骤 1：检查 Ruby 版本

步骤 2：安装 Ruby

步骤 3：安装 Rails

步骤 4：检查 Rails 版本

在 Linux 上安装 Rails

步骤 1：安装先决条件依赖项

步骤 2：安装 rbenv

步骤 3：安装 Ruby

步骤 4：安装 Rails

步骤 5：安装 JavaScript 运行时

步骤 6：安装数据库

保持 Rails 更新

安装验证

Ruby on Rails - 框架

Ruby on Rails MVC 框架

模型 (ActiveRecord)

视图 (ActionView)

控制器 (ActionController)

MVC 框架的图形表示

MVC 框架的目录表示

Ruby on Rails - 目录结构

Ruby on Rails - 示例

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

创建空的 Rails Web 应用程序

启动 Web 服务器

接下来是什么？

Ruby on Rails - 数据库设置

MySQL 数据库设置

配置 database.yml

PostgreSQL 数据库设置

配置 database.yml

接下来是什么？

Ruby on Rails - Active Records

将领域模型转换为 SQL

创建 Active Record 文件（模型）

在模型之间创建关联

在模型上实现验证

接下来是什么？

Ruby on Rails - 迁移

Rails 迁移可以做什么？

创建迁移

编辑代码

运行迁移

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

接下来是什么？

Ruby on Rails - 控制器

实现 list 方法

实现 show 方法

实现 new 方法

实现 create 方法

实现 edit 方法

实现 update 方法

实现 delete 方法

显示主题的其他方法

接下来是什么？

Ruby on Rails - 路由

示例

接下来是什么？

Ruby on Rails - 视图

为 list 方法创建视图文件

为新方法创建视图文件

为show方法创建视图文件