Shikong/trpl-zh-cn
1
0
Fork 0
mirror of https://github.com/KaiserY/trpl-zh-cn synced 2024-11-13 03:21:20 +08:00
Code Issues Packages Projects Releases Wiki Activity
4f7fea54c7
trpl-zh-cn/docs/ch17-03-oo-design-patterns.html
KaiserY 9923b5ae37 update ch18-01
2017-05-31 23:48:57 +08:00

473 lines
42 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!DOCTYPE HTML>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>面向对象设计模式的实现 - Rust 程序设计语言 简体中文版</title>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type">
<meta name="description" content="Rust 程序设计语言 简体中文版">
<meta name="viewport" content="width=device-width, initial-scale=1">
<base href="">
<link rel="stylesheet" href="book.css">
<link href='https://fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel='stylesheet' type='text/css'>
<link rel="shortcut icon" href="favicon.png">
<!-- Font Awesome -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css">
<link rel="stylesheet" href="highlight.css">
<link rel="stylesheet" href="tomorrow-night.css">
<!-- MathJax -->
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<!-- Fetch JQuery from CDN but have a local fallback -->
<script src="https://code.jquery.com/jquery-2.1.4.min.js"></script>
<script>
if (typeof jQuery == 'undefined') {
document.write(unescape("%3Cscript src='jquery.js'%3E%3C/script%3E"));
}
</script>
</head>
<body class="light">
<!-- Set the theme before any content is loaded, prevents flash -->
<script type="text/javascript">
var theme = localStorage.getItem('theme');
if (theme == null) { theme = 'light'; }
$('body').removeClass().addClass(theme);
</script>
<!-- Hide / unhide sidebar before it is displayed -->
<script type="text/javascript">
var sidebar = localStorage.getItem('sidebar');
if (sidebar === "hidden") { $("html").addClass("sidebar-hidden") }
else if (sidebar === "visible") { $("html").addClass("sidebar-visible") }
</script>
<div id="sidebar" class="sidebar">
<ul class="chapter"><li><a href="ch01-00-introduction.html"><strong>1.</strong> 介绍</a></li><li><ul class="section"><li><a href="ch01-01-installation.html"><strong>1.1.</strong> 安装</a></li><li><a href="ch01-02-hello-world.html"><strong>1.2.</strong> Hello, World!</a></li></ul></li><li><a href="ch02-00-guessing-game-tutorial.html"><strong>2.</strong> 猜猜看教程</a></li><li><a href="ch03-00-common-programming-concepts.html"><strong>3.</strong> 通用编程概念</a></li><li><ul class="section"><li><a href="ch03-01-variables-and-mutability.html"><strong>3.1.</strong> 变量和可变性</a></li><li><a href="ch03-02-data-types.html"><strong>3.2.</strong> 数据类型</a></li><li><a href="ch03-03-how-functions-work.html"><strong>3.3.</strong> 函数如何工作</a></li><li><a href="ch03-04-comments.html"><strong>3.4.</strong> 注释</a></li><li><a href="ch03-05-control-flow.html"><strong>3.5.</strong> 控制流</a></li></ul></li><li><a href="ch04-00-understanding-ownership.html"><strong>4.</strong> 认识所有权</a></li><li><ul class="section"><li><a href="ch04-01-what-is-ownership.html"><strong>4.1.</strong> 什么是所有权</a></li><li><a href="ch04-02-references-and-borrowing.html"><strong>4.2.</strong> 引用 &amp; 借用</a></li><li><a href="ch04-03-slices.html"><strong>4.3.</strong> Slices</a></li></ul></li><li><a href="ch05-00-structs.html"><strong>5.</strong> 结构体</a></li><li><ul class="section"><li><a href="ch05-01-method-syntax.html"><strong>5.1.</strong> 方法语法</a></li></ul></li><li><a href="ch06-00-enums.html"><strong>6.</strong> 枚举和模式匹配</a></li><li><ul class="section"><li><a href="ch06-01-defining-an-enum.html"><strong>6.1.</strong> 定义枚举</a></li><li><a href="ch06-02-match.html"><strong>6.2.</strong> <code>match</code>控制流运算符</a></li><li><a href="ch06-03-if-let.html"><strong>6.3.</strong> <code>if let</code>简单控制流</a></li></ul></li><li><a href="ch07-00-modules.html"><strong>7.</strong> 模块</a></li><li><ul class="section"><li><a href="ch07-01-mod-and-the-filesystem.html"><strong>7.1.</strong> <code>mod</code>和文件系统</a></li><li><a href="ch07-02-controlling-visibility-with-pub.html"><strong>7.2.</strong> 使用<code>pub</code>控制可见性</a></li><li><a href="ch07-03-importing-names-with-use.html"><strong>7.3.</strong> 使用<code>use</code>导入命名</a></li></ul></li><li><a href="ch08-00-common-collections.html"><strong>8.</strong> 通用集合类型</a></li><li><ul class="section"><li><a href="ch08-01-vectors.html"><strong>8.1.</strong> vector</a></li><li><a href="ch08-02-strings.html"><strong>8.2.</strong> 字符串</a></li><li><a href="ch08-03-hash-maps.html"><strong>8.3.</strong> 哈希 map</a></li></ul></li><li><a href="ch09-00-error-handling.html"><strong>9.</strong> 错误处理</a></li><li><ul class="section"><li><a href="ch09-01-unrecoverable-errors-with-panic.html"><strong>9.1.</strong> <code>panic!</code>与不可恢复的错误</a></li><li><a href="ch09-02-recoverable-errors-with-result.html"><strong>9.2.</strong> <code>Result</code>与可恢复的错误</a></li><li><a href="ch09-03-to-panic-or-not-to-panic.html"><strong>9.3.</strong> <code>panic!</code>还是不<code>panic!</code></a></li></ul></li><li><a href="ch10-00-generics.html"><strong>10.</strong> 泛型、trait 和生命周期</a></li><li><ul class="section"><li><a href="ch10-01-syntax.html"><strong>10.1.</strong> 泛型数据类型</a></li><li><a href="ch10-02-traits.html"><strong>10.2.</strong> trait：定义共享的行为</a></li><li><a href="ch10-03-lifetime-syntax.html"><strong>10.3.</strong> 生命周期与引用有效性</a></li></ul></li><li><a href="ch11-00-testing.html"><strong>11.</strong> 测试</a></li><li><ul class="section"><li><a href="ch11-01-writing-tests.html"><strong>11.1.</strong> 编写测试</a></li><li><a href="ch11-02-running-tests.html"><strong>11.2.</strong> 运行测试</a></li><li><a href="ch11-03-test-organization.html"><strong>11.3.</strong> 测试的组织结构</a></li></ul></li><li><a href="ch12-00-an-io-project.html"><strong>12.</strong> 一个 I/O 项目</a></li><li><ul class="section"><li><a href="ch12-01-accepting-command-line-arguments.html"><strong>12.1.</strong> 接受命令行参数</a></li><li><a href="ch12-02-reading-a-file.html"><strong>12.2.</strong> 读取文件</a></li><li><a href="ch12-03-improving-error-handling-and-modularity.html"><strong>12.3.</strong> 增强错误处理和模块化</a></li><li><a href="ch12-04-testing-the-librarys-functionality.html"><strong>12.4.</strong> 测试库的功能</a></li><li><a href="ch12-05-working-with-environment-variables.html"><strong>12.5.</strong> 处理环境变量</a></li><li><a href="ch12-06-writing-to-stderr-instead-of-stdout.html"><strong>12.6.</strong> 输出到<code>stderr</code>而不是<code>stdout</code></a></li></ul></li><li><a href="ch13-00-functional-features.html"><strong>13.</strong> Rust 中的函数式语言功能</a></li><li><ul class="section"><li><a href="ch13-01-closures.html"><strong>13.1.</strong> 闭包</a></li><li><a href="ch13-02-iterators.html"><strong>13.2.</strong> 迭代器</a></li><li><a href="ch13-03-improving-our-io-project.html"><strong>13.3.</strong> 改进 I/O 项目</a></li><li><a href="ch13-04-performance.html"><strong>13.4.</strong> 性能</a></li></ul></li><li><a href="ch14-00-more-about-cargo.html"><strong>14.</strong> 更多关于 Cargo 和 Crates.io</a></li><li><ul class="section"><li><a href="ch14-01-release-profiles.html"><strong>14.1.</strong> 发布配置</a></li><li><a href="ch14-02-publishing-to-crates-io.html"><strong>14.2.</strong> 将 crate 发布到 Crates.io</a></li><li><a href="ch14-03-cargo-workspaces.html"><strong>14.3.</strong> Cargo 工作空间</a></li><li><a href="ch14-04-installing-binaries.html"><strong>14.4.</strong> 使用<code>cargo install</code>从 Crates.io 安装文件</a></li><li><a href="ch14-05-extending-cargo.html"><strong>14.5.</strong> Cargo 自定义扩展命令</a></li></ul></li><li><a href="ch15-00-smart-pointers.html"><strong>15.</strong> 智能指针</a></li><li><ul class="section"><li><a href="ch15-01-box.html"><strong>15.1.</strong> <code>Box&lt;T&gt;</code>用于已知大小的堆上数据</a></li><li><a href="ch15-02-deref.html"><strong>15.2.</strong> <code>Deref</code> Trait 允许通过引用访问数据</a></li><li><a href="ch15-03-drop.html"><strong>15.3.</strong> <code>Drop</code> Trait 运行清理代码</a></li><li><a href="ch15-04-rc.html"><strong>15.4.</strong> <code>Rc&lt;T&gt;</code> 引用计数智能指针</a></li><li><a href="ch15-05-interior-mutability.html"><strong>15.5.</strong> <code>RefCell&lt;T&gt;</code>和内部可变性模式</a></li><li><a href="ch15-06-reference-cycles.html"><strong>15.6.</strong> 引用循环和内存泄漏是安全的</a></li></ul></li><li><a href="ch16-00-concurrency.html"><strong>16.</strong> 无畏并发</a></li><li><ul class="section"><li><a href="ch16-01-threads.html"><strong>16.1.</strong> 线程</a></li><li><a href="ch16-02-message-passing.html"><strong>16.2.</strong> 消息传递</a></li><li><a href="ch16-03-shared-state.html"><strong>16.3.</strong> 共享状态</a></li><li><a href="ch16-04-extensible-concurrency-sync-and-send.html"><strong>16.4.</strong> 可扩展的并发：<code>Sync</code>和<code>Send</code></a></li></ul></li><li><a href="ch17-00-oop.html"><strong>17.</strong> 面向对象</a></li><li><ul class="section"><li><a href="ch17-01-what-is-oo.html"><strong>17.1.</strong> 什么是面向对象？</a></li><li><a href="ch17-02-trait-objects.html"><strong>17.2.</strong> 为使用不同类型的值而设计的 trait 对象</a></li><li><a href="ch17-03-oo-design-patterns.html" class="active"><strong>17.3.</strong> 面向对象设计模式的实现</a></li></ul></li><li><a href="ch18-00-patterns.html"><strong>18.</strong> 模式用来匹配值的结构</a></li><li><ul class="section"><li><a href="ch18-01-all-the-places-for-patterns.html"><strong>18.1.</strong> 所有可能会用到模式的位置</a></li><li><a href="ch18-02-refutability.html"><strong>18.2.</strong> refutable：何时模式可能会匹配失败</a></li><li><a href="ch18-03-pattern-syntax.html"><strong>18.3.</strong> 模式的全部语法</a></li></ul></li></ul>
</div>
<div id="page-wrapper" class="page-wrapper">
<div class="page">
<div id="menu-bar" class="menu-bar">
<div class="left-buttons">
<i id="sidebar-toggle" class="fa fa-bars"></i>
<i id="theme-toggle" class="fa fa-paint-brush"></i>
</div>
<h1 class="menu-title">Rust 程序设计语言 简体中文版</h1>
<div class="right-buttons">
<i id="print-button" class="fa fa-print" title="Print this book"></i>
</div>
</div>
<div id="content" class="content">
<a class="header" href="#面向对象设计模式的实现" name="面向对象设计模式的实现"><h2>面向对象设计模式的实现</h2></a>
<blockquote>
<p><a href="https://github.com/rust-lang/book/blob/master/second-edition/src/ch17-03-oo-design-patterns.md">ch17-03-oo-design-patterns.md</a>
<br>
commit 67737ff868e3347588cc832eceb8fc237afc5895</p>
</blockquote>
<p>让我们看看一个状态设计模式的例子以及如何在 Rust 中使用他们。<strong>状态模式</strong>（<em>state pattern</em>）是指一个值有某些内部状态，而它的行为随着其内部状态而改变。内部状态由一系列继承了共享功能的对象表现（我们使用结构体和 trait 因为 Rust 没有对象和继承）。每一个状态对象负责它自身的行为和当需要改变为另一个状态时的规则。持有任何一个这种状态对象的值对于不同状态的行为以及何时状态转移毫不知情。当将来需求改变时，无需改变值持有状态或者使用值的代码。我们只需更新某个状态对象中的代码来改变它的规则，或者是增加更多的状态对象。</p>
<p>为了探索这个概念，我们将实现一个增量式的发布博文的工作流。这个我们希望发布博文时所应遵守的工作流，一旦完成了它的实现，将为如下：</p>
<ol>
<li>博文从空白的草案开始。</li>
<li>一旦草案完成，请求审核博文。</li>
<li>一旦博文过审，它将被发表。</li>
<li>只有被发表的博文的内容会被打印，这样就不会意外打印出没有被审核的博文的文本。</li>
</ol>
<p>任何其他对博文的修改尝试都是没有作用的。例如，如果尝试在请求审核之前通过一个草案博文，博文应该保持未发布的状态。</p>
<p>列表 17-11 展示这个工作流的代码形式。这是一个我们将要在一个叫做 <code>blog</code> 的库 crate 中实现的 API 的使用示例：</p>
<p><span class="filename">文件名: src/main.rs</span></p>
<pre><code class="language-rust,ignore">extern crate blog;
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text(&quot;I ate a salad for lunch today&quot;);
assert_eq!(&quot;&quot;, post.content());
post.request_review();
assert_eq!(&quot;&quot;, post.content());
post.approve();
assert_eq!(&quot;I ate a salad for lunch today&quot;, post.content());
}
</code></pre>
<p><span class="caption">列表 17-11: 展示了 <code>blog</code> crate 期望行为的代码</span></p>
<p>我们希望能够使用 <code>Post::new</code> 创建一个新的博文草案。接着希望能在草案阶段为博文编写一些文本。如果尝试立即打印出博文的内容，将不会得到任何文本，因为博文仍然是草案。这里增加的 <code>assert_eq!</code> 用于展示目的。断言草案博文的 <code>content</code> 方法返回空字符串将能作为库的一个非常好的单元测试，不过我们并不准备为这个例子编写单元测试。</p>
<p>接下来，我们希望能够请求审核博文，而在等待审核的阶段 <code>content</code> 应该仍然返回空字符串，当博文审核通过，它应该被发表，这意味着当调用 <code>content</code> 时我们编写的文本将被返回。</p>
<p>注意我们与 crate 交互的唯一的类型是 <code>Post</code>。博文可能处于的多种状态（草案，等待审核和发布）由 <code>Post</code> 内部管理。博文状态依我们在<code>Post</code>调用的方法而改变，但不必直接管理状态改变。这也意味着不会在状态上犯错，比如忘记了在发布前请求审核。</p>
<a class="header" href="#定义-post-并新建一个草案状态的实例" name="定义-post-并新建一个草案状态的实例"><h3>定义 <code>Post</code> 并新建一个草案状态的实例</h3></a>
<p>让我们开始实现这个库吧！我们知道需要一个公有 <code>Post</code> 结构体来存放一些文本，所以让我们从结构体的定义和一个创建 <code>Post</code> 实例的公有关联函数 <code>new</code> 开始，如列表 17-12 所示。我们还需定义一个私有 trait <code>State</code>。<code>Post</code> 将在私有字段 <code>state</code> 中存放一个 <code>Option</code> 中的 trait 对象 <code>Box&lt;State&gt;</code>。稍后将会看到为何 <code>Option</code> 是必须的。<code>State</code> trait 定义了所有不同状态的博文所共享的行为，同时 <code>Draft</code>、<code>PendingReview</code> 和 <code>Published</code> 状态都会实现<code>State</code> 状态。现在这个 trait 并没有任何方法，同时开始将只定义<code>Draft</code>状态因为这是我们希望开始的状态：</p>
<p><span class="filename">文件名: src/lib.rs</span></p>
<pre><code class="language-rust">pub struct Post {
state: Option&lt;Box&lt;State&gt;&gt;,
content: String,
}
impl Post {
pub fn new() -&gt; Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
}
trait State {}
struct Draft {}
impl State for Draft {}
</code></pre>
<p><span class="caption">列表 17-12: <code>Post</code>结构体的定义和新建 <code>Post</code> 实例的 <code>new</code>函数，<code>State</code> trait 和实现了 <code>State</code> 的结构体 <code>Draft</code></span></p>
<p>当创建新的 <code>Post</code> 时，我们将其 <code>state</code> 字段设置为一个 <code>Some</code> 值，它存放了指向一个 <code>Draft</code> 结构体新实例的 <code>Box</code>。这确保了无论何时新建一个 <code>Post</code> 实例，它会从草案开始。因为 <code>Post</code> 的 <code>state</code> 字段是私有的，也就无法创建任何其他状态的 <code>Post</code> 了！。</p>
<a class="header" href="#存放博文内容的文本" name="存放博文内容的文本"><h3>存放博文内容的文本</h3></a>
<p>在 <code>Post::new</code> 函数中，我们设置 <code>content</code> 字段为新的空 <code>String</code>。在列表 17-11 中，展示了我们希望能够调用一个叫做 <code>add_text</code> 的方法并向其传递一个 <code>&amp;str</code> 来将文本增加到博文的内容中。选择实现为一个方法而不是将 <code>content</code> 字段暴露为 <code>pub</code> 是因为我们希望能够通过之后实现的一个方法来控制 <code>content</code> 字段如何被读取。<code>add_text</code> 方法是非常直观的，让我们在列表 17-13 的 <code>impl Post</code> 块中增加一个实现：</p>
<p><span class="filename">文件名: src/lib.rs</span></p>
<pre><code class="language-rust"># pub struct Post {
# content: String,
# }
#
impl Post {
// ...snip...
pub fn add_text(&amp;mut self, text: &amp;str) {
self.content.push_str(text);
}
}
</code></pre>
<p><span class="caption">列表 17-13: 实现方法 <code>add_text</code> 来向博文的 <code>content</code> 增加文本</span></p>
<p><code>add_text</code> 获取一个 <code>self</code> 的可变引用，因为需要改变调用 <code>add_text</code> 的 <code>Post</code>。接着调用 <code>content</code> 中的 <code>String</code> 的 <code>push_str</code> 并传递 <code>text</code> 参数来保存到 <code>content</code> 中。这不是状态模式的一部分，因为它的行为并不依赖博文所处的状态。<code>add_text</code> 方法完全不与 <code>state</code> 状态交互，不过这是我们希望支持的行为的一部分。</p>
<a class="header" href="#博文草案的内容是空的" name="博文草案的内容是空的"><h3>博文草案的内容是空的</h3></a>
<p>调用 <code>add_text</code> 并像博文增加一些内容之后，我们仍然希望 <code>content</code> 方法返回一个空字符串 slice，因为博文仍然处于草案状态，如列表 17-11 的第 8 行所示。现在让我们使用能满足要求的最简单的方式来实现 <code>content</code> 方法 总是返回一个空字符 slice。当实现了将博文状态改为发布的能力之后将改变这一做法。但是现在博文只能是草案状态，这意味着其内容总是空的。列表 17-14 展示了这个占位符实现：</p>
<p><span class="filename">文件名: src/lib.rs</span></p>
<pre><code class="language-rust"># pub struct Post {
# content: String,
# }
#
impl Post {
// ...snip...
pub fn content(&amp;self) -&gt; &amp;str {
&quot;&quot;
}
}
</code></pre>
<p><span class="caption">列表 17-14: 增加一个 <code>Post</code> 的 <code>content</code> 方法的占位实现，它总是返回一个空字符串 slice</span></p>
<p>通过增加这个 <code>content</code>方法，列表 17-11 中直到第 8 行的代码能如期运行。</p>
<a class="header" href="#请求审核博文来改变其状态" name="请求审核博文来改变其状态"><h3>请求审核博文来改变其状态</h3></a>
<p>接下来是请求审核博文，这应当将其状态由 <code>Draft</code> 改为 <code>PendingReview</code>。我们希望 <code>post</code> 有一个获取 <code>self</code> 可变引用的公有方法 <code>request_review</code>。接着将调用内部存放的状态的 <code>request_review</code> 方法，而这第二个 <code>request_review</code> 方法会消费当前的状态并返回要一个状态。为了能够消费旧状态，第二个 <code>request_review</code> 方法需要能够获取状态值的所有权。这就是 <code>Option</code> 的作用：我们将 <code>take</code> 字段 <code>state</code> 中的 <code>Some</code> 值并留下一个 <code>None</code> 值，因为 Rust 并不允许结构体中有空字段。接着将博文的 <code>state</code> 设置为这个操作的结果。列表 17-15 展示了这些代码：</p>
<p><span class="filename">文件名: src/lib.rs</span></p>
<pre><code class="language-rust"># pub struct Post {
# state: Option&lt;Box&lt;State&gt;&gt;,
# content: String,
# }
#
impl Post {
// ...snip...
pub fn request_review(&amp;mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
}
trait State {
fn request_review(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt;;
}
struct Draft {}
impl State for Draft {
fn request_review(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt; {
Box::new(PendingReview {})
}
}
struct PendingReview {}
impl State for PendingReview {
fn request_review(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt; {
self
}
}
</code></pre>
<p><span class="caption">列表 17-15: 实现 <code>Post</code> 和 <code>State</code> trait 的 <code>request_review</code> 方法</span></p>
<p>这里给 <code>State</code> trait 增加了 <code>request_review</code> 方法；所有实现了这个 trait 的类型现在都需要实现 <code>request_review</code> 方法。注意不用于使用<code>self</code>、 <code>&amp;self</code> 或者 <code>&amp;mut self</code> 作为方法的第一个参数，这里使用了 <code>self: Box&lt;Self&gt;</code>。这个语法意味着这个方法调用只对这个类型的 <code>Box</code> 有效。这个语法获取了 <code>Box&lt;Self&gt;</code> 的所有权，这是我们希望的，因为需要从老状态转换为新状态，同时希望老状态不再有效。</p>
<p><code>Draft</code> 的方法 <code>request_review</code> 的实现返回一个新的，装箱的 <code>PendingReview</code> 结构体的实例，这是新引入的用来代表博文处于等待审核状态的类型。结构体 <code>PendingReview</code> 同样也实现了 <code>request_review</code> 方法，不过它不进行任何状态转换。它返回自身，因为请求审核已经处于 <code>PendingReview</code> 状态的博文应该保持 <code>PendingReview</code> 状态。</p>
<p>现在能够看出状态模式的优势了：<code>Post</code> 的 <code>request_review</code> 方法无论 <code>state</code> 是何值都是一样的。每个状态负责它自己的规则。</p>
<p>我们将继续保持 <code>Post</code> 的 <code>content</code> 方法不变，返回一个空字符串 slice。现在可以拥有 <code>PendingReview</code> 状态而不仅仅是 <code>Draft</code> 状态的 <code>Post</code> 了，不过我们希望在 <code>PendingReview</code> 状态下其也有相同的行为。现在列表 17-11 中直到 11 行的代码是可以执行的！</p>
<a class="header" href="#批准博文并改变-content-的行为" name="批准博文并改变-content-的行为"><h3>批准博文并改变 <code>content</code> 的行为</h3></a>
<p><code>Post</code> 的 <code>approve</code> 方法将与 <code>request_review</code> 方法类似：它会将 <code>state</code> 设置为审核通过时应处于的状态。我们需要为 <code>State</code> trait 增加 <code>approve</code> 方法，并需新增实现了 <code>State</code> 的结构体， <code>Published</code> 状态。列表 17-16 展示了新增的代码：</p>
<p><span class="filename">文件名: src/lib.rs</span></p>
<pre><code class="language-rust"># pub struct Post {
# state: Option&lt;Box&lt;State&gt;&gt;,
# content: String,
# }
#
impl Post {
// ...snip...
pub fn approve(&amp;mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
trait State {
fn request_review(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt;;
fn approve(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt;;
}
struct Draft {}
impl State for Draft {
# fn request_review(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt; {
# Box::new(PendingReview {})
# }
#
// ...snip...
fn approve(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt; {
self
}
}
struct PendingReview {}
impl State for PendingReview {
# fn request_review(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt; {
# Box::new(PendingReview {})
# }
#
// ...snip...
fn approve(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt; {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
fn request_review(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt; {
self
}
fn approve(self: Box&lt;Self&gt;) -&gt; Box&lt;State&gt; {
self
}
}
</code></pre>
<p><span class="caption">列表 17-16: 为 <code>Post</code> 和 <code>State</code> trait 实现 <code>approve</code> 方法</span></p>
<p>类似于 <code>request_review</code>，如果对 <code>Draft</code> 调用 <code>approve</code> 方法，并没有任何效果，因为它会返回 <code>self</code>。当对 <code>PendingReview</code> 调用 <code>approve</code> 时，它返回一个新的、装箱的 <code>Published</code> 结构体的实例。<code>Published</code> 结构体实现了 <code>State</code> trait，同时对于 <code>request_review</code> 和 <code>approve</code> 方法来说，它返回自身，因为在这两种情况博文应该保持 <code>Published</code> 状态。</p>
<p>现在更新 <code>Post</code> 的 <code>content</code> 方法：我们希望当博文处于 <code>Published</code> 时返回 <code>content</code> 字段的值，否则返回空字符串 slice。因为目标是将所有像这样的规则保持在实现了 <code>State</code> 的结构体中，我们将调用 <code>state</code> 中的值的 <code>content</code> 方法并传递博文实例（也就是 <code>self</code>）作为参数。接着返回 <code>state</code> 值的 <code>content</code> 方法的返回值，如列表 17-17 所示：</p>
<p><span class="filename">文件名: src/lib.rs</span></p>
<pre><code class="language-rust"># trait State {
# fn content&lt;'a&gt;(&amp;self, post: &amp;'a Post) -&gt; &amp;'a str;
# }
# pub struct Post {
# state: Option&lt;Box&lt;State&gt;&gt;,
# content: String,
# }
#
impl Post {
// ...snip...
pub fn content(&amp;self) -&gt; &amp;str {
self.state.as_ref().unwrap().content(&amp;self)
}
// ...snip...
}
</code></pre>
<p><span class="caption">列表 17-17: 更新 <code>Post</code> 的 <code>content</code> 方法来委托调用 <code>State</code> 的<code>content</code> 方法</span></p>
<p>这里调用 <code>Option</code> 的 <code>as_ref</code>方法是因为需要 <code>Option</code> 中值的引用。接着调用 <code>unwrap</code> 方法，这里我们知道永远也不会 panic 因为 <code>Post</code> 的所有方法都确保在他们返回时 <code>state</code> 会有一个 <code>Some</code> 值。这就是一个第十二章讨论过的我们知道 <code>None</code> 是不可能的而编译器却不能理解的情况。</p>
<p><code>State</code> trait 的 <code>content</code> 方法是博文返回什么内容的逻辑所在之处。我们将增加一个 <code>content</code> 方法的默认实现来返回一个空字符串 slice。这样就无需为 <code>Draft</code> 和 <code>PendingReview</code> 结构体实现 <code>content</code> 了。<code>Published</code> 结构体会覆盖 <code>content</code> 方法并会返回 <code>post.content</code> 的值，如列表 17-18 所示：</p>
<p><span class="filename">文件名: src/lib.rs</span></p>
<pre><code class="language-rust"># pub struct Post {
# content: String
# }
trait State {
// ...snip...
fn content&lt;'a&gt;(&amp;self, post: &amp;'a Post) -&gt; &amp;'a str {
&quot;&quot;
}
}
// ...snip...
struct Published {}
impl State for Published {
// ...snip...
fn content&lt;'a&gt;(&amp;self, post: &amp;'a Post) -&gt; &amp;'a str {
&amp;post.content
}
}
</code></pre>
<p><span class="caption">列表 17-18: 为 <code>State</code> trait 增加 <code>content</code> 方法</span></p>
<p>注意这个方法需要生命周期注解，如第十章所讨论的。这里获取 <code>post</code> 的引用作为参数，并返回 <code>post</code> 一部分的引用，所以返回的引用的生命周期与 <code>post</code> 参数相关。</p>
<a class="header" href="#状态模式的权衡取舍" name="状态模式的权衡取舍"><h3>状态模式的权衡取舍</h3></a>
<p>我们展示了 Rust 是能够实现面向对象的状态模式的，以便能根据博文所处的状态来封装不同类型的行为。<code>Post</code> 的方法并不知道这些不同类型的行为。这种组织代码的方式，为了找到所有已发布的博文不同行为只需查看一处代码：<code>Published</code> 的 <code>State</code> trait 的实现。</p>
<p>一个不使用状态模式的替代实现可能会在 <code>Post</code> 的方法中，甚至于在使用 <code>Post</code> 的代码中（在这里是 <code>main</code> 中）用到 <code>match</code> 语句，来检查博文状态并在这里改变其行为。这可能意味着需要查看很多位置来理解处于发布状态的博文的所有逻辑！这在增加更多状态时会变得更糟：每一个 <code>match</code> 语句都会需要另一个分支。对于状态模式来说，<code>Post</code> 的方法和使用 <code>Post</code> 的位置无需<code>match</code> 语句，同时增加新状态只涉及到增加一个新 <code>struct</code> 和为其实现 trait 的方法。</p>
<p>这个实现易于增加更多功能。这里是一些你可以尝试对本部分代码做出的修改，来亲自体会一下使用状态模式随着时间的推移维护代码是什么感觉：</p>
<ul>
<li>只允许博文处于 <code>Draft</code> 状态时增加文本内容</li>
<li>增加 <code>reject</code> 方法将博文的状态从 <code>PendingReview</code> 变回 <code>Draft</code></li>
<li>在将状态变为 <code>Published</code> 之前需要两次 <code>approve</code> 调用</li>
</ul>
<p>状态模式的一个缺点是因为状态实现了状态之间的转换，一些状态会相互联系。如果在 <code>PendingReview</code> 和 <code>Published</code> 之间增加另一个状态，比如 <code>Scheduled</code>，则不得不修改 <code>PendingReview</code> 中的代码来转移到 <code>Scheduled</code>。如果 <code>PendingReview</code> 无需因为新增的状态而改变就更好了，不过这意味着切换到另一个设计模式。</p>
<p>这个 Rust 中的实现的缺点在于存在一些重复的逻辑。如果能够为 <code>State</code> trait 中返回 <code>self</code> 的 <code>request_review</code> 和 <code>approve</code> 方法增加默认实现就好了，不过这会违反对象安全性，因为 trait 不知道 <code>self</code> 具体是什么。我们希望能够将 <code>State</code> 作为一个 trait 对象，所以需要这个方法是对象安全的。</p>
<p>另一个最好能去除的重复是 <code>Post</code> 中 <code>request_review</code> 和 <code>approve</code> 这两个类似的实现。他们都委托调用了 <code>state</code> 字段中 <code>Option</code> 值的同一方法，并在结果中为 <code>state</code> 字段设置了新值。如果 <code>Post</code> 中的很多方法都遵循这个模式，我们可能会考虑定义一个宏来消除重复（查看附录 E 以了解宏）。</p>
<p>这个完全按照面向对象语言的定义实现的面向对象模式的缺点在于没有尽可能的利用 Rust 的优势。让我们看看一些代码中可以做出的修改，来将无效的状态和状态转移变为编译时错误。</p>
<a class="header" href="#将状态和行为编码为类型" name="将状态和行为编码为类型"><h4>将状态和行为编码为类型</h4></a>
<p>我们将展示如何稍微反思状态模式来进行一系列不同的权衡取舍。不同于完全封装状态和状态转移使得外部代码对其毫不知情，我们将将状态编码进不同的类型。当状态是类型时，Rust 的类型检查就会使任何在只能使用发布的博文的地方使用草案博文的尝试变为编译时错误。</p>
<p>让我们考虑一下列表 17-11 中 <code>main</code> 的第一部分：</p>
<p><span class="filename">文件名: src/main.rs</span></p>
<pre><code class="language-rust">fn main() {
let mut post = Post::new();
post.add_text(&quot;I ate a salad for lunch today&quot;);
assert_eq!(&quot;&quot;, post.content());
}
</code></pre>
<p>我们仍然希望使用 <code>Post::new</code> 创建一个新的草案博文，并仍然希望能够增加博文的内容。不过不同于存在一个草案博文时返回空字符串的 <code>content</code> 方法，我们将使草案博文完全没有 <code>content</code> 方法。这样如果尝试获取草案博文的内容，将会得到一个方法不存在的编译错误。这使得我们不可能在生产环境意外显示出草案博文的内容，因为这样的代码甚至就不能编译。列表 17-19 展示了 <code>Post</code> 结构体、<code>DraftPost</code> 结构体以及各自的方法的定义：</p>
<p><span class="filename">文件名: src/lib.rs</span></p>
<pre><code class="language-rust">pub struct Post {
content: String,
}
pub struct DraftPost {
content: String,
}
impl Post {
pub fn new() -&gt; DraftPost {
DraftPost {
content: String::new(),
}
}
pub fn content(&amp;self) -&gt; &amp;str {
&amp;self.content
}
}
impl DraftPost {
pub fn add_text(&amp;mut self, text: &amp;str) {
self.content.push_str(text);
}
}
</code></pre>
<p><span class="caption">列表 17-19: 带有 <code>content</code> 方法的 <code>Post</code> 和没有 <code>content</code> 方法的 <code>DraftPost</code></span></p>
<p><code>Post</code> 和 <code>DraftPost</code> 结构体都有一个私有的 <code>content</code> 字段来储存博文的文本。这些结构体不再有 <code>state</code> 字段因为我们将类型编码为结构体的类型。<code>Post</code> 将代表发布的博文，它有一个返回 <code>content</code> 的 <code>content</code> 方法。</p>
<p>仍然有一个 <code>Post::new</code> 函数，不过不同于返回 <code>Post</code> 实例，它返回 <code>DraftPost</code> 的实例。现在不可能创建一个 <code>Post</code> 实例，因为 <code>content</code> 是私有的同时没有任何函数返回 <code>Post</code>。<code>DraftPost</code> 上定义了一个 <code>add_text</code> 方法，这样就可以像之前那样向 <code>content</code> 增加文本，不过注意 <code>DraftPost</code> 并没有定义 <code>content</code> 方法！所以所有博文都强制从草案开始，同时草案博文没有任何可供展示的内容。任何绕过这些限制的尝试都会产生编译错误。</p>
<a class="header" href="#实现状态转移为不同类型的转移" name="实现状态转移为不同类型的转移"><h4>实现状态转移为不同类型的转移</h4></a>
<p>那么如何得到发布的博文呢？我们希望强制的规则是草案博文在可以发布之前必须被审核通过。等待审核状态的博文应该仍然不会显示任何内容。让我们通过增加另一个结构体 <code>PendingReviewPost</code> 来实现这个限制，在 <code>DraftPost</code> 上定义 <code>request_review</code> 方法来返回 <code>PendingReviewPost</code>，并在 <code>PendingReviewPost</code> 上定义 <code>approve</code> 方法来返回 <code>Post</code>，如列表 17-20 所示：</p>
<p><span class="filename">文件名: src/lib.rs</span></p>
<pre><code class="language-rust"># pub struct Post {
# content: String,
# }
#
# pub struct DraftPost {
# content: String,
# }
#
impl DraftPost {
// ...snip...
pub fn request_review(self) -&gt; PendingReviewPost {
PendingReviewPost {
content: self.content,
}
}
}
pub struct PendingReviewPost {
content: String,
}
impl PendingReviewPost {
pub fn approve(self) -&gt; Post {
Post {
content: self.content,
}
}
}
</code></pre>
<p><span class="caption">列表 17-20: <code>PendingReviewPost</code> 通过调用 <code>DraftPost</code> 的 <code>request_review</code> 创建，<code>approve</code> 方法将 <code>PendingReviewPost</code> 变为发布的 <code>Post</code></span></p>
<p><code>request_review</code> 和 <code>approve</code> 方法获取 <code>self</code> 的所有权，因此会消费 <code>DraftPost</code> 和 <code>PendingReviewPost</code> 实例，并分别转换为 <code>PendingReviewPost</code> 和 发布的 <code>Post</code>。这样在调用 <code>request_review</code> 之后就不会遗留任何 <code>DraftPost</code> 实例，后者同理。<code>PendingReviewPost</code> 并没有定义 <code>content</code> 方法，所以类似 <code>DraftPost</code> 尝试读取它的内容是一个编译错误。因为唯一得到定义了 <code>content</code> 方法的 <code>Post</code> 实例的途径是调用 <code>PendingReviewPost</code> 的 <code>approve</code> 方法，而得到 <code>PendingReviewPost</code> 的唯一办法是调用 <code>DraftPost</code> 的 <code>request_review</code> 方法，现在我们就将发博文的工作流编码进了类型系统。</p>
<p>这也意味着不得不对 <code>main</code>做出一些小的修改。因为 <code>request_review</code> 和 <code>approve</code> 返回新实例而不是修改被调用的结构体，我们需要增加更多的 <code>let post =</code> 覆盖赋值来保存返回的实例。也不能再断言草案和等待审核的博文的内容为空字符串了，我们也不再需要他们：不能编译尝试使用这些状态下博文内容的代码。更新后的 <code>main</code> 的代码如列表 18-21 所示：</p>
<p><span class="filename">Filename: src/main.rs</span></p>
<pre><code class="language-rust,ignore">extern crate blog;
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text(&quot;I ate a salad for lunch today&quot;);
let post = post.request_review();
let post = post.approve();
assert_eq!(&quot;I ate a salad for lunch today&quot;, post.content());
}
</code></pre>
<p><span class="caption">列表 17-21: <code>main</code> 中使用新的博文工作流实现的修改</span></p>
<p>不得不修改 <code>main</code> 来重新赋值 <code>post</code> 使得这个实现不再完全遵守面向对象的状态模式：状态间的转换不再完全封装在 <code>Post</code> 实现中。然而，得益于类型系统和编译时类型检查我们得到了不可能拥有无效状态的属性！这确保了特定的 bug，比如显示未发布博文的内容，将在部署到生产环境之前被发现。</p>
<p>尝试在这一部分开始所建议的增加额外需求的任务来体会使用这个版本的代码是何感觉。</p>
<p>即便 Rust 能够实现面向对象设计模式，也有其他像将状态编码进类型这样的模式存在。这些模式有着不同于面向对象模式的权衡取舍。虽然你可能非常熟悉面向对象模式，重新思考这些问题来利用 Rust 提供的像在编译时避免一些 bug 这样有益功能。在 Rust 中面向对象模式并不总是最好的解决方案，因为 Rust 拥有像所有权这样的面向对象语言所没有的功能。</p>
<a class="header" href="#总结" name="总结"><h2>总结</h2></a>
<p>阅读本章后，不管你是否认为 Rust 是一个面向对象语言，现在你都见识了 trait 对象是一个 Rust 中获取部分面向对象功能的方法。动态分发可以通过牺牲一些运行时性能来为你的代码提供一些灵活性。这些灵活性可以用来实现有助于代码可维护性的面向对象模式。Rust 也有像所有权这样不同于面向对象语言的功能。面向对象模式并不总是利用 Rust 实力的最好方式。</p>
<p>接下来，让我们看看另一个提供了很多灵活性的 Rust 功能：模式。贯穿本书我们都曾简单的见过他们，但并没有见识过他们的全部本领。让我们开始吧！</p>
</div>
<!-- Mobile navigation buttons -->
<a href="ch17-02-trait-objects.html" class="mobile-nav-chapters previous">
<i class="fa fa-angle-left"></i>
</a>
<a href="ch18-00-patterns.html" class="mobile-nav-chapters next">
<i class="fa fa-angle-right"></i>
</a>
</div>
<a href="ch17-02-trait-objects.html" class="nav-chapters previous" title="You can navigate through the chapters using the arrow keys">
<i class="fa fa-angle-left"></i>
</a>
<a href="ch18-00-patterns.html" class="nav-chapters next" title="You can navigate through the chapters using the arrow keys">
<i class="fa fa-angle-right"></i>
</a>
</div>
<!-- Local fallback for Font Awesome -->
<script>
if ($(".fa").css("font-family") !== "FontAwesome") {
$('<link rel="stylesheet" type="text/css" href="_FontAwesome/css/font-awesome.css">').prependTo('head');
}
</script>
<!-- Livereload script (if served using the cli tool) -->
<script src="highlight.js"></script>
<script src="book.js"></script>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink