(Kotlin and Java)设计模式-访问者模式

以最简单的module学习设计模式，理解最重要
设计模式持续更新中:https://www.jianshu.com/p/e3c25095c31f
持续更新中

前言

访问者模式是一种将数据操作与数据结构分离的设计模式。
使用场景：

1. 主要解决稳定的数据结构和易变的操作耦合问题。
2. 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。即数据结构不变，数据发生改变适用的设计模式

基本思路

访问者模式的基本想法是，软件系统中拥有一个由许多对象构成的、比较稳定的对象结构，这些对象的类都拥有一个 accept 方法用来接受访问者对象的访问。访问者是一个接口，它拥有一个 visit 方法，这个方法对访问到的对象结构中不同类型的元素做出不同的处理。在对象结构的一次访问过程中，我们遍历整个对象结构，对每一个元素都实施 accept 方法，在每一个元素的 accept 方法中会调用访问者的 visit 方法，从而使访问者得以处理对象结构的每一个元素，我们可以针对对象结构设计不同的访问者类来完成不同的操作，达到区别对待的效果。

三. UML图

（1）Visitor：接口或者抽象类，它定义了对每一个元素（Element）访问的行为，它的参数就是可以访问的元素，它的方法数理论上来讲与元素个数是一样的，因此，访问者模式要求元素的类族要稳定，如果经常添加、移除元素类，必然会导致频繁地修改Visitor接口，如果这样则不适合使用访问者模式。

（2）ConcreteVisitor1、ConcreteVisitor2：具体的访问类，它需要给出对每一个元素类访问时所产生的具体行为。

（3）Element：元素接口或者抽象类，它定义了一个接受访问者的方法（Accept），其意义是指每一个元素都要可以被访问者访问。

（4）ConcreteElementA、ConcreteElementB：具体的元素类，它提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法。

（5）ObjectStructure：定义当中所说的对象结构，对象结构是一个抽象表述，它内部管理了元素集合，并且可以迭代这些元素供访问者访问。

四 访问者模式实现：

我们都知道财务都是有账本的，这个账本就可以作为一个对象结构，而它其中的元素有两种，收入和支出，这满足我们访问者模式的要求，即元素的个数是稳定的，因为账本中的元素只能是收入和支出。

而查看账本的人可能有这样几种，比如老板，会计事务所的注会，财务主管，等等。而这些人在看账本的时候显然目的和行为是不同的。

首先我们给出单子的接口，它只有一个方法accept。

/**
 * 创建一个账单接口，有接收访问者的功能
 */
interface Bill {
    fun accept(accountBookView: AccountBookView)
}

其中的方法参数AccountBookView是一个账本访问者接口，接下来也就是实现类，收入单子和消费单子，或者说收入和支出类。

/**
 * 消费单子
 */
class ConsumerBill : Bill {
    internal var item: String = ""
    internal var amount: Double = 0.0

    internal constructor(item: String, amount: Double) {
        this.amount = amount
        this.item = item
    }

    fun getItem(): String {
        return item
    }

    fun getAmount(): Double {
        return amount
    }

    override fun accept(accountBookView: AccountBookView) {
        accountBookView.view(this)
    }
}

/**
 * 支出单子
 */
class IncomeBill : Bill {
    private var item: String = ""
    internal var amount: Double = 0.0

    internal constructor(item: String, amount: Double) {
        this.item = item
        this.amount = amount
    }

    fun getItem(): String {
        return item
    }

    fun getAmount(): Double {
        return amount
    }

    override fun accept(accountBookView: AccountBookView) {
        accountBookView.view(this)
    }
}

上面最关键的还是里面的accept方法，它直接让访问者访问自己，这相当于一次静态分派，当然我们也可以不使用重载而直接给方法不同的名称。

接下来是账本访问者接口

/**
 * 访问者接口
 */
interface AccountBookView {
    fun view(consumerBill: ConsumerBill)

    fun view(incomeBill: IncomeBill)
}

