【架构—设计模式】迭代器模式

在软件开发中，存在一些类，它们可以存储多个成员对象（元素），这些类通常称为聚合类(Aggregate Classes)，对应的对象称为聚合对象。为了更加方便地操作这些聚合对象，同时可以很灵活地为聚合对象增加不同的遍历方法，我们也需要类似电视机遥控器一样的角色，可以访问一个聚合对象中的元素但又不需要暴露它的内部结构。本章我们将要学习的迭代器模式将为聚合对象提供一个遥控器，通过引入迭代器，客户端无须了解聚合对象的内部结构即可实现对聚合对象中成员的遍历，还可以根据需要很方便地增加新的遍历方式。

概述

在软件开发中，我们经常需要使用聚合对象来存储一系列数据。聚合对象拥有两个职责：一是存储数据；二是遍历数据。从依赖性来看，前者是聚合对象的基本职责；而后者既是可变化的，又是可分离的。因此，可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为“迭代器”的对象中，由迭代器来提供遍历聚合对象内部数据的行为，这将简化聚合对象的设计，更符合“单一职责原则”的要求。

迭代器模式定义如下：

迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。

在迭代器模式结构中包含聚合和迭代器两个层次结构，考虑到系统的灵活性和可扩展性，在迭代器模式中应用了工厂方法模式，其模式结构如图所示：

在迭代器模式结构图中包含如下几个角色：

• Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。
• ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。
• Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。
• ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

在迭代器模式中，提供了一个外部的迭代器来对聚合对象进行访问和遍历，迭代器定义了一个访问该聚合元素的接口，并且可以跟踪当前遍历的元素，了解哪些元素已经遍历过而哪些没有。迭代器的引入，将使得对一个复杂聚合对象的操作变得简单。

在迭代器模式中应用了工厂方法模式，抽象迭代器对应于抽象产品角色，具体迭代器对应于具体产品角色，抽象聚合类对应于抽象工厂角色，具体聚合类对应于具体工厂角色。

在抽象迭代器中声明了用于遍历聚合对象中所存储元素的方法，典型代码如下所示：

interface Iterator 
{
    //返回游标当前指向元素
    public function current();

    //将游标指向下一个元素
    public function next();

    //返回当前元素的键
    public function key();

    //检查当前位置是否有效
    public function valid();

    //重置游标指向第一个元素
    public function rewind();
}

在具体迭代器中将实现抽象迭代器声明的遍历数据的方法，如下代码所示：

class ConcreteIterator implements Iterator
{
    //维持一个对具体聚合对象的引用，以便于访问存储在聚合对象中的数据
    private $concreteAggregate;

    //定义一个游标，用于记录当前访问位置
    private $cursor = 0;

    public function current()
    {
        ...
    }

    public function next()
    {
        ...
    }

    public function key()
    {
        ...
    }

    public function valid(): bool
    {
        ...
    }

    public function rewind()
    {
        ...
    }
}

需要注意的是抽象迭代器接口的设计非常重要，一方面需要充分满足各种遍历操作的要求，尽量为各种遍历方法都提供声明，另一方面又不能包含太多方法，接口中方法太多将给子类的实现带来麻烦。因此，可以考虑使用抽象类来设计抽象迭代器，在抽象类中为每一个方法提供一个空的默认实现。如果需要在具体迭代器中为聚合对象增加全新的遍历操作，则必须修改抽象迭代器和具体迭代器的源代码，这将违反“开闭原则”，因此在设计时要考虑全面，避免之后修改接口。

聚合类用于存储数据并负责创建迭代器对象，最简单的抽象聚合类代码如下所示：

interface Aggregate
{
    public function createIterator(): Iterator;
}

具体聚合类作为抽象聚合类的子类，一方面负责存储数据，另一方面实现了在抽象聚合类中声明的工厂方法createIterator()，用于返回一个与该具体聚合类对应的具体迭代器对象，代码如下所示：

class ConcreteAggregate implements Aggregate
{
    ...

    public function createIterator(): Iterator
    {
        return new ConcreteIterator($this);
    }

    ...
}

案例

Sunny软件公司为某商场开发了一套销售管理系统，在对该系统进行分析和设计时，Sunny软件公司开发人员发现经常需要对系统中的商品数据、客户数据等进行遍历，为了复用这些遍历代码，Sunny公司开发人员设计了一个抽象的数据集合类AbstractObjectList，而将存储商品和客户等数据的类作为其子类，AbstractObjectList类结构如图所示：

该方案存在违反单一职责原则等问题，请设计方案对其进行重构。

为了简化AbstractObjectList类的结构，并给不同的具体数据集合类提供不同的遍历方式，Sunny软件公司开发人员使用迭代器模式来重构AbstractObjectList类的设计，重构之后的销售管理系统数据遍历结构如图所示：

AbstractObjectList充当抽象聚合类，ProductList充当具体聚合类，AbstractIterator充当抽象迭代器，ProductIterator充当具体迭代器。完整代码如下所示：

<?php

//抽象聚合类
abstract class AbstractObjectList
{
    protected $objects = [];

    public function __construct(array $objects)
    {
        $this->objects = $objects;
    }

    public function addObject($obj)
    {
        $this->objects[] = $obj;
    }

    public function removeObject($obj)
    {
        unset($this->objects[array_search($obj, $this->objects)]);
    }

    public function getObjects(): array
    {
        return $this->objects;
    }

    //声明创建迭代器对象的抽象工厂方法
    abstract public function createIterator(): AbstractIterator;
}

//商品数据类：具体聚合类
class ProductList extends AbstractObjectList
{
    public function __construct(array $objects)
    {
        parent::__construct($objects);
    }

    //实现创建迭代器对象的具体工厂方法
    public function createIterator(): AbstractIterator
    {
        return new ProductIterator($this);
    }
}

//抽象迭代器
interface AbstractIterator
{
    public function next(); //移至下一个元素

    public function isLast(): bool; //判断是否为最后一个元素

    public function previous(); //移至上一个元素

    public function isFirst(): bool; //判断是否为第一个元素

    public function getNextItem(); //获取下一个元素

    public function getPreviousItem(); //获取上一个元素
}

//商品迭代器：具体迭代器
class ProductIterator implements AbstractIterator
{
    private $productList;
    private $products;
    private $cursor1; //定义一个游标，用于记录正向遍历的位置
    private $cursor2; //定义一个游标，用于记录逆向遍历的位置

    public function __construct(ProductList $list)
    {
        $this->productList = $list;
        $this->products = $list->getObjects(); //获取集合对象
        $this->cursor1 = 0; //设置正向遍历游标的初始值
        $this->cursor2 = count($this->products) - 1; //设置逆向遍历游标的初始值
    }

    public function next()
    {
        if ($this->cursor1 < count($this->products)) {
            $this->cursor1++;
        }
    }

    public function isLast(): bool
    {
        return ($this->cursor1 == count($this->products));
    }

    public function previous()
    {
        if ($this->cursor2 > -1) {
            $this->cursor2--;
        }
    }

    public function isFirst(): bool
    {
        return ($this->cursor2 == -1);
    }

    public function getNextItem()
    {
        return $this->products[$this->cursor1];
    }

    public function getPreviousItem()
    {
        return $this->products[$this->cursor2];
    }
}

如果需要增加一个新的具体聚合类，如客户数据集合类，并且需要为客户数据集合类提供不同于商品数据集合类的正向遍历和逆向遍历操作，只需增加一个新的聚合子类和一个新的具体迭代器类即可，原有类库代码无须修改，符合“开闭原则”；如果需要为ProductList类更换一个迭代器，只需要增加一个新的具体迭代器类作为抽象迭代器类的子类，重新实现遍历方法，原有迭代器代码无须修改，也符合“开闭原则”；但是如果要在迭代器中增加新的方法，则需要修改抽象迭代器源代码，这将违背“开闭原则”。

总结

迭代器模式是一种使用频率非常高的设计模式，通过引入迭代器可以将数据的遍历功能从聚合对象中分离出来，聚合对象只负责存储数据，而遍历数据由迭代器来完成。由于很多编程语言的类库都已经实现了迭代器模式，因此在实际开发中，我们只需要直接使用Java、C#等语言已定义好的迭代器即可，迭代器已经成为我们操作聚合对象的基本工具之一。

主要优点

1. 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
2. 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
3. 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。

主要缺点

1. 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
2. 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展，在自定义迭代器时，创建一个考虑全面的抽象迭代器并不是件很容易的事情。

适用场景

1. 访问一个聚合对象的内容而无须暴露它的内部表示。将聚合对象的访问与内部数据的存储分离，使得访问聚合对象时无须了解其内部实现细节。
2. 需要为一个聚合对象提供多种遍历方式。
3. 为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而客户端可以一致性地操作该接口。