Ruby on Rails，常简称为Rails，是一个开源的Web应用框架，旨在使开发人员能在短时间内构建高效、可维护的Web应用。自2004年发布以来，Rails逐渐成为Web开发中的热门选择，其背后是一个充满创新与活力的历史。

起源与发展

Ruby on Rails的诞生可以追溯到1990年代的Ruby语言。Ruby是由日本计算机科学家松本行弘（Yukihiro Matsumoto）于1995年创建的一种面向对象的编程语言。Ruby以其简单易用的语法和灵活的设计理念受到了许多开发者的喜爱。

Rails的创建者大卫·海奈梅尔·汉森（David Heinemeier Hansson, DHH）在2003年开发了一个名为Basecamp的项目管理工具。在构建此工具时，他需要一个快速且高效的Web框架，这促使他创建了Ruby on Rails。DHH在2004年发布了Rails的第一个版本，并通过其自身的项目推广了这一框架。

开放源代码与社区

随着Rails的推出，开发者们迅速意识到它的潜力和生产力。Rails采用了“约定优于配置”（Convention over Configuration）和“干（DRY，Don’t Repeat Yourself）”的原则，使得开发速度大幅提高。这些设计理念为开发者提供了强大的工具来构建Web应用，从而吸引了越来越多的使用者。

Rails于2005年以开源形式发布，促进了更为广泛的社区参与。这一开放的模式让开发者们能够贡献代码、编写扩展和创建插件，使得Rails迅速发展与壮大。社区的力量反过来又推动了Rails的演进，定期更新和新功能不断涌现，使其保持了市场竞争力。

里程碑式的版本

Rails的发展过程中，有几个重要的版本值得一提：

• Rails 1.0（2005）: 正式发布的第一个版本，标志着Rails框架的成熟。
• Rails 2.0（2007）: 引入了多项新特性，从而改善了性能和可用性，如RESTful架构和内置的测试框架。
• Rails 3.0（2010）: 大幅度重构，整合了许多gem（Ruby库），提高了灵活性和可扩展性，成为了业界公认的标准。
• Rails 4.0（2013）: 加入了更多的安全特性，优化了性能和路由。
• Rails 5.0（2016）: 引入了Action Cable，支持实时功能，增加了API模式的支持。

每个版本的更新都为Rails注入了新的生命力，使其能够适应不断变化的技术需求和开发者的期望。

成功案例

Rails的广泛应用在许多知名项目中得到了体现，例如：

• GitHub: 世界上最大的代码托管平台，使用Rails构建。
• Twitter: 最初版本是基于Rails的，虽然之后进行了重写，但Rails在早期帮助其快速成长。
• Basecamp: 自Rails诞生以来的原始项目，展现了其创建时的愿景。

这些案例展现了Rails的强大和灵活性，使其成为许多初创公司和大企业的首选框架。

总结

Ruby on Rails的历史彰显了一个开源项目如何在社区的推动下成长壮大，并成为现代Web开发的支柱之一。其独特的设计理念和强大的功能，使得开发者能够快速构建高质量的Web应用。在接下来的篇章中，我们将深入探讨Ruby语言本身，了解它为何是Rails的基石。

在学习Ruby on Rails之前，了解其基础——Ruby语言—是极其重要的。Ruby是一种动态、通用的编程语言，以其简洁的语法和强大的功能而闻名。正是Ruby的特性使得Rails框架得以快速开发和构建高效的Web应用。

Ruby语言概述

Ruby由松本行弘（Yukihiro Matsumoto）于1995年发布。松本的理念是创建一种既能支持快速开发，又能给予程序员灵活性的语言。Ruby的设计目标是为了让编程更加愉快，并且加速开发过程。

核心特性

1. 简洁的语法: Ruby的语法设计得非常直观，使用类和方法的方式来组织代码，使得新手能够容易上手。正如下面的代码所示：

   1 2 3 4 5

   def greet(name) "Hello, #{name}!" end puts greet("World") # 输出 "Hello, World!"

   在这个例子中，我们定义了一个方法greet，并利用字符串插值产生友好的输出信息。

2. 动态类型: Ruby是一种动态类型语言，这意味着你不需要显式声明变量的类型。这种特性在快速开发中非常有用，但同时也需要开发者自行遵循正确的变量使用规则。

   1 2	number = 10 # 在Ruby中没有类型声明 text = "Hello"

3. 面向对象: Ruby是一种纯粹的面向对象编程语言，几乎所有的东西都是对象，包括数字和类。这使得Ruby非常灵活，可以将功能封装在不同的对象中。

   1 2 3 4 5 6 7 8

   class Dog def bark "Woof!" end end my_dog = Dog.new puts my_dog.bark # 输出 "Woof!"

4. 丰富的标准库: Ruby提供了丰富的标准库，使得许多功能都可以快速实现，从文件处理到网络通信，几乎每个功能都可以用Ruby的标准库来完成。

5. 社区和生态系统: Ruby拥有一个强大而热情的社区，开发者可以利用大量的开源库（即Gem）来扩展 Ruby 的功能。

Ruby与Rails的结合

Ruby与Rails结合的强大厄口常常被称为“愉快的编程”（The joy of programming），因为Rails框架充分利用了Ruby语言的特性来实现简单而优雅的设计。

案例分析

假设你正在开发一个简单的博客应用，使用Rails构建。以下是一个用Ruby实现的基本模型（Model）示例，用于定义“文章”：

1
2
3
4

class Article < ApplicationRecord
  validates :title, presence: true
  validates :content, presence: true
end

在上面的代码中，Article模型使用Rails提供的Active Record库来与数据库交互。在Ruby中，我们使用类和实例来表示数据模型，利用其内置的验证机制确保数据的完整性。

结论

随着对Ruby语言的基本理解，您将能够更全面地学习Ruby on Rails框架。Ruby的优雅和灵活性为Rails提供了强大的动力，使得Web开发变得快速而高效。深入掌握Ruby是您成为一名优秀Rails开发者的关键一步。

接下来，我们将探讨Rails框架的特点，如其结构、约定优于配置的原则等，从而全面理解Ruby on Rails的魅力。在此之前，建议您稍作复习，以确保对Ruby语言的基本概念有更深的理解。

在上一篇文章中，我们介绍了Ruby语言的基础知识，强调了它的优雅与灵活性。本篇将深入探讨Ruby on Rails框架的独特特点，这些特点让Rails成为Web开发领域广受欢迎的框架。无论你是刚接触Web开发的初学者，还是有经验的开发者，理解这些特点都是了解和应用Rails的基础。

1. MVC架构

Ruby on Rails采用了MVC（Model-View-Controller）架构，这种设计模式将应用分为三个主要部分：

• Model（模型）：负责业务逻辑和数据处理。在Rails中，模型通常对应一个数据库表。
• View（视图）：负责显示数据给用户的界面。视图里的代码通常涉及HTML和一些Ruby代码，用于动态生成内容。
• Controller（控制器）：作为模型和视图之间的中介，接收用户输入，处理请求，并最终选择合适的视图进行响应。

这种分离的设计使得代码更加模块化，便于维护和扩展。

案例

假设我们正在创建一个简单的博客应用。这时我们可能会有一个Post模型来处理数据库中的文章数据，一个PostsController来处理文章相关的请求，以及一个posts/index.html.erb视图来显示所有博客文章。

1
2
3
4
5

# app/models/post.rb
class Post < ApplicationRecord
  validates :title, presence: true
  validates :content, presence: true
end

1
2
3
4
5
6

# app/controllers/posts_controller.rb
class PostsController < ApplicationController
  def index
    @posts = Post.all
  end
end

1
2
3
4
5
6

<!-- app/views/posts/index.html.erb -->
<h1>我的博客</h1>
<% @posts.each do |post| %>
  <h2><%= post.title %></h2>
  <p><%= post.content %></p>
<% end %>

2. 快速开发

Rails的一个重要特点是其关注于快速开发。通过约定优于配置的原则，Rails内置了许多功能，使得开发者能够更快速地搭建应用。

约定优于配置

在Rails中，你几乎不需要写很多配置代码。举个例子，当你创建一个新的Rails项目并生成一个模型时，Rails会自动生成对应的数据库迁移文件、视图、控制器等。这意味着你可以专注于实现业务逻辑，而不必为每个小细节配置大量代码。

1
2

rails generate scaffold Post title:string content:text
rails db:migrate

以上命令会创建一个完整的Post资源，包括模型、迁移、控制器和视图，你只需编写少量代码就能拥有一个完整的CRUD应用。

3. 丰富的生态系统

Ruby on Rails具有丰富的生态系统，包括大量的插件和库，能够显著提高开发效率。用于各种功能的gem（Ruby库）可以帮助开发者迅速集成所需的功能。

例如，使用devise库，可以轻松为应用添加用户认证功能。只需在Gemfile中添加一行代码：

1

gem 'devise'

然后执行bundle install安装依赖，接下来只需运行简单的命令，便可实现用户注册、登录等功能。

4. 强大的社区支持

Rails拥有一个活跃且友好的社区，开发者能够从中获取大量的教程、文档和支持。在遇到问题时，你可以在官方文档、Stack Overflow或Rails社区中迅速找到解答。这种强大的社区支持使得学习与解决问题变得更加容易。

5. RESTful架构

Rails强调遵循REST（Representational State Transfer）架构风格，这是一种设计API和Web服务的流行方法。RESTful设计使得开发者能够通过标准的HTTP动作（如GET、POST、PUT和DELETE）来进行资源操作，极大地提高了API的可读性和一致性。

案例

在我们的博客应用中，以下路由定义对应了RESTful风格：

1
2
3

Rails.application.routes.draw do
  resources :posts
end

这将生成标准的七个路由，分别对应于创建、读取、更新和删除文章的操作。

结论

通过上述特点，我们可以清楚地看到Ruby on Rails如何通过其MVC架构、快速开发能力、丰富的生态系统、强大社区支持以及RESTful设计，使得Web开发变得更加高效和愉快。在接下来的章节中，我们将探讨如何搭建开发环境，安装Ruby和Rails，并开始我们的开发之旅。准备好进入Ruby on Rails的世界了吗？让我们继续前进！

在前一篇中，我们介绍了Ruby on Rails框架的特点，例如其“约定优于配置”的理念和强大的社区支持。接下来，我们将开始实际动手搭建开发环境，首先需要安装Ruby及Rails。这一章节将逐步引导你完成这些操作，以确保你能够顺利运行和开发Rails应用。

1. 安装Ruby

1.1 安装工具的选择

在安装Ruby之前，建议使用版本管理工具来管理不同版本的Ruby。我们通常推荐使用rbenv或者RVM。在本教程中，我们将使用rbenv，因为它更加简单轻便并且可以有效防止与系统Ruby发生冲突。

1.2 安装rbenv

在Unix或Linux系统上，你可以使用以下命令来安装rbenv：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 安装依赖
sudo apt update
sudo apt install -y git curl

# 克隆rbenv仓库
git clone https://github.com/rbenv/rbenv.git ~/.rbenv

# 将rbenv添加到PATH中
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec $SHELL

# 安装ruby-build插件用于安装Ruby版本
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build

1.3 安装Ruby

完成了rbenv的安装后，你可以运行以下命令来安装所需的Ruby版本（例如：3.1.2）：

1
2

rbenv install 3.1.2
rbenv global 3.1.2

通过运行ruby -v来确认Ruby是否安装成功：

1

ruby -v

你应该看到类似于以下输出：

1

ruby 3.1.2p20 (2022-04-12 revision 8c3050b40b) [x86_64-linux]

2. 安装Rails

2.1 安装Rails gem

在Ruby安装成功后，你可以通过gem命令来安装Rails。在终端中运行以下命令：

1

gem install rails

安装完成后，再次执行命令来验证Rails版本：

1

rails -v

你应该会看到输出类似于：

1

Rails 7.0.3

2.2 验证环境是否搭建成功

在成功安装Rails之后，接下来我们可以通过创建一个新的Rails应用来确认一切工作正常。运行以下命令创建一个名为myapp的Rails应用：

1

rails new myapp

进入应用目录并启动Rails服务器：

1
2

cd myapp
rails server

访问http://localhost:3000，你应该会看到Rails的欢迎页面，表明你的开发环境已经准备好。

3. 常见问题

• Ruby未安装：如果你在运行ruby -v时遇到“未找到命令”的错误，可能是rbenv没有添加到你的PATH中。请检查你的.bashrc或.bash_profile文件，确保上述环境变量配置正确。

• Rails安装失败：如果gem install rails过程中出现依赖问题，请确保你的Ruby环境正确，并尝试更新gem：

1

gem update --system

结语

在本篇教程中，我们成功安装了Ruby和Rails，并创建了一个新的Rails应用。通过这个过程，你不仅学会了如何设置开发环境，还体验了Rails的初步功能。下一章节中，我们将配置我们的开发环境，进一步优化开发体验。继续关注，以获得更深入的Ruby on Rails开发技巧和知识！

在前一篇中，我们成功安装了 Ruby 和 Rails，现在我们将继续进行配置开发环境的步骤。正确的配置对于顺利开发 Rails 应用至关重要。在这一章中，我们将涵盖以下几个要点：

1. 选择和配置数据库
2. 配置 Rails 环境变量
3. 安装和配置使用的编辑器
4. 版本管理工具的使用

选择和配置数据库

在 Rails 中，我们通常使用 PostgreSQL、MySQL 或 SQLite 作为数据库。由于 SQLite 是一个轻量级的数据库，适合开发和测试阶段，我们建议在开发环境中使用 SQLite，而在生产环境中使用更强大的数据库，如 PostgreSQL。下面是如何配置数据库的简单步骤：

安装 SQLite

在大多数操作系统中，SQLite 默认已安装，但你可以通过以下命令来检查和安装（以 Ubuntu 上为例）：

1
2

sudo apt update
sudo apt install sqlite3 libsqlite3-dev

配置数据库

在你的 Rails 项目中，有一个名为 database.yml 的文件，这个文件位于 config 文件夹中。该文件定义了应用程序所使用的数据库的配置。

打开 config/database.yml 文件并确保开发环境配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

default: &default
  adapter: sqlite3
  pool: 5
  timeout: 5000

development:
  <<: *default
  database: db/development.sqlite3

test:
  <<: *default
  database: db/test.sqlite3

production:
  <<: *default
  database: db/production.sqlite3

在以上配置中，development 环境将使用 db/development.sqlite3 作为数据库文件。

配置 Rails 环境变量

环境变量常用于存储敏感信息，如数据库密码或API密钥。我们可以使用 dotenv gem 来方便地管理环境变量。

安装 dotenv

在 Gemfile 中添加以下行：

1

gem 'dotenv-rails', groups: [:development, :test]

然后运行以下命令以安装 gem：

1

bundle install

创建 .env 文件

在 Rails 项目的根目录下创建一个 .env 文件，然后在其中添加你需要的环境变量：

1
2

DATABASE_USERNAME=your_username
DATABASE_PASSWORD=your_password

在进行数据库配置时，可以使用这些环境变量来避免硬编码敏感信息。例如，在 database.yml 中可以这样使用：

1
2
3
4
5

development:
  <<: *default
  database: db/development.sqlite3
  username: <%= ENV['DATABASE_USERNAME'] %>
  password: <%= ENV['DATABASE_PASSWORD'] %>

安装和配置使用的编辑器

选择合适的代码编辑器可以显著提高开发效率。常用的编辑器包括 Visual Studio Code、Sublime Text 和 RubyMine。这里我们以 Visual Studio Code 为例。

安装 Visual Studio Code

你可以从 Visual Studio Code 的官方网站下载并安装它。安装完成后，建议你安装一些扩展支持 Ruby 开发。

安装 Ruby 扩展

打开 Visual Studio Code，进入扩展市场，搜索并安装以下扩展：

• Ruby：提供语法高亮、代码片段等
• Solargraph：为 Ruby 提供智能感知
• Rails：支持 Rails 开发的工具

版本管理工具的使用

版本管理对于协调团队开发和维护代码至关重要。我们通常使用 Git 来进行版本控制。

安装 Git

在大多数操作系统上，Git 都有默认安装。如果你尚未安装，可以使用以下命令进行安装（以 Ubuntu 为例）：

1
2

sudo apt update
sudo apt install git

初始化 Git 仓库

在你的 Rails 项目目录下，运行以下命令来初始化一个新的 Git 仓库：

1

git init

接着，你可以使用以下命令添加文件，提交更改：

1
2

git add .
git commit -m "Initial commit"

小结

在本章中，我们成功配置了开发环境，包括数据库的选择和配置、环境变量的管理、代码编辑器的推荐及版本管理工具的使用。一个良好的开发环境能够极大提升你的工作效率。接下来，我们将继续进行 Rails 项目的创建步骤。在那篇文章中，我们将介绍如何创建一个空的 Rails 项目并运行它。

在成功配置开发环境后，接下来的步骤是创建一个空的Rails项目。这一过程将基于上章中配置好的环境，通过创建一个新的Rails应用程序来验证我们的开发环境设置是否正确。

创建空Rails项目

在终端中执行以下命令来创建一个新的Rails项目：

1

rails new my_first_app

这里的 my_first_app 是你新项目的名称。执行此命令时，Rails会自动为你创建一个新的项目目录，并生成一系列文件和目录结构。

命令参数

Rails的new命令有许多可用的选项，常用的参数包括：

• --database: 指定你要使用的数据库类型（例如 mysql, postgresql, sqlite3）。
• --skip-test: 跳过测试框架的生成。
• --api: 创建一个API-only应用。

例如，如果你想使用PostgreSQL数据库，可以执行以下命令：

1

rails new my_first_app --database=postgresql

目录结构

生成项目后，可以进入到新创建的目录并查看其结构：

1

cd my_first_app

一个基本的Rails项目的目录结构会如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

my_first_app/
├── app/
│   ├── assets/
│   ├── controllers/
│   ├── helpers/
│   ├── javascript/
│   ├── jobs/
│   ├── mailers/
│   ├── models/
│   └── views/
├── bin/
├── config/
├── db/
├── lib/
├── log/
├── public/
├── test/
├── tmp/
└── vendor/

• app/: 存放应用的主要代码，包含模型、控制器、视图等。
• config/: 处理配置文件，Rails的路由和设置。
• db/: 数据库相关的文件，例如迁移文件。
• public/: 可公开访问的文件。
• log/: 存放日志文件。

每个目录都有其特定的责任，确保了解每个部分的作用对于后续开发至关重要。

启动Rails服务器

接下来，用以下命令启动Rails服务器，确保一切已正确搭建：

1

bin/rails server

成功启动后，终端中会出现如下信息：

1
2
3

=> Booting Puma
=> Rails 7.x.x application starting in development
=> Run `bin/rails server --help` for more startup options

打开浏览器，访问 http://localhost:3000，如果看到Welcome aboard的页面，恭喜你，你已经成功创建了一个空的Rails项目。

常见问题

在创建空项目或启动服务器时，可能会遇到以下常见问题：

1. 未找到Rails命令：

   • 请确保已经在终端中安装了Rails，可以通过 gem install rails 来安装最新版本。

2. 数据库连接错误：

   • 确保所选数据库已安装并且正确配置。

3. 权限问题：

   • 在某些情况下，你可能需要使用sudo权限来运行命令，或者检查相关文件和目录的权限设置。

总结

在本章中，我们完成了空Rails项目的创建并成功启动了开发服务器。接下来，我们将进入到第三章，开始创建我们的第一个Rails应用，通过生成控制器和视图来更深入地了解Rails的工作机制。在这之前，确保你对本章的流程有透彻的理解，这将帮助你在后续的学习中更为顺利。

在上一章中，我们讨论了如何创建一个空的Rails项目，现在我们进入更具体的内容：生成第一个控制器和视图。在这一章中，我们将学习如何使用Rails命令行工具快速生成控制器，以及如何创建与之关联的视图文件。

生成控制器

Rails为我们提供了一个强大的命令行工具，可以非常方便地生成所需的控制器。在我们的示例应用中，让我们创建一个简单的Articles控制器。打开终端，确保你在项目目录下，执行以下命令：

1

