Ruby on Rails - 快速指南

Ruby on Rails - 快速指南

Ruby on Rails - 简介

什么是 Ruby？

在深入了解 Rails 之前，理解 Ruby（Rails 构建所基于的编程语言）至关重要。

Ruby 常被描述为以下特点的融合：

• Smalltalk 的概念优雅和纯粹的面向对象特性，
• Python 的易用性和可读性，以及
• Perl 的实用脚本处理能力。

Ruby 的主要特点：

• 一种动态（dynamic）、开源（open-source）的编程语言，专注于简洁性和生产力。
• 解释型语言（Interpreted），类似于 Perl、Python 和 Tcl/TK。
• 真正的面向对象（object-oriented）：在 Ruby 中，一切皆对象，包括数字等基本类型（primitive types）。

为什么 Ruby 适合 Rails？

Ruby 的设计理念和特性使其非常适合使用 Rails 进行 Web 开发。它的流行源于：

• 可读性和简洁性：Ruby 的语法设计接近自然语言，相对容易学习和阅读。
• 开源：在宽松许可下可用， fostering a large and active community.
• 丰富的标准库和 Gem：拥有庞大的库（称为 ‘gem’）集合，几乎涵盖任何任务。
• 元编程：Ruby 允许程序编写或操作其他程序（或自身），Rails 大量利用此特性来减少样板代码（boilerplate code）。
• 开发者幸福感：Ruby 社区的核心理念，致力于让开发过程愉快且高效。

注意事项：

• 性能：历史上，与编译型语言相比，Ruby 的执行速度曾是一个问题。然而，随着近期 Ruby 版本中 YJIT（Yet Another JIT Compiler）等技术的进步，Rails 应用程序的性能已显著提高。
• 并发和并行：在 MRI（Matz’s Ruby Interpreter）中的全局解释器锁（Global Interpreter Lock - GIL）意味着每个进程只能同时执行一个 Ruby 线程。然而，I/O 密集型操作可以释放 GIL，允许并发。对于 CPU 密集型任务，可以使用多进程架构（如 Puma Web 服务器所用）或 Ractors 等实验性特性来实现并行。

Ruby 代码示例

以下是一个简单的 Ruby 类：

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

  def salute
    puts "Hello, #{@name}! Welcome to the world of Ruby."
  end
end

# Create a new object
g = Greeter.new("rubyist")

# Call the salute method
g.salute

输出：

Hello, Rubyist! Welcome to the world of Ruby.

嵌入式 Ruby (ERB)

ERB（Embedded Ruby）是一种模板系统，允许您将 Ruby 代码嵌入到文本文档中，最常见的是用于网页的 HTML。Rails 在其视图模板（view templates）中广泛使用 ERB。

ERB 使用特定的标签：

• <% ... %>：执行标签内的 Ruby 代码。不会打印任何内容到输出。
• <%= ... %>：执行 Ruby 代码并将表达式的结果打印到输出。
• <%# ... %>：注释标签；其中的代码将被忽略。

示例 (template.html.erb)：

<% page_title = "ERB Demonstration" %>
<% salutation = "Dear Developer," %>

<html>
<head>
  <title><%= page_title %></title>
</head>
<body>
  <p><%= salutation %></p>
  <p>This is an example of how ERB templates work in Rails views.</p>
</body>
</html>

当 Rails 处理此 ERB 模板时，它将生成一个包含 Ruby 变量插值的 HTML。

什么是 Rails？

• Ruby on Rails（通常简称为“Rails”）是一个强大且用 Ruby 编写的 Web 应用程序框架。
• 由 David Heinemeier Hansson (DHH) 创建。
• 它遵循 模型-视图-控制器 (MVC) 架构模式。
• 强调 约定优于配置 (Convention over Configuration - CoC) 和 不要重复你自己 (Don’t Repeat Yourself - DRY) 原则。
• 专为快速开发数据库驱动的 Web 应用程序而设计。
• 开源且拥有一个庞大、充满活力的社区。

全栈框架

Rails 是一个全栈（full-stack）框架，这意味着它为 Web 应用程序开发的各个层面提供了工具和库：

• 数据库交互（通过 Active Record ORM）。
• 路由（将 URL 映射到控制器动作）。
• 控制器逻辑（处理请求和响应）。
• 视图模板（使用 ERB、Slim、Haml 等生成 HTML）。
• 资产管理（通过 Sprockets 或 Webpacker/Shakapacker 管理 CSS、JavaScript、图像）。
• 后台作业（Active Job）。
• 实时特性（Action Cable）。
• 邮件发送（Action Mailer）。

约定优于配置 (Convention over Configuration)

Rails 对常见的命名约定（例如，一个 Book 模型映射到 books 数据库表）做出了假设。通过遵循这些约定，开发者编写的配置代码比许多其他框架要少得多。应用程序的结构和数据库模式通常为 Rails 提供了它所需的所有信息。

Rails 的优势

Rails 提供多种特性来提高开发者的生产力：

元编程 (Metaprogramming)

Rails 利用 Ruby 的元编程能力动态定义方法和行为，从而减少样板代码并使代码更具表现力。例如，Active Record 会自动为数据库列创建访问器方法（accessor methods）。

Active Record

Rails 中的对象关系映射（Object-Relational Mapper - ORM）。它允许开发者像操作 Ruby 对象一样与数据库表交互，抽象掉了大部分 SQL 代码。Active Record 处理数据库连接、模式发现、CRUD 操作（创建、读取、更新、删除）、关联（associations）、验证（validations）等等。

内置测试

Rails 具有强大的测试文化。当您创建模型或控制器时，它会自动生成测试文件（默认使用 Minitest）。夹具（fixtures）或工厂（factories）（例如 FactoryBot）等工具帮助设置测试数据。RSpec 是一个流行的替代测试框架。

开发环境

Rails 提供了三个默认环境（environments）：development（开发）、test（测试）和 production（生产）。每个环境都有稍微不同的配置（例如，缓存行为、错误报告、使用的数据库），以适应其目的，从而简化了开发生命周期。

脚手架 (Scaffolding)

Rails 可以生成“脚手架”（scaffolding）——一组基本的模型（model）、视图（views）、控制器（controller）和路由（routes），用于某个资源。这对于快速搭建 CRUD 接口、原型开发或学习 Rails 组件如何协同工作非常有用。

Ruby on Rails - 安装

要使用 Ruby on Rails 开发 Web 应用程序，您需要设置开发环境，包含以下组件：

• Ruby：编程语言本身。
• RubyGems：Ruby 库（gem）的包管理器。
• Bundler：管理应用程序特定的 gem 依赖。
• Rails：框架本身（作为 gem 安装）。
• JavaScript 运行时环境：例如 Node.js，通常用于资产管道（Asset Pipeline）（管理 JavaScript 和 CSS）。
• 数据库系统：Rails 支持 SQLite、PostgreSQL、MySQL、Oracle、SQL Server 等。SQLite 通常是新应用程序在开发和测试环境中的默认选项。
• Web 服务器：Puma 是 Rails 应用程序的默认 Web 服务器。

我们将介绍 Windows 和基于 Linux 的系统的安装步骤。对于 macOS，通常推荐使用版本管理器（version manager），如 rbenv 或 RVM，步骤与 Linux 类似。

通用建议：使用 Ruby 版本管理器

强烈建议在 macOS 和 Linux 上使用 Ruby 版本管理器，如 rbenv 或 RVM (Ruby Version Manager)。它可以让您轻松安装并在不同 Ruby 版本之间切换，避免冲突，这对于需要特定 Ruby 版本的项目至关重要。

在 Windows 上安装 Rails

按照以下步骤在 Windows 上安装 Ruby on Rails：

步骤 1：使用 RubyInstaller 安装 Ruby