这两个方法是重载方法，就是在上面的元素类当中用到的，当然你也可以按照访问者模式类图当中的方式去做，将两个方法分别命名为viewConsumeBill和viewIncomeBill，而一般建议按照类图上来做的

访问者的实现

/**
 * 老板类：访问者是老板，主要查看总支出和总收入
 */
class Boss : AccountBookView {
    private var totalConsumer: Double = 0.toDouble()
    private var totalIncome: Double = 0.toDouble()

    // 查看消费的单子
    override fun view(consumerBill: ConsumerBill) {
        totalConsumer += consumerBill.amount
    }

    // 查看收入单子
    override fun view(incomeBill: IncomeBill) {
        totalIncome += incomeBill.amount
    }

    internal fun getTotalConsumer() {
        println("老板查看到 一共消费了$totalConsumer")
    }

    internal fun getTotalIncome() {
        println("老板查看到 一共收入了$totalIncome")
    }

}

/**
 * 会计类：访问者是会计，主要记录每笔单子
 */
class CPA : AccountBookView {
    private var count = 0

    // 查看消费的单子
    override fun view(consumerBill: ConsumerBill) {
        count++
        if (consumerBill.getItem() == "消费") {
            println("第" + count + "个单子消费了：" + consumerBill.getAmount())
        }
    }

    // 查看收入单子
    override fun view(incomeBill: IncomeBill) {

        if (incomeBill.getItem() == "收入") {
            println("第" + count + "个单子收入了：" + incomeBill.getAmount())
        }
    }
}

老板只关心收入和支出的总额，而注会只关注该交税的是否交税

接下来是账本类，它是当前访问者模式例子中的对象结构

/**
 * 账单类：用于添加账单，和为每一个账单添加访问者
 */
internal class AccountBook {
    private val listBill = ArrayList<Bill>()

    // 添加单子
    fun add(bill: Bill) {
        listBill.add(bill)
    }

    // 为每个账单添加访问者
    fun show(viewer: AccountBookView) {
        for (b in listBill) {
            b.accept(viewer)
        }
    }
}

账本类当中有一个列表，这个列表是元素（Bill）的集合，这便是对象结构的通常表示，它一般会是一堆元素的集合，不过这个集合不一定是列表，也可能是树，链表等等任何数据结构，甚至是若干个数据结构。其中show方法，就是账本类的精髓，它会枚举每一个元素，让访问者访问。

测试客户端

object VisitorTest {
    @JvmStatic
    fun main(args: Array<String>) {
        // 创建消费和收入单子
        val consumerBill = ConsumerBill("消费", 3000.0)
        val incomeBill = IncomeBill("收入", 5000.0)
        val consumerBill2 = ConsumerBill("消费", 4000.0)
        val incomeBill2 = IncomeBill("收入", 8000.0)
        // 添加单子
        val accountBook = AccountBook()
        accountBook.add(consumerBill)
        accountBook.add(incomeBill)
        accountBook.add(consumerBill2)
        accountBook.add(incomeBill2)
        // 创建访问者
        val boss = Boss()
        val cpa = CPA()
//
//        // 接受 访问者
        accountBook.show(boss)
        accountBook.show(cpa)
//        // boss查看总收入和总消费
        boss.getTotalConsumer()
        boss.getTotalIncome()
    }
}

上面的代码中，可以这么理解，账本以及账本中的元素是非常稳定的，这些几乎不可能改变，而最容易改变的就是访问者这部分。

访问者模式最大的优点就是增加访问者非常容易，我们从代码上来看，如果要增加一个访问者，你只需要做一件事即可，那就是写一个类，实现AccountBookViewer接口，然后就可以直接调用AccountBook的show方法去访问账本了。

如果没使用访问者模式，一定会增加许多if else，而且每增加一个访问者，你都需要改你的if else，代码会显得非常臃肿，而且非常难以扩展和维护。
结果：

---

如果你对此感兴趣，可订阅(感谢你的关注):