rails generate controller Articles

运行这个命令后，Rails会为我们生成一个名为ArticlesController的控制器类，文件位于app/controllers/articles_controller.rb中。同时，Rails还会自动创建与之对应的视图文件夹和一些基础的视图文件。

查看生成的代码

在app/controllers/articles_controller.rb中，你会看到如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class ArticlesController < ApplicationController
  def index
  end

  def show
  end

  def new
  end

  def create
  end

  def edit
  end

  def update
  end

  def destroy
  end
end

这个控制器包含了关于Article的标准RESTful动作，如index、show、new、create、edit、update和destroy。每个方法将在后续的章节中实现具体逻辑。

生成视图文件

在执行生成控制器命令后，同时在app/views/articles目录下也会创建一些视图文件，最初是空的。视图文件包括如下几个：

• index.html.erb
• show.html.erb
• new.html.erb
• edit.html.erb

默认情况下，这些文件是空的，我们将逐步填充它们。

创建第一个视图

接下来，我们将为index视图添加一些内容。打开app/views/articles/index.html.erb，然后添加以下内容：

1
2
3

<h1>Articles</h1>

<p>Welcome to the Articles index page! Your articles will be listed here.</p>

在这里，我们简单地创建了一个标题和欢迎消息。在后续的章节中，我们会动态地显示文章的列表。

测试控制器和视图

为了测试我们的控制器和视图是否工作正常，我们需要在下一步设置路由。首先，我们可以使用Rails提供的开发服务器来查看效果。运行命令：

1

rails server

接着，打开浏览器，访问http://localhost:3000/articles。如果一切正常，你应该能够看到你在index.html.erb中定义的内容。

小结

在本章中，我们成功生成了一个控制器和视图，并向视图中添加了基础内容。控制器为我们提供了不同的动作框架，而视图则是用户实际看到的页面。

在下一章中，我们将探讨如何设置路由，以将HTTP请求映射到我们刚刚创建的控制器动作。希望你能继续跟我们的教程，一步步构建出功能完整的Rails应用！

在前面的章节中，我们生成了一个控制器和视图，为我们的Rails应用奠定了基础。现在，我们将学习如何设置路由，使得你的应用能正确地响应HTTP请求，并能将请求转发到正确的控制器和动作。

什么是路由？

在Ruby on Rails中，路由是应用程序的一个重要组成部分。它负责将HTTP请求映射到控制器的特定动作。通过定义路由，我们可以告诉Rails如何处理特定的URL请求。

Rails使用 config/routes.rb 文件来管理应用程序的路由定义。在这个文件中，我们可以设置URL模式，并指定当请求匹配这些模式时应该执行什么操作。

创建简单的路由

让我们来看看如何在 routes.rb 文件中为我们的应用添加简单的路由。假设我们创建的控制器是 ArticlesController，并且我们希望能够通过特定的URL访问它的动作，例如：index 和 show。

首先，打开 config/routes.rb 文件。我们将添加以下代码：

1
2
3

Rails.application.routes.draw do
  resources :articles
end

这段代码使用了 resources 方法，它为 articles 资源生成了一系列RESTful路由。这些路由包括：

• GET /articles - 对应 ArticlesController#index，用于显示所有文章
• GET /articles/new - 对应 ArticlesController#new，用于显示新建文章的表单
• POST /articles - 对应 ArticlesController#create，用于创建新文章
• GET /articles/:id - 对应 ArticlesController#show，用于显示特定文章
• GET /articles/:id/edit - 对应 ArticlesController#edit，用于编辑特定文章
• PATCH/PUT /articles/:id - 对应 ArticlesController#update，用于更新特定文章
• DELETE /articles/:id - 对应 ArticlesController#destroy，用于删除特定文章

利用 resources 方法，我们可以方便地处理RESTful风格的请求，而不必手动逐个定义每条路由。

自定义路由

如果你需要更复杂的路由设置，也可以自定义路由。例如，假设你想为 articles 资源添加一个 publish 动作，可以在 routes.rb 中如下添加：

1
2
3
4
5
6
7

Rails.application.routes.draw do
  resources :articles do
    member do
      post 'publish'
    end
  end
end

在这个例子中，publish 路由将对应 ArticlesController 中的 publish 动作，并且URL模式将是 POST /articles/:id/publish。

检查路由

完成路由设置后，我们可以使用以下命令在终端中检查已定义的路由：

1

rails routes

这将列出应用程序中所有的路由，包括它们所对应的HTTP动词与控制器动作。你应该能看到像以下输出：

1
2
3
4
5
6
7
8

    articles GET    /articles(.:format)          articles#index
             POST   /articles(.:format)          articles#create
 new_article GET    /articles/new(.:format)      articles#new
edit_article GET    /articles/:id/edit(.:format) articles#edit
     article GET    /articles/:id(.:format)      articles#show
             PATCH  /articles/:id(.:format)      articles#update
             PUT    /articles/:id(.:format)      articles#update
             DELETE /articles/:id(.:format)      articles#destroy

通过查看这些路由，我们确认路由组的设置是否按预期工作。

总结

在本篇中，我们学习了如何设置Rails应用程序的路由。通过 resources 方法，我们快速定义了一整套RESTful路由，并且了解了自定义路由的基本方法。掌握了路由配置后，我们可以更好地控制应用程序的请求处理过程。

在下一篇中，我们将学习如何运行我们的Rails应用程序，并查看为 articles 生成的控制器和视图是如何工作的。请继续关注！

在上一篇文章中，我们讨论了如何设置路由，使得我们的Rails应用程序能够处理HTTP请求并将其路由到相应的控制器和动作。现在，我们将进一步探索如何运行我们的Rails应用程序，并查看我们所创建的路径返回的内容。

启动Rails服务器

在构建Rails应用程序时，第一步是确保我们能够启动本地服务器，以便在浏览器中查看我们的应用。Rails 提供了一个内置的开发服务器，称为 Puma。我们可以通过以下命令启动服务器：

1

rails server

执行此命令后，您应该看到类似以下内容的输出：

1
2
3

=> Booting Puma
=> Rails 6.1.3 application starting in development
=> Run `rails server --help` for more startup options

默认情况下，Rails会在 http://localhost:3000 端口上启动服务器。您可以打开浏览器并输入该地址来查看应用程序。

访问路由

一旦服务器启动，您可以访问设置的路由。假设您在上一节中创建了一个名为 welcome 的控制器，并且为其添加了一个 index 方法，并且路由文件 config/routes.rb 中包含了以下内容：

1
2
3

Rails.application.routes.draw do
  get 'welcome/index'
end

在浏览器中访问 http://localhost:3000/welcome/index，您应该能够看到该页面的内容。

为了让我们看得更清楚，假设我们在 WelcomeController 中的 index 方法中返回了简单的HTML：

1
2
3
4
5

class WelcomeController < ApplicationController
  def index
    render html: "<h1>欢迎来到我的Rails应用！</h1>".html_safe
  end
end

如此，您在浏览器中所看到的内容将是：

1

欢迎来到我的Rails应用！

处理静态文件

Rails应用程序默认会提供一些静态资产，例如CSS和JavaScript文件。你可以在 app/assets 文件夹中找到这些文件。为了确保这些文件在你的应用中有效，请在 application.html.erb 布局文件中进行适当的引用，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<!DOCTYPE html>
<html>
<head>
  <title>MyRailsApp</title>
  <%= csrf_meta_tags %>
  <%= csp_meta_tag %>
  <%= stylesheet_link_tag 'application', media: 'all', 'data-turbolinks-track': 'reload' %>
  <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>
</head>

<body>
  <%= yield %>
</body>
</html>

在 app/assets/stylesheets/application.css 文件中，您可以添加一些自定义样式来提升网页的外观。

例如，如果您添加以下CSS样式：

1
2
3
4

h1 {
  color: blue;
  text-align: center;
}

那么页面中的标题将会是蓝色且居中显示。

检查更改

每次您对应用程序的代码进行更改后，保存文件并刷新浏览器页面，您应该能够立即看到更改的效果。例如，您可以修改 index 方法的内容，或者修改显示的HTML标记，以测试实时更新的效果。

基于案例的继续探索

在运行应用程序的过程中，您可能会想尝试添加更多的功能或页面。例如，您可以为应用添加一个新的控制器、视图和路由，通过以下命令创建一个新的控制器：

1

rails generate controller About

接着，您可以在 AboutController 中定义 index 方法，并设置新的路由：

1
2

# routes.rb
get 'about/index'

然后在 AboutController 中：

1
2
3
4
5

class AboutController < ApplicationController
  def index
    render html: "<h1>关于我们</h1><p>这是关于我们页面的简单介绍。</p>".html_safe
  end
end

访问 http://localhost:3000/about/index，您就能创建新的页面并查看内容。

小结

通过学习如何启动Rails服务器并访问设置的路由，我们可以向应用程序添加更多功能和页面。在这个过程中，您掌握了如何将控制器方法与路由相连接，并且了解了如何处理HTML输出。接下来的章节将深入探讨Rails的MVC架构，以及控制器、模型和视图如何协同工作，构建强大而灵活的应用程序。

期待在下章中与您继续探索Rails的奥秘！

在上一章中，我们成功运行了我们的第一个Rails应用程序，体验了Rails框架带来的便利。这一章我们将深入探讨Rails中的核心概念之一：MVC架构。

MVC架构概述

MVC代表的是“模型-视图-控制器”（Model-View-Controller），是一个设计模式，用于组织代码，使其更加易于维护和扩展。在Rails中，这种架构将应用程序的不同部分分离，帮助开发者更清晰地理解和管理代码。我们来详细了解每个部分的职责。

模型（Model）

模型是应用程序中数据的抽象和业务逻辑的代表。它负责与数据库交互，封装应用程序的核心数据以及实现数据验证和业务规则。在Rails中，模型通常对应于数据库中的表。在典型的Rails应用中，我们可能会有一个User模型来表示用户数据。

1
2
3
4

class User < ApplicationRecord
  validates :name, presence: true
  validates :email, presence: true, uniqueness: true
end

在这个例子中，User模型确保每个用户都有一个名称和唯一的电子邮件地址。通过使用ActiveRecord这一ORM（对象关系映射）库，开发者可以方便地与数据库进行交互。