1. 访问 RubyInstaller for Windows。
2. 下载推荐的 Ruby+Devkit 安装器版本（例如，Ruby 3.2.x (x64) 或最新的稳定版本）。
3. 运行安装程序。接受许可并保留默认设置，确保勾选“将 Ruby 可执行文件添加到 PATH”（Add Ruby executables to your PATH）。
4. 在“安装目标和可选任务”（Installation Destination and Optional Tasks）屏幕上，也勾选 MSYS2 开发工具链安装选项（通常是第一个选项，例如 ridk install）。这对于安装带有本地扩展（native extensions）的 gem 至关重要。
5. Ruby 安装完成后，可能会打开一个命令提示符窗口进行 MSYS2 设置。如果提示，按 ENTER 安装 MSYS2 基本系统和开发工具链。

步骤 2：验证 Ruby 和 RubyGems 安装

打开一个新的命令提示符（Command Prompt）（最初不要使用 PowerShell，因为 PATH 更新可能不会立即生效），然后输入：

C:\> ruby -v
C:\> gem -v

您应该会看到已安装的 Ruby 和 RubyGems 版本。

步骤 3：安装 Bundler 和 Rails

Bundler 管理应用程序的 gem 依赖。Rails 本身就是一个 gem。

C:\> gem install bundler
C:\> gem install rails

这可能需要几分钟，因为它会下载并安装 Rails 及其依赖项。请确保您有活动的互联网连接。

步骤 4：验证 Rails 安装

检查已安装的 Rails 版本：

C:\> rails -v

这应该会输出 Rails 版本，例如 Rails 7.1.0。

步骤 5：安装 Node.js (JavaScript Runtime)

Rails 通常需要 JavaScript 运行时环境来实现资产管道（Asset Pipeline）等功能。从 nodejs.org 安装 Node.js。下载 LTS（长期支持）版本。

在 Linux 上安装 Rails (使用 rbenv)

使用 rbenv 是在 Linux 上管理 Ruby 版本的常用方法。

步骤 1：安装 rbenv 和 Ruby Build 插件

首先，安装用于构建 Ruby 的依赖项（命令可能因 Linux 发行版而异，此处以 Debian/Ubuntu 为例）：

$ sudo apt update
$ sudo apt install -y git curl autoconf bison build-essential libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libncurses5-dev libffi-dev libgdbm-dev libjemalloc-dev

安装 rbenv 和 ruby-build：

$ git clone https://github.com/rbenv/rbenv.git ~/.rbenv
$ echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc # Or ~/.zshrc if using Zsh
$ echo 'eval "$(rbenv init -)"' >> ~/.bashrc
$ exec $SHELL

$ git clone https://github.com/rbenv/ruby-build.git "$(rbenv root)"/plugins/ruby-build

关闭并重新打开终端或运行 exec $SHELL 以应用更改。

步骤 2：安装 Ruby

列出可用的 Ruby 版本：rbenv install -l。选择一个最近的稳定版本（例如，3.2.2）：

$ rbenv install 3.2.2 # This can take a while
$ rbenv global 3.2.2 # Sets this as the default Ruby version

验证 Ruby 安装：

$ ruby -v

禁用 gem 文档生成（可选，节省时间）：

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

步骤 3：安装 Bundler 和 Rails

$ gem install bundler
$ gem install rails
$ rbenv rehash # Important after installing gems that provide commands

步骤 4：验证 Rails 安装

$ rails -v

步骤 5：安装 Node.js

安装 Node.js。使用 NodeSource 仓库是一种常见方式：

# For Node.js LTS (e.g., version 20.x)
$ curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
$ sudo apt-get install -y nodejs

步骤 6：安装数据库（示例：PostgreSQL）

虽然 SQLite 可以直接使用，但 PostgreSQL 是一个强大的选择，适用于生产环境，也常用于开发环境。

$ sudo apt install postgresql postgresql-contrib libpq-dev
# Start and enable PostgreSQL (systemd)
$ sudo systemctl start postgresql
$ sudo systemctl enable postgresql

# Create a database user (you might need to switch to 'postgres' user first)
$ sudo -u postgres createuser --interactive --pwprompt
# Enter name of role to add: your_username
# Enter password for new role: your_password
# Make it a superuser? (y/n) y (for development ease, or grant specific privileges later)

保持 Rails 最新

要将 Rails 更新到最新版本（或您的 Gemfile 约束内的特定版本）：

# To update the Rails gem itself system-wide (or for rbenv/RVM current Ruby)
$ gem update rails

# To update Rails for a specific project (preferred):
# Edit your Gemfile to specify the desired Rails version, then run:
$ bundle update rails

安装验证

让我们创建一个新的 Rails 应用程序来验证安装：

$ rails new demo_app
$ cd demo_app
$ bin/rails server

打开您的浏览器并访问 http://localhost:3000。您应该会看到 Rails 的默认欢迎页面。

欢迎页面通常显示有关您的 Rails 和 Ruby 版本的信息，以及指南链接。这确认您的环境已正确设置。

Ruby on Rails - 框架 (Framework)

Web 框架提供了一种构建和部署 Web 应用程序的标准方式。Ruby on Rails 是一个全栈框架，通过提供结构、工具和约定来简化常见的 Web 开发任务。

开发 Rails 应用程序时，您通常会关注三个主要任务，这些任务与模型-视图-控制器（MVC）模式相吻合：

• 描述并建模应用程序的领域：这涉及定义实体（例如，用户、产品、文章）、它们的属性及其关系。这主要由 Rails 模型（Active Record）处理。
• 指定该领域中可以发生什么：定义动作和业务逻辑。例如，用户可以注册，产品可以添加到购物车，文章可以发布。这由 Rails 控制器（Action Controller）处理。
• 选择和设计该领域可公开访问的视图：确定如何向用户呈现信息以及用户如何与应用程序交互（例如，表单、列表、详情页）。这由 Rails 视图（Action View）处理。

Ruby on Rails MVC 框架

模型-视图-控制器（Model-View-Controller - MVC）模式是一种架构模式，它将应用程序分解为三个相互关联的组件，以管理复杂性并促进模块化。

模型 (Model) (Active Record)

模型（Model）代表应用程序的数据和业务逻辑。在 Rails 中，这主要由 Active Record 处理。

• 对象关系映射 (ORM)：Active Record 将数据库表映射到 Ruby 类，将行映射到对象，将列映射到对象属性。
• 数据持久化：处理从数据库保存、检索、更新和删除数据。
• 关联 (Associations)：管理不同模型之间的关系（例如，一个 User has_many Posts）。
• 验证 (Validations)：强制执行数据完整性规则（例如，电子邮件必须存在且唯一）。
• 回调 (Callbacks)：允许在对象的生命周期的不同时间点（例如，保存之前、销毁之后）执行自定义逻辑。

视图 (View) (Action View)

视图（View）负责向用户呈现数据和处理用户输入。在 Rails 中，这由 Action View 处理。

• 模板化 (Templating)：使用 ERB（Embedded Ruby）、Haml 或 Slim 等模板引擎生成 HTML（或其他格式，如 JSON、XML）。
• 助手方法 (Helpers)：提供助手方法以简化常见的视图任务，例如生成表单、链接、格式化日期和数字。
• 局部视图 (Partials)：允许可重用的视图片段在不同视图之间共享。
• 布局 (Layouts)：定义包裹单个视图的通用结构（页眉、页脚、导航）。

控制器 (Controller) (Action Controller)

控制器（Controller）充当模型和视图之间的中介。它接收来自用户（通过路由）的请求，与模型交互以获取或操作数据，然后选择一个视图来渲染响应。

• 请求处理 (Request Handling)：处理传入的 HTTP 请求（GET、POST、PATCH、DELETE 等）。
• 动作方法 (Action Methods)：控制器类中的公共方法，对应于特定的请求。
• 数据编排 (Data Orchestration)：从模型中获取数据并准备好供视图使用（通常通过实例变量，如 @user = User.find(params[:id])）。
• 会话管理 (Session Management)：处理用户会话和 cookies。
• 参数 (Parameters)：通过 params 对象访问用户提交的数据（例如，表单数据、URL 参数），使用强参数（Strong Parameters）确保安全。
• 渲染和重定向 (Rendering and Redirection)：决定是渲染视图模板还是将用户重定向到另一个 URL。

