Ruby on Rails - 快速指南

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 线程在 VM 中模拟，而不是作为本机 OS 线程运行。

示例 Ruby 代码

以下是用于打印"Hello Ruby"的示例 Ruby 代码

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

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

# 创建新对象
h = Hello.new("Ruby")

# 输出 "Hello Ruby!"
h.salute

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

Hello Ruby!

Embedded 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 的优势

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

元编程

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

Active Record

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

约定优于配置

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

脚手架

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

内置测试

Rails 创建简单的自动化测试，然后您可以对其进行扩展。 Rails 还提供支持代码(称为 harnesses 和 fixtures)，使测试用例的编写和运行更加容易。然后，Ruby 可以使用 rake 实用程序执行所有自动化测试。

三种环境

Rails 为您提供了三种默认环境:开发、测试和生产。每种环境的行为略有不同，可让您的整个软件开发周期更加轻松。例如，Rails 会为每次测试运行创建一份全新的测试数据库副本。

Ruby on Rails - 安装

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

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

我们假设您已经在计算机上安装了 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

如果未安装 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

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

现在打开您的浏览器并输入以下 −

http://localhost:3000

它应该显示一条消息，例如"欢迎加入"或"祝贺"。

Ruby on Rails - 框架

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

当您着手编写 Rails 应用程序时，除了配置和其他日常工作之外，您必须执行三个主要任务 −

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

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

Ruby on Rails MVC 框架

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

模型 (ActiveRecord )

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

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

视图 ( ActionView )

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

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

控制器 ( 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
uby\gems\2.2.0\gems
ruby\lib
uby\gems\2.2.0\gems\>dir

您将看到包括(但不限于)以下内容的子目录 −

ActionView 和 ActionController 捆绑在一起ActionPack。

ActiveRecord 提供了一系列编程技术和快捷方式，用于处理来自 SQL 数据库的数据。ActionController 和 ActionView 提供了处理和显示该数据的工具。Rails 将它们全部结合在一起。

Ruby on Rails - 目录结构

当您使用 Rails 帮助脚本创建应用程序时，它会为应用程序创建整个目录结构。Rails 知道在此结构中查找所需内容的位置，因此您无需提供任何输入。

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

要了解此目录结构，让我们使用在"安装"一章中创建的 demo 应用程序。可以使用简单的帮助命令 rails demo 创建它。

现在，按如下方式进入演示应用程序根目录 −

tp> cd demo
demo> dir

您将在 Windows 中找到以下目录结构 −

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

app − 它组织您的应用程序组件。它有子目录，包含视图(视图和帮助程序)、控制器(控制器)和后端业务逻辑(模型)。
app/controllers − Rails 会在 controllers 子目录中查找控制器类。控制器处理来自用户的 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)。您还可以使用在环境目录中找到的文件定制三个 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 文件 (public)。
script − 此目录包含用于启动和管理您将与 Rails 一起使用的各种工具的脚本。例如，有用于生成代码 (generate) 和启动 Web 服务器 (server) 的脚本。
test − 您编写的测试和 Rails 为您创建的测试都在这里。您将看到模拟 (mocks)、单元测试 (unit)、装置 (fixtures) 和功能测试 (function) 的子目录。
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 应用程序时所做的许多事情。在此步骤中，我们将使用一个这样的辅助脚本来创建整个目录结构和初始文件集，以启动我们的 Library System 应用程序。

进入 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
uby\library\> Rails server

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

这将启动您的 WEBrick 网络服务器。

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

下一步是什么?

下一章将介绍如何为您的应用程序创建数据库，以及访问这些创建的数据库所需的配置是什么。

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

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 Migrations 管理这些表。

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 即可。实际上，您必须遵循某些规则 −

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

创建 Active Record 文件(模型)

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

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

上面的 rails generate model book 命令生成如下的自动代码 −

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

使用生成工具时，Rails 会创建实际的模型文件，其中包含模型特有的所有方法和您定义的业务规则、用于执行测试驱动开发的单元测试文件、用于单元测试的示例数据文件(称为 Fixtures)以及可轻松创建数据库表和列的 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 模型中定义的，因此在同一位置定义有效数据的含义才有意义。

验证是 −

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

Ruby on Rails - 迁移

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

这有很多用途，包括 −

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

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 − 用于存储真值或假值。

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

limit ( :limit => “50” )
default (:default => “blah” )
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 和 subject。

Books 迁移应如下所示 −

tp> cd library
library> rails generate migration books

上述命令生成以下代码。

subject 迁移应如下所示 −

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 表，并将在 subject 表中创建五条记录。

运行迁移

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

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"而不是 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，它是 controllers 文件夹中的另一个文件: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 可以找到特定的书籍。

实现新方法

新方法让 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 中的所有字段。数据从新方法传递到使用 params 对象创建的方法。

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

然后，如果数据保存失败，则需要 @subjects = Subject.all，并且它与使用新选项的情况类似。

实现 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 程序，它通过可相互访问的变量与控制器共享数据。

如果您查看库应用程序的 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 数组中是否有任何对象。如果数组为空，.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，创建一个从数组构建的 HTML 选择菜单，例如 @books 菜单。有五个参数，如下所示 −

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

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

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

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

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

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

如果单击链接，您应该会看到另一个"缺少模板"错误，因为您尚未为 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。在本例中，您可以使用 belongs_to 关联通过 @book 变量提取主题的名称值。如果单击任何列出的记录，它将显示以下屏幕。

为 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>

现在，尝试使用 http://localhost: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 确认框，询问您是否确实要执行该操作。如果用户单击"确定"，则操作将继续，并删除该项目。

现在，尝试使用 http://localhost: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 的"主题:"行，以便主题列表显示链接。

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

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

下一步是什么?

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

下一章将介绍如何使用 Layouts 以更好的方式放置数据。我们将向您展示如何在 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 Scaffolding 开发应用程序，让用户能够添加、删除和修改任何数据库中的记录。

Ruby on Rails - 脚手架

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

脚手架提供的不仅仅是廉价的演示刺激。以下是一些好处 −

您可以快速将代码呈现给用户以获得反馈。
更快的成功会激励您。
您可以通过查看生成的代码来了解 Rails 的工作原理。
您可以使用脚手架作为基础来快速启动开发。

脚手架示例

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

创建一个空的 Rails Web 应用程序

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

tp> rails new cookbook

设置数据库

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

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

mysql> grant all permission on cookbook.*
to 'root'@'localhost' established by 'password';
Query OK, 0 rows impacted (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows impacted (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
   
   # 使用回调来共享操作之间的常见设置或约束。
   def set_recipe
      @recipe = Recipe.find(params[:id])
   end
   
   # 永远不要相信来自可怕的互联网的参数，只允许白名单通过。
   def recipe_params
      params.require(:recipe).permit(:tittle, :instructions)
   end
end

当 Rails 应用程序的用户选择一项操作(例如"Show")时，控制器将执行相应部分中的任何代码 - "def show"，然后默认呈现同名模板 - "show.html.erb"。此默认行为可以被覆盖。

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

这一行代码将使数据库表变得生动。它将为您的数据提供一个简单的界面，以及−

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

在创建或编辑条目时，scaffold 将为您完成所有繁重的工作，例如表单生成和处理，甚至提供巧妙的表单生成，支持以下类型的输入−

简单文本字符串
文本区域(或大块文本)
日期选择器
日期时间选择器

您可以使用 Rails Migrations 来创建和维护表格。

rake db:migrate RAILS_ENV=development

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

cookbook> rails server

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

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

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

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

增强模型

Rails 为您提供了大量的免费错误处理。为了理解这一点，请向空的配方模型添加一些验证规则 −

按如下方式修改 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 代表 Asynchronous 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 示例

此示例基于 scaffold 工作，Destroy 概念基于 ajax 工作。

在此示例中，我们将在小马表上提供、列出、显示和创建操作。如果您不了解脚手架技术，那么我们建议您先阅读前面的章节，然后继续使用 AJAX on Rails。

创建应用程序

让我们从创建应用程序开始它将按如下方式完成 −

rails new ponies

上面的命令创建了一个应用程序，现在我们需要使用 cd 命令调用应用程序目录。它将进入应用程序目录，然后我们需要调用脚手架命令。它将按如下方式完成 −

rails generate scaffold Pony name:string profession:string

上述命令生成了带有姓名和职业列的脚手架。我们需要按照以下命令迁移数据库

rake db:migrate

现在按照以下命令运行 Rails 应用程序

rails s

现在打开 Web 浏览器并调用 http://localhost:3000/ponies/new 这样的 URL，输出将如下所示

创建 Ajax

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

创建一个文件 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

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

现在运行一个应用程序，从 http://localhost:3000/ponies/new 调用输出，它将看起来像下图一样

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

现在点击返回按钮，它将显示所有小马创建的信息，如下图所示

到目前为止，我们正在使用脚手架，现在单击"destroy"按钮，它将调用一个弹出窗口，如下图所示，该弹出窗口基于 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

现在打开简历模型并调用上传器，如下所示。简历模型已放置在 app/models/resume.rb −

class Resume < ActiveRecord::Base
    mount_uploader :attachment, AttachmentUploader # 告诉 rails 将此上传器用于此模型。
    validates :name, presence: true # 确保所有者的姓名存在。
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>

现在启动服务器并访问 http://localhost: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

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

有关 File 对象的完整详细信息，您需要阅读 Ruby 参考手册。

Ruby on Rails - 发送电子邮件

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

tp> rails new mailtest

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

Action Mailer - 配置

在继续实际工作之前，您必须遵循以下步骤完成配置 −

转到电子邮件项目的配置文件夹并打开 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) 服务器的适当设置替换每个哈希值。如果您还不知道，可以从 Internet 服务提供商处获取此信息。如果您使用的是标准 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

默认哈希 − 这是您从此邮件程序发送的任何电子邮件的默认值哈希。在本例中，我们将 :from 标头设置为此类中所有消息的值。这可以根据每封电子邮件进行覆盖
邮件 − 实际的电子邮件消息，我们将 :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!

调用邮件程序

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

$ 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 on Rails - 快速指南

Ruby on Rails - 简介

什么是 Ruby?

为什么是 Ruby?

示例 Ruby 代码

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

实现新方法

实现 create 方法

实现 edit 方法

实现 update 方法

实现 delete 方法

显示主题的其他方法

下一步是什么?

Ruby on Rails - 路由

示例

下一步是什么?

Ruby on Rails - 视图