视图（View）

视图是应用程序的用户界面部分，负责将模型数据呈现给用户。在Rails中，视图通常使用ERB（Embedded Ruby）模板引擎来生成动态HTML内容。视图将数据和HTML结构结合起来，最终呈现出来。

1

<h1>欢迎回来，<%= @user.name %>!</h1>

在这个ERB视图中，我们展示了用户的名称，这是从User模型中提取出来的。视图应该尽量保持简单，只负责数据显示和用户界面的呈现，而不包含复杂的业务逻辑。

控制器（Controller）

控制器是MVC架构中连接模型和视图的桥梁。它接收用户的输入，处理相应的业务逻辑，随后选择适当的视图进行呈现。控制器负责协调模型和视图之间的交互。

下面是一个简单的控制器示例，代表一个用户的控制器：

1
2
3
4
5

class UsersController < ApplicationController
  def show
    @user = User.find(params[:id])
  end
end

在这个控制器中，show方法获取了一个特定的用户，并将其保存在实例变量@user中，以便在视图中使用。

三者的协作

MVC架构的核心在于三者之间的协作。控制器接收来自用户的请求，查询模型获得数据，并将数据传递给视图。视图将模型数据展示给用户，并能接收用户的输入（比如表单提交），这些输入会再次通过控制器返回模型中进行处理。

案例分析

假设我们有一个简单的博客应用，用户可以创建、查看和删除文章。我们将用MVC架构来处理这个功能。

1. 模型：创建一个Post模型用于代表文章数据。

1
2
3
4

class Post < ApplicationRecord
  validates :title, presence: true
  validates :content, presence: true
end

2. 控制器：创建PostsController来处理与文章相关的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class PostsController < ApplicationController
  def index
    @posts = Post.all
  end

  def show
    @post = Post.find(params[:id])
  end

  def new
    @post = Post.new
  end

  def create
    @post = Post.new(post_params)
    if @post.save
      redirect_to @post
    else
      render :new
    end
  end

  private

  def post_params
    params.require(:post).permit(:title, :content)
  end
end

3. 视图：创建相应的视图文件来显示和操作文章。

index.html.erb视图文件展示所有文章：

1
2
3
4

<h1>所有文章</h1>
<% @posts.each do |post| %>
  <h2><%= link_to post.title, post %></h2>
<% end %>

show.html.erb视图文件展示单个文章的内容：

1
2
3

<h1><%= @post.title %></h1>
<p><%= @post.content %></p>
<%= link_to '返回', posts_path %>

结论

在这一章中，我们概述了Rails的MVC架构，深入理解了模型、视图和控制器的职责，以及它们之间如何协作来构建一个功能丰富的应用。在接下来的章节中，我们将更深入地探讨模型的职责，了解如何更有效地使用ActiveRecord进行数据库交互和数据管理。通过继续学习，我们将能够扩展我们的知识，构建出更复杂的Rails应用程序。

在学习了Rails的MVC架构概述后，接下来我们要深入探讨模型在Rails中的职责。模型是Rails中关键的组件之一，它主要负责数据的管理、业务逻辑的处理，以及与数据库的交互。在本章中，我们将会讨论模型的基本概念、职责以及如何在Rails应用中有效使用模型。

模型的基本概念

在Rails中，模型通常对应于数据库中的一张表。每个模型类都继承自ActiveRecord::Base，这意味着Rails为你提供了一种简单的方式来与数据库进行交互。每个模型的实例通常代表数据库中的一条记录。模型的命名遵循约定，如User模型对应于users表，Post模型对应于posts表。

例子

假设我们有一个简单的博客应用，有一个Post模型，表示博客文章。它的定义如下：

1
2
3
4
5

class Post < ApplicationRecord
  # 模型的验证
  validates :title, presence: true
  validates :content, presence: true
end

在这个例子中，Post模型包含了对title和content字段的验证，确保在保存到数据库之前它们必须存在。

模型的职责

1. 数据验证

模型的一个主要职责是执行数据的验证。正如上面例子中所示，我们为Post模型添加了验证规则，确保数据的完整性。Rails为模型提供了多种内置的验证方法，比如presence、uniqueness、length等。

2. 关联关系

模型还可以定义与其他模型的关系。这些关系通常是数据库表之间的外键关系。在Rails中，你可以使用belongs_to、has_many、has_one等方法来设置这些关联。

例如，假设每个Post都属于一个User，我们可以这样定义模型：

1
2
3
4
5
6
7

class Post < ApplicationRecord
  belongs_to :user
end

class User < ApplicationRecord
  has_many :posts
end

在这个例子中，Post模型通过belongs_to关联到User模型，表明每个文章都属于一个用户，而User模型则通过has_many关联到Post模型，表明一个用户可以拥有多篇文章。

3. 业务逻辑

模型也负责处理与特定业务逻辑相关的功能。这意味着我们可以在模型中定义方法，以处理某些复杂的计算或数据转换。

例如，假设我们希望在Post模型中定义一个方法，用于计算文章的字数：

1
2
3
4
5
6