MVC 交互流程

1. 来自用户浏览器的 HTTP 请求到达 Rails 路由（Router）。
2. 路由将 URL 映射到特定的控制器动作（Controller action）。
3. 控制器动作被执行。它可能与一个或多个模型交互以检索或修改数据。
4. 模型与数据库通信。
5. 控制器动作从模型接收数据并将其提供给视图（通常通过实例变量，如 @users）。
6. 控制器然后渲染一个视图模板。
7. 视图模板（例如，一个 ERB 文件）生成一个 HTML 响应，可能使用控制器提供的数据和助手方法。
8. HTML 响应被发送回用户的浏览器。

这种关注点分离（separation of concerns）使得 Rails 应用程序更易于理解、维护和测试。每个组件都有明确的责任。

MVC 组件在 Rails 应用程序中的位置

在标准的 Rails 应用程序中，您会在 app/ 目录中找到这些组件：

• app/models/：包含您的 Active Record 模型文件（例如，user.rb，article.rb）。
• app/views/：包含每个控制器的子目录，存放各自的视图模板（例如，app/views/users/index.html.erb）。布局文件在 app/views/layouts/ 中。
• app/controllers/：包含您的 Action Controller 文件（例如，users_controller.rb，articles_controller.rb）。application_controller.rb 是所有其他控制器的基类。

核心库（Active Record、Action View、Action Controller 等）是由 Bundler 管理的 gem。如果需要，您可以检查它们的源代码，通常可以通过在项目目录中运行 bundle show <gem_name> 找到。

Ruby on Rails - 目录结构

当您使用 rails new app_name 命令创建一个新的 Rails 应用程序时，Rails 会生成一个标准化的目录结构。这种一致性是“约定优于配置”的一个关键方面，使得开发者更容易浏览和理解不同的 Rails 项目。

让我们看看典型 Rails 应用程序（例如，名为 my_app）的顶级目录结构：

$ rails new my_app
$ cd my_app
$ ls -F # Or 'dir' on Windows

您将找到以下主要的目录和文件：

• app/：应用程序的核心。它包含核心代码：模型（models）、视图（views）、控制器（controllers）、助手（helpers）、邮件程序（mailers）、作业（jobs）、频道（channels）和资产（assets）。
• • assets/：用于静态资产，如样式表（app/assets/stylesheets/）、JavaScript 文件（如果使用 Sprockets，在 app/assets/javascripts/ 中；如果使用 esbuild/Webpacker 等工具，则在 app/javascript/ 中管理）和图像（app/assets/images/）。
• • channels/：用于 Action Cable WebSocket 通信。
• • controllers/：包含控制器类。application_controller.rb 是所有其他控制器的基类。
• • helpers/：提供实用方法的助手模块，通常用于视图。application_helper.rb 是一个基类。
• • javascript/：(在现代 Rails 中更常见) 用于 JavaScript 代码，通常由 esbuild、Webpacker/Shakapacker 或 import maps 等工具管理。
• • jobs/：用于使用 Active Job 的后台作业（例如，application_job.rb）。
• • mailers/：用于处理发送电子邮件的 Action Mailer 类（例如，application_mailer.rb）。
• • models/：包含 Active Record 模型类（例如，application_record.rb 是基类）。
• • views/：存放视图模板，通常按控制器名称组织到子目录中。app/views/layouts/ 包含布局文件。
• bin/：包含应用程序的可执行脚本，例如 rails（用于运行 rails console、rails server 等 Rails 命令）、bundle（用于 Bundler）、rake（用于 Rake 任务）和 setup（用于应用程序初始设置）。
• config/：应用程序的配置文件。
• • application.rb：应用程序的主要配置。
• • database.yml：不同环境的数据库连接设置。
• • environment.rb：初始化 Rails 应用程序。
• • environments/：特定环境的配置（例如，development.rb、test.rb、production.rb）。
• • initializers/：应用程序启动时运行的 Ruby 文件，用于设置 gem 或自定义配置。
• • master.key 或 credentials.yml.enc：用于存储加密的凭据（API 密钥、秘密）。在较新版本的 Rails 中可能在 config/credentials/development.key 等文件中。
• • puma.rb：Puma Web 服务器的配置。
• • routes.rb：定义应用程序的 URL 路由。
• • storage.yml：Active Storage（文件上传）的配置。
• db/：数据库相关文件。
• • migrate/：包含定义数据库模式更改的数据库迁移（migration）文件。
• • schema.rb 或 structure.sql：表示数据库模式的当前状态。
• • seeds.rb：用于使用初始数据填充数据库的 Ruby 代码。
• lib/：不适合放在 app/ 中的自定义库模块或代码。
• • assets/：用于库特定的资产。
• • tasks/：自定义 Rake 任务。
• log/：不同环境的日志文件（例如，development.log、production.log）。
• public/：可公开访问的文件，如错误页面（404.html、500.html）、favicon.ico 和 robots.txt。这些文件由 Web 服务器直接提供服务。
• storage/：(如果使用 Active Storage 的 disk 服务) 本地存储上传文件的位置。
• test/：测试文件（默认使用 Minitest）。包括夹具（fixtures）、系统测试、集成测试、模型测试、控制器测试等的目录。
• tmp/：临时文件（缓存、pid、socket）。
• vendor/：不由 RubyGems 管理的第三方代码（现在较少见）。如果不是通过 app/javascript 或包管理器管理 JavaScript 库，有时会使用。
• .gitattributes, .gitignore：Git 配置文件。
• .ruby-version：通常由 Ruby 版本管理器（如 rbenv、RVM）用于指定项目所需的 Ruby 版本。
• Gemfile：列出应用程序的 gem 依赖，由 Bundler 管理。
• Gemfile.lock：记录所有使用的 gem 的精确版本，确保环境一致。
• package.json, yarn.lock or package-lock.json：(如果使用 Node.js 管理 JavaScript) Node.js 包管理器文件。
• Rakefile：定义应用程序的 Rake 任务。
• README.md：包含应用程序信息的 Markdown 文件。
• config.ru：由基于 Rack 的服务器（如 Puma）用于启动应用程序的 Rack 配置文件。

理解这个结构是有效使用 Rails 的基础。虽然初看起来目录可能很多，但它们清晰的用途使得 Rails 项目具有可预测性和可维护性。

Ruby on Rails - 数据库设置

在您的 Rails 应用程序能够存储和检索数据之前，您需要设置数据库并配置 Rails 连接到它。Rails 遵循为不同环境分别设置数据库的约定：development（开发）、test（测试）和 production（生产）。

对于一个名为 library_system 的项目，常规的数据库名称将是：

• library_system_development
• library_system_test
• library_system_production

您应该在您选择的数据库系统（例如 PostgreSQL、MySQL，或使用默认的 SQLite，它需要较少的手动设置）中创建这些数据库。通常还需要一个具有适当权限的数据库用户。

MySQL / MariaDB 数据库设置

1. 创建数据库： 连接到您的 MySQL 服务器（例如，使用 mysql 命令行客户端）。

mysql> CREATE DATABASE library_system_development CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
Query OK, 1 row affected (0.01 sec)

mysql> CREATE DATABASE library_system_test CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
Query OK, 1 row affected (0.00 sec)

mysql> CREATE DATABASE library_system_production CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
Query OK, 1 row affected (0.00 sec)

2. 创建用户并授予权限（将 'your_user' 和 'your_password' 替换为安全的凭据）：

mysql> CREATE USER 'library_user'@'localhost' IDENTIFIED BY 'secure_password';
Query OK, 0 rows affected (0.00 sec)

