Реализация объектно-ориентированного шаблона проектирования
Шаблон состояния — это объектно-ориентированный шаблон проектирования. Суть шаблона в том, что определяется набор состояний, которые значение может иметь внутри себя. Состояния представлены набором объектов состояний, и поведение значения меняется в зависимости от его состояния. Мы поработаем над примером структуры записи в блоге, у которой есть поле для хранения её состояния, которое будет объектом состояния из набора «черновик», «на рассмотрении» или «опубликовано».
Объекты состояний разделяют функциональность: в Rust, конечно, используются структуры и трейты, а не объекты и наследование. Каждый объект состояния отвечает за своё собственное поведение и за управление тем, когда он должен перейти в другое состояние. Значение, содержащее объект состояния, ничего не знает о различном поведении состояний или о том, когда переходить между состояниями.
Преимущество использования шаблона состояния состоит в том, что при изменении бизнес- требований программы не нужно менять код значения, содержащего состояние, или код, использующий это значение. Понадобится только обновить код внутри одного из объектов состояний, чтобы изменить его правила или, возможно, добавить больше объектов состояний.
Сначала реализуем шаблон состояния более традиционным объектно-ориентированным способом. Затем используем подход, который немного более естественен для Rust. Приступим к поэтапной реализации рабочего процесса записи в блог с использованием шаблона состояния.
Итоговая функциональность будет выглядеть так:
- Запись в блоге начинается как пустой черновик.
- Когда черновик готов, запрашивается рецензирование записи.
- Когда запись одобрена, она публикуется.
- Только опубликованные записи в блоге возвращают содержимое для печати, чтобы неодобренные записи не могли быть случайно опубликованы.
Любые другие изменения, предпринятые для записи, не должны иметь эффекта. Например, если попытаться одобрить черновик записи в блоге до того, как запрошено рецензирование, запись должна остаться неопубликованным черновиком.
Попытка использования традиционного объектно-ориентированного стиля
Существует бесконечное множество способов структурировать код для решения одной и той же задачи, каждый с разными компромиссами. Реализация в этом разделе — скорее традиционный объектно-ориентированный стиль, который можно написать на Rust, но который не использует некоторые сильные стороны Rust. Позже будет продемонстрировано другое решение, которое по-прежнему использует объектно-ориентированный шаблон проектирования, но структурировано так, что может показаться менее привычным программистам с объектно-ориентированным опытом. Сравним два решения, чтобы на практике ощутить компромиссы проектирования кода на Rust иначе, чем кода на других языках.
Листинг 18-11 показывает этот рабочий процесс в виде кода: это пример использования
API, который будет реализован в библиотечном крейте с именем blog. Этот код пока не будет компилироваться,
потому что крейт blog ещё не реализован.
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
assert_eq!("", post.content());
post.request_review();
assert_eq!("", post.content());
post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
blogНужно позволить пользователю создать новую черновую запись в блоге с помощью Post::new. Нужно
позволить добавлять текст к записи в блоге. Если попытаться получить содержимое записи
сразу, до одобрения, не должно быть получено никакого текста, потому что запись
всё ещё черновик. Мы добавили assert_eq! в код для демонстрационных
целей. Отличным модульным тестом для этого было бы утверждение, что черновая запись в блоге
возвращает пустую строку из метода content, но мы не собираемся
писать тесты для этого примера.
Далее нужно включить возможность запроса рецензирования записи, и нужно, чтобы
content возвращал пустую строку в ожидании рецензирования. Когда запись
получает одобрение, она должна быть опубликована, то есть текст записи будет
возвращаться при вызове content.
Обратите внимание, что единственный тип, с которым мы взаимодействуем из крейта, — это Post.
Этот тип будет использовать шаблон состояния и хранить значение, которое будет
одним из трёх объектов состояний, представляющих различные состояния, в которых может находиться запись
— черновик, на рассмотрении или опубликовано. Переход из одного состояния в другое будет
управляться внутри типа Post. Состояния меняются в ответ на
методы, вызываемые пользователями библиотеки для экземпляра Post, но им не
нужно управлять изменениями состояния напрямую. Кроме того, пользователи не могут ошибиться
с состояниями, например, опубликовать запись до её рецензирования.
Определение Post и создание нового экземпляра
Начнём реализацию библиотеки! Известно, что нужна публичная структура Post, которая хранит
некоторое содержимое, поэтому начнём с определения структуры и связанной
публичной функции new для создания экземпляра Post, как показано в листинге 18-12. Также
сделаем приватный трейт State, который будет определять поведение, которое должны иметь все объекты состояний для Post.
Затем Post будет хранить трейт-объект Box<dyn State> внутри Option<T>
в приватном поле с именем state для хранения объекта состояния. Вскоре будет показано, почему
нужен Option<T>.
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
}
trait State {}
struct Draft {}
impl State for Draft {}
Post и функции new, создающей новый экземпляр Post, трейта State и структуры DraftТрейт State определяет поведение, общее для разных состояний записи.
Объекты состояний — это Draft, PendingReview и Published, и все они будут
реализовывать трейт State. Пока трейт не имеет методов, и
начнём с определения только состояния Draft, потому что это состояние, в котором
должна начинаться запись.
При создании нового Post его поле state устанавливается в значение Some, которое
содержит Box. Этот Box указывает на новый экземпляр структуры Draft. Это
гарантирует, что при каждом создании нового экземпляра Post он будет начинаться как
черновик. Поскольку поле state у Post приватное, нет способа
создать Post в каком-либо другом состоянии! В функции Post::new поле content
устанавливается в новую пустую String.
Сохранение текста содержимого записи
В листинге 18-11 было видно, что нужно иметь возможность вызвать метод с именем
add_text и передать ему &str, который затем добавляется как текстовое содержимое
записи в блоге. Это реализуется как метод, а не как публичное поле content,
чтобы позже можно было реализовать метод, который будет управлять тем, как
читаются данные поля content. Метод add_text довольно
прост, поэтому добавим реализацию в листинге 18-13 в блок impl Post.
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
}
trait State {}
struct Draft {}
impl State for Draft {}
add_text для добавления текста в content записиМетод add_text принимает изменяемую ссылку на self, потому что
изменяется экземпляр Post, для которого вызывается add_text. Затем вызывается
push_str для String в content и передаётся аргумент text для добавления к
сохранённому content. Это поведение не зависит от состояния, в котором находится запись,
поэтому оно не является частью шаблона состояния. Метод add_text не взаимодействует
с полем state вообще, но является частью поведения, которое нужно
поддерживать.
Обеспечение пустоты содержимого черновой записи
Даже после вызова add_text и добавления некоторого содержимого в запись
по-прежнему нужно, чтобы метод content возвращал пустой срез строки, потому что запись
всё ещё находится в состоянии черновика, как показано первым assert_eq! в листинге 18-11.
Пока реализуем метод content с самым простым вариантом, который
удовлетворит это требование: всегда возвращать пустой срез строки. Это будет изменено
позже, когда будет реализована возможность изменения состояния записи, чтобы она
могла быть опубликована. Пока записи могут находиться только в состоянии черновика, поэтому содержимое записи
должно всегда быть пустым. В листинге 18-14 показана эта заполняющая
реализация.
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
""
}
}
trait State {}
struct Draft {}
impl State for Draft {}
content для Post, всегда возвращающей пустой срез строкиС этим добавленным методом content всё в листинге 18-11 до первого
assert_eq! работает как задумано.
Запрос рецензирования, изменяющий состояние записи
Далее нужно добавить функциональность для запроса рецензирования записи, которая должна
изменить её состояние с Draft на PendingReview. В листинге 18-15 показан этот код.
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
""
}
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
}
trait State {
fn request_review(self: Box<Self>) -> Box<dyn State>;
}
struct Draft {}
impl State for Draft {
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
}
struct PendingReview {}
impl State for PendingReview {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
}
request_review для Post и трейта StateУ Post появляется публичный метод с именем request_review, который принимает изменяемую
ссылку на self. Затем вызывается внутренний метод request_review для
текущего состояния Post, и этот второй метод request_review потребляет
текущее состояние и возвращает новое состояние.
Метод request_review добавляется в трейт State; все типы, реализующие трейт,
теперь должны будут реализовать метод request_review.
Обратите внимание, что в качестве первого параметра метода используется не self, &self или &mut self,
а self: Box<Self>. Этот синтаксис означает, что
метод действителен только при вызове у Box, содержащего тип. Этот синтаксис принимает
владение Box<Self>, делая недействительным старое состояние, так что значение состояния
Post может преобразоваться в новое состояние.
Чтобы потребить старое состояние, метод request_review должен принять владение
значением состояния. Здесь и пригодится Option в поле state у Post:
вызывается метод take, чтобы извлечь значение Some из поля state
и оставить на его месте None, потому что Rust не позволяет иметь
незаполненные поля в структурах. Это позволяет переместить значение state из
Post, а не заимствовать его. Затем значение state записи устанавливается в
результат этой операции.
Нужно установить state в None временно, а не устанавливать его напрямую
кодом вроде self.state = self.state.request_review();, чтобы получить владение
значением state. Это гарантирует, что Post не сможет использовать старое значение state
после того, как оно было преобразовано в новое состояние.
Метод request_review у Draft возвращает новый упакованный в Box экземпляр новой
структуры PendingReview, которая представляет состояние, когда запись ожидает
рецензирования. Структура PendingReview также реализует метод request_review,
но не выполняет никаких преобразований. Вместо этого она возвращает саму себя, потому что при
запросе рецензирования записи, уже находящейся в состоянии PendingReview, она должна остаться
в состоянии PendingReview.
Теперь можно начать видеть преимущества шаблона состояния: метод
request_review у Post одинаков независимо от значения state. Каждое
состояние отвечает за свои собственные правила.
Метод content у Post оставим как есть, возвращающим пустой срез строки.
Теперь Post может находиться в состоянии PendingReview так же, как и в
состоянии Draft, но нужно одинаковое поведение в состоянии PendingReview.
Листинг 18-11 теперь работает до второго вызова assert_eq!!
Добавление approve для изменения поведения content
Метод approve будет похож на метод request_review: он будет
устанавливать state в значение, которое текущее состояние говорит, что должно быть, когда это
состояние одобрено, как показано в листинге 18-16.
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
""
}
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
pub fn approve(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
trait State {
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
}
struct Draft {}
impl State for Draft {
// --snip--
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
struct PendingReview {}
impl State for PendingReview {
// --snip--
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
approve для Post и трейта StateМетод approve добавляется в трейт State и добавляется новая структура, реализующая
State, — состояние Published.
Подобно тому, как работает request_review у PendingReview, если вызвать метод
approve у Draft, это не будет иметь эффекта, потому что approve
вернёт self. При вызове approve у PendingReview возвращается новый
упакованный в Box экземпляр структуры Published. Структура Published реализует
трейт State, и как для метода request_review, так и для метода approve
она возвращает саму себя, потому что запись должна оставаться в состоянии Published
в этих случаях.
Теперь нужно обновить метод content у Post. Нужно, чтобы значение,
возвращаемое из content, зависело от текущего состояния Post, поэтому
Post будет делегировать вызов методу content, определённому в его state,
как показано в листинге 18-17.
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
// --snip--
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
self.state.as_ref().unwrap().content(self)
}
// --snip--
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
pub fn approve(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
trait State {
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
}
struct Draft {}
impl State for Draft {
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
struct PendingReview {}
impl State for PendingReview {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
content у Post для делегирования методу content у StateПоскольку цель — держать все эти правила внутри структур, реализующих
State, вызывается метод content у значения в state, и передаётся
экземпляр записи (то есть self) в качестве аргумента. Затем возвращается значение,
возвращённое из использования метода content у значения state.
Метод as_ref вызывается у Option, потому что нужна ссылка на
значение внутри Option, а не владение значением. Поскольку state —
это Option<Box<dyn State>>, при вызове as_ref возвращается Option<&Box<dyn State>>. Если бы
as_ref не вызывался, была бы получена ошибка, потому что нельзя переместить
state из заимствованного &self параметра функции.
Затем вызывается метод unwrap, который, как известно, никогда не вызовет панику, потому что
методы у Post гарантируют, что state всегда будет содержать значение Some,
когда эти методы завершаются. Это один из случаев, о которых говорилось в
разделе «Когда у вас больше информации, чем у
компилятора» главы 9, когда
известно, что значение None невозможно, хотя компилятор не способен
это понять.
На этом этапе при вызове content у &Box<dyn State> разыменовывающее приведение
типов вступит в силу для & и Box, так что в конечном итоге метод content будет
вызван у типа, реализующего трейт State. Это означает,
что нужно добавить content в определение трейта State, и именно здесь
будет размещена логика того, какое содержимое возвращать в зависимости от того, какое состояние
есть, как показано в листинге 18-18.
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
self.state.as_ref().unwrap().content(self)
}
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
pub fn approve(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
trait State {
// --snip--
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
fn content<'a>(&self, post: &'a Post) -> &'a str {
""
}
}
// --snip--
struct Draft {}
impl State for Draft {
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
struct PendingReview {}
impl State for PendingReview {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
// --snip--
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
fn content<'a>(&self, post: &'a Post) -> &'a str {
&post.content
}
}
content в трейт StateДобавим реализацию по умолчанию для метода content, возвращающую пустой
срез строки. Это означает, что не нужно реализовывать content у структур Draft
и PendingReview. Структура Published переопределит метод content
и вернёт значение в post.content. Хотя это удобно, наличие метода
content у State, определяющего содержимое Post, размывает
границы между ответственностью State и ответственностью Post.
Обратите внимание, что для этого метода нужны аннотации времени жизни, как обсуждалось в
главе 10. Принимается ссылка на post в качестве аргумента и возвращается
ссылка на часть этого post, поэтому время жизни возвращаемой ссылки связано
с временем жизни аргумента post.
И готово — всё в листинге 18-11 теперь работает! Шаблон состояния реализован
с правилами рабочего процесса записи в блоге. Логика, связанная с
правилами, находится в объектах состояний, а не разбросана по Post.
Почему не перечисление?
Возможно, возник вопрос, почему не использовалось перечисление с различными
возможными состояниями записи в качестве вариантов. Это, безусловно, возможное решение; попробуйте
и сравните конечные результаты, чтобы увидеть, что больше нравится! Один из недостатков использования
перечисления состоит в том, что каждое место, проверяющее значение перечисления, потребует
выражения match или аналогичного для обработки каждого возможного варианта. Это может стать
более повторяющимся, чем это решение с трейт-объектами.
Оценка шаблона состояния
Было показано, что Rust способен реализовать объектно-ориентированный шаблон состояния,
чтобы инкапсулировать различные виды поведения, которые должна иметь запись
в каждом состоянии. Методы у Post ничего не знают о различных поведениях.
Благодаря тому, как организован код, нужно посмотреть только в одно место, чтобы
узнать различные способы поведения опубликованной записи: реализацию
трейта State для структуры Published.
Если бы была создана альтернативная реализация без использования шаблона
состояния, можно было бы вместо этого использовать выражения match в методах у
Post или даже в коде main, который проверяет состояние записи и меняет поведение
в этих местах. Это означало бы, что нужно было бы смотреть в несколько мест, чтобы
понять все последствия того, что запись находится в опубликованном состоянии.
С шаблоном состояния методы Post и места использования Post не
нуждаются в выражениях match, а для добавления нового состояния нужно было бы только добавить
новую структуру и реализовать методы трейта для этой одной структуры в одном месте.
Реализация с использованием шаблона состояния легко расширяется для добавления функциональности. Чтобы увидеть простоту поддержки кода, использующего шаблон состояния, попробуйте несколько из этих предложений:
- Добавить метод
reject, который переводит состояние записи изPendingReviewобратно вDraft. - Требовать два вызова
approve, прежде чем состояние сможет измениться наPublished. - Разрешить пользователям добавлять текстовое содержимое только тогда, когда запись находится в состоянии
Draft. Подсказка: пусть объект состояния отвечает за то, что может измениться в содержимом, но не отвечает за изменениеPost.
Один из недостатков шаблона состояния состоит в том, что, поскольку состояния реализуют
переходы между состояниями, некоторые из состояний связаны друг с другом. Если
добавить ещё одно состояние между PendingReview и Published, например Scheduled,
пришлось бы изменить код в PendingReview для перехода в
Scheduled вместо этого. Было бы меньше работы, если бы PendingReview не нужно было
менять при добавлении нового состояния, но это означало бы переключение на
другой шаблон проектирования.
Ещё один недостаток — дублирование некоторой логики. Чтобы устранить часть
дублирования, можно попытаться сделать реализации по умолчанию для методов
request_review и approve в трейте State, возвращающие self.
Однако это не сработает: при использовании State в качестве трейт-объекта трейт
не знает, каким именно будет конкретный self, поэтому тип возвращаемого значения неизвестен
на этапе компиляции. (Это одно из правил dyn-совместимости, упомянутых
ранее.)
Другое дублирование включает похожие реализации методов request_review
и approve у Post. Оба метода используют Option::take с полем
state у Post, и если state равен Some, они делегируют
реализации того же метода у обёрнутого значения и устанавливают новое значение поля state
в результат. Если бы у Post было много методов, следующих этому
шаблону, можно было бы рассмотреть определение макроса для устранения повторения (см.
раздел «Макросы» главы 20).
Реализуя шаблон состояния в точности так, как он определён для объектно-ориентированных
языков, мы не используем сильные стороны Rust в полной мере. Рассмотрим некоторые изменения, которые можно внести в
крейт blog, чтобы сделать недопустимые состояния и переходы ошибками времени компиляции.
Кодирование состояний и поведения как типов
Будет показано, как переосмыслить шаблон состояния, чтобы получить другой набор компромиссов. Вместо того чтобы полностью инкапсулировать состояния и переходы так, чтобы внешний код ничего о них не знал, будем кодировать состояния в различные типы. Следовательно, система проверки типов Rust будет предотвращать попытки использовать черновые записи там, где разрешены только опубликованные записи, выдавая ошибку компилятора.
Рассмотрим первую часть main в листинге 18-11:
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
assert_eq!("", post.content());
post.request_review();
assert_eq!("", post.content());
post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
По-прежнему нужно включить создание новых записей в состоянии черновика с помощью Post::new
и возможность добавлять текст к содержимому записи. Но вместо того, чтобы у черновой записи
был метод content, возвращающий пустую строку, сделаем так,
чтобы у черновых записей вообще не было метода content. Таким образом, при попытке
получить содержимое черновой записи будет получена ошибка компилятора, сообщающая, что метод
не существует. В результате будет невозможно случайно
отобразить содержимое черновой записи в продакшене, потому что этот код даже не скомпилируется.
В листинге 18-19 показано определение структуры Post и структуры DraftPost,
а также методы у каждой.
pub struct Post {
content: String,
}
pub struct DraftPost {
content: String,
}
impl Post {
pub fn new() -> DraftPost {
DraftPost {
content: String::new(),
}
}
pub fn content(&self) -> &str {
&self.content
}
}
impl DraftPost {
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
}
Post с методом content и DraftPost без метода contentОбе структуры, Post и DraftPost, имеют приватное поле content, в котором
хранится текст записи в блоге. У структур больше нет поля state, потому что
кодирование состояния перенесено в типы структур. Структура Post
будет представлять опубликованную запись, и у неё есть метод content, который
возвращает content.
По-прежнему есть функция Post::new, но вместо возврата экземпляра
Post она возвращает экземпляр DraftPost. Поскольку content приватное и
нет ни одной функции, возвращающей Post, сейчас невозможно создать
экземпляр Post.
У структуры DraftPost есть метод add_text, поэтому можно добавлять текст в
content, как и раньше, но обратите внимание, что у DraftPost не определён метод content!
Значит, теперь программа гарантирует, что все записи начинаются как черновики, а
содержимое черновиков недоступно для отображения. Любая попытка обойти
эти ограничения приведёт к ошибке компилятора.
Итак, как получить опубликованную запись? Нужно обеспечить правило, что черновая
запись должна быть рассмотрена и одобрена, прежде чем может быть опубликована. Запись в
состоянии ожидания рецензирования по-прежнему не должна отображать никакого содержимого. Реализуем
эти ограничения, добавив ещё одну структуру, PendingReviewPost, определив метод
request_review у DraftPost, возвращающий PendingReviewPost, и
определив метод approve у PendingReviewPost, возвращающий Post, как
показано в листинге 18-20.
pub struct Post {
content: String,
}
pub struct DraftPost {
content: String,
}
impl Post {
pub fn new() -> DraftPost {
DraftPost {
content: String::new(),
}
}
pub fn content(&self) -> &str {
&self.content
}
}
impl DraftPost {
// --snip--
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn request_review(self) -> PendingReviewPost {
PendingReviewPost {
content: self.content,
}
}
}
pub struct PendingReviewPost {
content: String,
}
impl PendingReviewPost {
pub fn approve(self) -> Post {
Post {
content: self.content,
}
}
}
PendingReviewPost, создаваемый путём вызова request_review у DraftPost, и метод approve, превращающий PendingReviewPost в опубликованный PostМетоды request_review и approve принимают владение self, таким образом
потребляя экземпляры DraftPost и PendingReviewPost и преобразуя
их в PendingReviewPost и опубликованный Post соответственно. Таким образом,
не останется никаких оставшихся экземпляров DraftPost после вызова
request_review для них, и так далее. У структуры PendingReviewPost нет
метода content, поэтому попытка прочитать её содержимое
приведёт к ошибке компилятора, как и с DraftPost. Поскольку единственный способ получить
опубликованный экземпляр Post, у которого есть метод content, — это вызвать
метод approve у PendingReviewPost, а единственный способ получить
PendingReviewPost — вызвать метод request_review у DraftPost,
теперь рабочий процесс записи в блоге закодирован в системе типов.
Но также придётся внести некоторые небольшие изменения в main. Методы request_review и
approve возвращают новые экземпляры, а не изменяют структуру, для которой они
вызваны, поэтому нужно добавить больше затеняющих присваиваний let post =, чтобы сохранить
возвращённые экземпляры. Также больше нельзя иметь утверждения о том, что содержимое черновой и
ожидающей рецензирования записей пусто, и они не нужны: нельзя
скомпилировать код, который пытается использовать содержимое записей в этих состояниях. Обновлённый код в main
показан в листинге 18-21.
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
let post = post.request_review();
let post = post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
main для использования новой реализации рабочего процесса записи в блогеИзменения, которые потребовались в main для переназначения post, означают, что эта
реализация уже не совсем следует объектно-ориентированному шаблону состояния:
преобразования между состояниями больше не инкапсулированы полностью
внутри реализации Post. Однако выигрыш в том, что недопустимые состояния
теперь невозможны благодаря системе типов и проверке типов, которая происходит во
время компиляции! Это гарантирует, что определённые ошибки, такие как отображение содержимого
неопубликованной записи, будут обнаружены до того, как попадут в продакшен.
Попробуйте выполнить задачи, предложенные в начале этого раздела, для крейта blog в том виде,
в каком он находится после листинга 18-21, чтобы увидеть, что думаете о дизайне этой версии
кода. Обратите внимание, что некоторые из задач, возможно, уже выполнены в этом
дизайне.
Было показано, что хотя Rust способен реализовать объектно-ориентированные шаблоны проектирования, другие шаблоны, такие как кодирование состояния в систему типов, также доступны в Rust. У этих шаблонов разные компромиссы. Хотя объектно-ориентированные шаблоны могут быть очень знакомы, переосмысление задачи с использованием возможностей Rust может дать преимущества, такие как предотвращение некоторых ошибок на этапе компиляции. Объектно-ориентированные шаблоны не всегда будут лучшим решением в Rust из-за определённых возможностей, таких как владение, которых нет в объектно-ориентированных языках.
Итоги
Независимо от того, считается ли Rust объектно-ориентированным языком после прочтения этой главы, теперь известно, что можно использовать трейт-объекты для получения некоторых объектно-ориентированных возможностей в Rust. Динамическая диспетчеризация может дать коду некоторую гибкость в обмен на небольшую потерю производительности во время выполнения. Эту гибкость можно использовать для реализации объектно-ориентированных шаблонов, которые могут помочь в поддержке кода. В Rust также есть другие возможности, такие как владение, которых нет в объектно-ориентированных языках. Объектно-ориентированный шаблон не всегда будет лучшим способом использования сильных сторон Rust, но это доступная опция.
Далее рассмотрим шаблоны — ещё одну возможность Rust, обеспечивающую большую гибкость. Они кратко рассматривались на протяжении всей книги, но ещё не были показаны в полной мере. Приступим!