class Post < ApplicationRecord
  # 计算内容的字数
  def word_count
    content.split.size
  end
end

用户可以通过post.word_count来获取特定文章的字数，而无需在控制器或视图中重复逻辑。

4. 数据访问和持久化

模型也承担了所有与数据库的交互操作。例如，可以轻松地创建、查询、更新和删除记录，而不需要直接写SQL语句。Rails的ActiveRecord为我们提供了丰富的接口来实现这些功能。

以下是一些基本的数据库操作示例：

1
2
3
4
5
6
7
8
9
10
11

# 创建新记录
post = Post.create(title: '新文章', content: '这是我的第一篇文章')

# 查询记录
posts = Post.where('created_at >= ?', Time.now.beginning_of_day)

# 更新记录
post.update(content: '更新后的文章内容')

# 删除记录
post.destroy

以上代码展示了模型如何处理数据持久化和访问的例子。

总结

模型在Rails的MVC架构中扮演着至关重要的角色。它不仅管理数据，还执行数据验证、定义关系、处理业务逻辑和与数据库互动。掌握了模型的职责后，你将能够更好地设计和实现功能强大的Rails应用。

在下一篇中，我们将探讨视图的职责，了解如何将数据以用户友好的方式呈现，并实现用户交互。

在上一章节中，我们探讨了 Rails 应用中的模型（Model）职责，理解了数据如何在应用内被管理和持久化。本章将深入讨论 视图（View） 在 MVC（Model-View-Controller） 架构中的角色和职责。视图是你应用的前端部分，它负责呈现数据给用户并处理用户的交互，但并不包含任何业务逻辑。

视图的基本职责

在 Rails 中，视图的主要职责包括：

1. 数据的展示：视图从控制器接收数据，并根据逻辑构建最终展示给用户的 HTML。
2. 用户界面的结构：视图定义用户界面的结构和样式，确保用户可以友好地与应用交互。
3. 处理用户输入：视图可以包含表单，用于接收用户输入的数据，并将其发送给控制器进行处理。

示例应用

假设我们正在构建一个简单的博客应用。我们的模型可能包含文章（Article）和作者（Author）。在这一部分，我们将专注于如何使用 Rails 的视图来展示这些文章。

创建视图

首先，我们会在 ArticlesController 中设置我们的 index 动作，以获取所有文章并将其传递给视图：

1
2
3
4
5

class ArticlesController < ApplicationController
  def index
    @articles = Article.all
  end
end

这段代码将所有文章从数据库中取出，并将其赋值给实例变量 @articles。接下来，我们需要创建视图文件来展示这些文章。

在 app/views/articles/index.html.erb 文件中，我们可以使用以下代码来展示文章列表：

1
2
3
4
5
6
7
8
9
10
11

<h1>文章列表</h1>

<% if @articles.any? %>
  <ul>
    <% @articles.each do |article| %>
      <li><%= link_to article.title, article_path(article) %></li>
    <% end %>
  </ul>
<% else %>
  <p>没有文章。</p>
<% end %>

在这段代码中，使用了 <%= ... %> 语法来输出 article.title，并且使用 link_to 方法创建文章的链接。<% ... %> 语法则用于执行控制逻辑，如循环和条件判断，这些都是典型的视图职责。

视图中的局部视图

为了提高代码的复用性，我们可以使用局部视图（Partial Views）。例如，我们可以将每个文章的展示单元提取到一个局部视图中。

首先，在 app/views/articles/_article.html.erb 文件中，添加如下代码：

1

<li><%= link_to article.title, article_path(article) %></li>

接着，在 index.html.erb 中，我们可以通过调用这个局部视图来简化代码：

1
2
3
4
5
6
7
8
9

<h1>文章列表</h1>

<% if @articles.any? %>
  <ul>
    <%= render @articles %>
  </ul>
<% else %>
  <p>没有文章。</p>
<% end %>

这里我们使用 <%= render @articles %> 来渲染每个文章的局部视图。这样，代码结构更加清晰，并且便于维护。

表单的创建

视图的另一个重要职责是处理用户输入，通常表现为表单。在我们的博客应用中，用户需要能够创建新的文章。我们在 ArticlesController 中添加一个 new 动作，并准备相应的视图。

1
2
3

def new
  @article = Article.new
end

在 app/views/articles/new.html.erb 中，我们可以使用以下代码构建一个表单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<h1>新建文章</h1>

<%= form_with model: @article do |form| %>
  <div>
    <%= form.label :title %>
    <%= form.text_field :title %>
  </div>
  <div>
    <%= form.label :content %>
    <%= form.text_area :content %>
  </div>
  <div>
    <%= form.submit '创建文章' %>
  </div>
<% end %>

在这个示例中，form_with 辅助方法用于生成与模型绑定的表单。它将自动为我们创建相应的表单输入字段，并确保正确的路由和 HTTP 方法。

结论

在本章中，我们深入了解了 视图 在 Rails 应用中的职责。通过展示数据、构建用户界面以及处理用户输入，视图为用户提供了与应用交互的界面。接下来，我们将继续探讨 控制器（Controller） 的职责，它负责协调模型和视图之间的交互，确保应用按照预期响应用户的请求。