mysql> GRANT ALL PRIVILEGES ON library_system_development.* TO 'library_user'@'localhost';
mysql> GRANT ALL PRIVILEGES ON library_system_test.* TO 'library_user'@'localhost';
mysql> GRANT ALL PRIVILEGES ON library_system_production.* TO 'library_user'@'localhost';
Query OK, 0 rows affected (0.00 sec)

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

配置 MySQL 的 database.yml

编辑 Rails 应用程序中的 config/database.yml 文件。更新 MySQL 部分：

default: &default
  adapter: mysql2
  encoding: utf8mb4
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  username: library_user
  password: <%= ENV['LIBRARY_DATABASE_PASSWORD'] || 'secure_password' %> # Use ENV var in production
  host: localhost
  # socket: /tmp/mysql.sock # Optional, if not using default socket

development:
  <<: *default
  database: library_system_development

test:
  <<: *default
  database: library_system_test

production:
  <<: *default
  database: library_system_production
  username: prod_library_user # Potentially different user/pass for production
  password: <%= ENV['LIBRARY_PROD_DATABASE_PASSWORD'] %>

重要提示：对于密码，特别是在生产环境中，请使用环境变量（例如，ENV['LIBRARY_DATABASE_PASSWORD']）而不是硬编码。也可以使用 Rails 凭据。

PostgreSQL 数据库设置

1. 创建用户（如果不存在）： 连接到 PostgreSQL（例如，psql postgres），或从命令行使用 createuser。

$ sudo -u postgres createuser --interactive --pwprompt
# Enter name of role to add: library_user
# Enter password for new role: secure_password
# Shall the new role be a superuser? (y/n) n (unless necessary)
# Shall the new role be allowed to create databases? (y/n) y
# Shall the new role be allowed to create more new roles? (y/n) n

2. 创建数据库：

$ sudo -u postgres createdb -O library_user library_system_development
$ sudo -u postgres createdb -O library_user library_system_test
$ sudo -u postgres createdb -O library_user library_system_production

或者，在 psql 中作为 postgres 用户或其他超级用户运行：

CREATE DATABASE library_system_development OWNER library_user;
CREATE DATABASE library_system_test OWNER library_user;
CREATE DATABASE library_system_production OWNER library_user;

配置 PostgreSQL 的 database.yml

编辑 config/database.yml 文件：

default: &default
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  username: library_user
  password: <%= ENV['LIBRARY_DATABASE_PASSWORD'] || 'secure_password' %> # Use ENV var in production
  host: localhost
  # port: 5432 # Optional, if not default

development:
  <<: *default
  database: library_system_development

test:
  <<: *default
  database: library_system_test

production:
  <<: *default
  database: library_system_production
  username: prod_library_user # Potentially different user/pass for production
  password: <%= ENV['LIBRARY_PROD_DATABASE_PASSWORD'] %>

使用 SQLite（默认）

如果您使用的是 SQLite（创建新 Rails 应用程序时未指定 -d 选项时的默认数据库），设置会更简单，因为 SQLite 数据库只是文件。Rails 通常会在需要时自动创建这些文件（例如，运行迁移时），例如 db/development.sqlite3。

SQLite 的默认 config/database.yml 如下所示：

default: &default
  adapter: sqlite3
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  timeout: 5000

development:
  <<: *default
  database: storage/development.sqlite3 # Or db/development.sqlite3 in older Rails

test:
  <<: *default
  database: storage/test.sqlite3 # Or db/test.sqlite3

production:
  <<: *default
  database: storage/production.sqlite3 # Or db/production.sqlite3

使用 Rails 命令创建数据库

配置好 config/database.yml（对于 PostgreSQL/MySQL）后，您通常可以使用 Rails 命令来创建数据库（如果您的数据库用户有权限）：

$ bin/rails db:create  # Creates development and test databases
$ bin/rails db:create RAILS_ENV=production # Creates production database (use with caution)

此命令会读取 database.yml 并尝试创建数据库。对于 SQLite，通常不需要此命令，因为文件是按需创建的。

下一步是什么？

配置好数据库后，下一步是使用 Active Record 模型定义应用程序的数据结构，然后使用迁移（migrations）创建或修改数据库模式（schema）。