MyException - 我的异常网
当前位置:我的异常网» 设计模式 » 设计形式visitor——访问者

设计形式visitor——访问者

www.MyException.Cn  网友分享于:2013-11-01  浏览:7次
设计模式visitor——访问者

http://www.ibm.com/developerworks/cn/java/l-dpstruct/part1/

 

把对象本身和对象的操作分离开

 

2、问题描述

一个完善的软件系统,必须要对出现的错误进行相应的处理,只有这样才能使系统足够的健壮,我准备以软件系统中对于错误的处理为例,来展示 我所使用的思路、方法。

在一个分布式的网管系统中,一个操作往往不会一定成功,常常会因为这样或者那样的原因失败,此时我们就要根据失败的原因相应的处理,使错误的影响局限在最 小的范围内,最好能够恢复而不影响系统的正常运行,还有一点很重要,那就是在对错误进行处理的同时,一定不要忘记通知系统的管理者,因为只有管理者才有能 力对错误进行进一步的分析,从而查找出错误的根源,从根本上解决错误。

下面我就从错误处理的通告管理者部分入手,开始我们的旅程。假定一个在一个分布式环境中访问数据库的操作,那么就有可能因为通信的原因或者数据库本身的原因失败,此时我们要通过用户界面来通知管理者发生的错误。简化了的代码示例如下:

   /* 错误码定义 */
    class ErrorConstant
    {
        public static final int ERROR_DBACCESS         =  100;
        public static final int ERROR_COMMUNICATION  =  101;
    }
    /* 省略了用户界面中的其他的功能 */
    class GUISys
    {
        public void announceError(int errCode) {
            switch(errCode) {
            case ErrorConstant.ERROR_DBACCESS:
                /* 通告管理者数据库访问错误的发生*/
            break;
            case ErrorConstant.ERROR_COMMUNICATION:
                /* 通告管理者通信错误的发生*/
            break;
            }
        }
    }

 

开始,这段代码工作的很好,能够完成我们需要的功能。但是这段代码缺少相应的弹性,很难适应需求的变化。


3、问题分析

熟悉面向对象的读者很快就会发现上面的代码是典型的结构化的方法,结构化的方法是以具体的功能为核心来组织程序的结构,它的封装度仅为1级,即仅有对于特 定的功能的封装(函数)。这使得结构化的方法很难适应需求的变化,面向对象的方法正是在这一点上优于结构化的方法。在面向对象领域,是以对象来组成程序结 构的,一个对象有自己的职责,通过对象间的交互来完成系统的功能,这使得它的封装度至少为2级,即封装了为完成自己职责的方法和数据。另外面向对象的方法 还支持更高层次的封装,比如:通过对于不同的具体对象的共同的概念行为进行描述,我们可以达到3级的封装度 - 抽象的类(在Java中就是接口)。封装的层次越高,抽象的层次就越高,使得设计、代码有越高的弹性,越容易适应变化。

考虑对上一节中的代码,如果在系统的开发过程中发现需要对一种新的错误进行处理,比如:用户认证错误,我们该如何做使得我们的系统能够增加对于此项功能的 需求呢?一种比较简单、直接的做法就是在增加一条用来处理此项错误的case语句。是的,这种方法的确能够工作,但是这样做是要付出代价的。

首先,随着系统的进一步开发,可能会出现更多的错误类型,那么就会导致对于错误的处理部分代码冗长,不利于维护。其次,也是最根本的一点,修改已经能够工 作的代码,很容易引入错误,并且在很多的情况下,错误都是在不经意下引入的,对于这种类型的错误很难定位。有调查表明,我们在开发过程中,用于修正错误的 时间并不多,大部分的时间是在调试、发现错误。在面向对象领域,有一个很著名的原则:OCP(Open-Closed Principle),它的核心含意是:一个好的设计应该能够容纳新的功能需求的增加,但是增加的方式不是通过修改又有的模块(类),而是通过增加新的模 块(类)来完成的。如果一个设计能够遵循OCP,那么就能够有效的避免上述的问题。

要是一个设计能够符合OCP原则,就要求我们在进行设计时不能简单的以功能为核心。要实现OCP的关键是抽象,抽象表征了一个固定的行为,但是对于这个行 为可以有很多个不同的具体实现方法。通过抽象,我们就可以用一个固定的抽象的概念来代替哪些容易变化的数量众多的具体的概念,并且使得原来依赖于哪些容易 变化的概念的模块,依赖于这个固定的抽象的概念,这样的结果就是:系统新的需求的增加,仅仅会引起具体的概念的增加,而不会影响依赖于具体概念的抽象体的 其他模块。在实现的层面上,抽象体是通过抽象类来描述的,在Java中是接口(interface)。关于OCP的更详细描述,请参见 参考文献[2] 。

既然知道了问题的本质以及相应的解决方法,下面就来改善我们的代码结构。


4、初步方案

让我们重新审视代码,看看该如何进行抽象。在错误处理中,需要处理不同类型的错误,每个具体的错误具有特定于自己本身的一些信息,但是它们在概念层面上又 是一致的,比如:都可以通过特定的方法接口获取自已内部的错误信息,每一个错误都有自己的处理方法。由此可以得到一个初步的方案:可以定义一个抽象的错误 基类,在这个基类里面定义一些在概念上适用于所有不同的具体错误的方法,每个具体的错误可以有自己的不同的对于这些方法的实现。代码示例如下:

    interface ErrorBase
{
    public void handle();
            public String getInfo();
}   
class DBAccessError implements ErrorBase
{
    public void handle() {
        /* 进行关于数据库访问错误的处理 */
    } 
   
            public String getInfo() {
            /* 构造返回关于数据库访问错误的信息 */    
            }
}
class CommunicationError implements ErrorBase
{
    public void handle() {
        /* 进行关于通信错误的处理 */
    } 
            public String getInfo() {
        /* 构造返回关于通信错误的信息 */    
            }
}   

 

这样,我们就可以在错误发生处,构造一个实际的错误对象,并以ErrorBase引用它。然后,交给给错误处理模块,此时错误处理模块就仅仅知道一个类型ErrorBase,而无需知道每一个具体的错误类型,这样就可以使用统一的方式来处理错误了。代码示例如下:

   class GUISys
{
            public void announceError(ErrorBase error) {
            /* 使用一致的方式处理错误 */                
            error.handle();
            }
}   

 

可以看出,对于新的错误类型的增加,仅仅需要增加一个具体的错误类,对于错误处理部分没有任何影响。看上去很完美,也符合OCP原则,但是进一步分析就会发现,这个方案一样存在着问题,我们将在下一个小节进行详细的说明。


5、进一步分析

上一个小节给出了一个方案,对于只有GUISys这一个错误处理者是很完美的,但是情况往往不是这样的。前面也曾经提到过,对于发生的错误,除了要通知系 统的使用者外,还要进行其他的处理,比如:试图恢复,记如日志等。可以看出,这些处理方法和把错误通告给使用者是非常不同的,完全没有办法仅仅用一个 handle方法来统一所有的不同的处理。但是,如果我们在ErrorBase中增加不同的处理方法声明,在具体的错误类中,根据自身的需要来相应的实现 这些方法,好像也是一个不错的方案。代码示例如下:

    interface ErrorBase
{
            public void guiHandle();
            public void logHandle();
}
class DBAccessError implements ErrorBase
{
    public void guiHandle() {
        /* 通知用户界面的数据库访问错误处理 */
    }
public void logHandle() {
        /* 通知日志系统的数据库访问错误处理 */
    }
}
class CommunicationError implements ErrorBase
{
    public void guiHandle() {
        /* 通知用户界面的通信错误处理 */
    }
public void logHandle() {
        /* 通知日志系统的通信错误处理 */
    }
}
class GUISys
{
    public void announceError(ErrorBase error) {
        error.guiHandle();
    }
}
class LogSys
{
    public void announceError(ErrorBase error) {
    error.logHandle();
    }
}   

 

读者可能已经注意到,这种做法其实也不是十分符合OCP,虽然它把变化局限在ErrorBase这个类层次架构中,但是增加新的处理方法,还是更改了已经 存在的ErrorBase类。其实,这种设计方法,还违反了另外一个著名的面向对象的设计原则:SRP(Single Responsibility Principle)。这个原则的核心含意是:一个类应该有且仅有一个职责。关于职责的含意,面向对象大师Robert.C Martin有一个著名的定义:所谓一个类的职责是指引起该类变化的原因,如果一个类具有一个以上的职责,那么就会有多个不同的原因引起该类变化,其实就 是耦合了多个互不相关的职责,就会降低这个类的内聚性。错误类的职责就是,保存和自己相关的错误状态,并且提供方法用于获取这些状态。上面的设计中把不同 的处理方法也放到错误类中,从而增加了错误类的职责,这样即使和错误类本身没有关系的对于错误处理方式的变化,增加、修改都会导致错误类的修改。这种设计 方法一样会在需求变化时,带来没有预料到的问题。那么能否将对错误的处理方法从中剥离出来呢?如果读者比较熟悉设计模式(这里的熟悉是指,设计模式的意 图、动机,而不是指怎样去实现一个具体的设计模式),应该会隐隐约约感觉到一个更好的设计方案即将出现。


6、设计模式浮出水面

让我们对问题重新描述一下:我们已经有了一个关于错误的类层次结构,现在我们需要在不改变这个类层次结构的前提下允许我们增加对于这个类层次的新的处理方 法。听起来很耳熟吧,不错,这正是过于visitor设计模式的意图的描述。通过对于该模式动机的分析,我们很容易知道,要想使用visitor模式,需 要定义两个类层次:一个对应于接收操作的元素的类层次(就是我们的错误类),另一个对应于定义对元素的操作的访问者(就是我们的对于错误的不同处理方 法)。这样,我们就转换了问题视角,即把需要不同的错误处理方法的问题转变为需要不同的错误处理类,这样的结果就是我们可以通过增加新的模块(类)来增加 新的错误处理方法,而不是通过增加新的错误处理方法(这样做,就势必要修改已经存在的类)。

一旦到了这一部,下面的工作就比较简单了,因为visitor模式已经为我们搭建了一个设计的上下文,此时我们就可以关注visitor模式的实现部分来 指导我们下面的具体实现了。下面仅仅给出最终的程序结构的UML图以及代码示例,其中忽略了错误类中的属于错误本身的方法,各个具体的错误处理方法通过这 些方法和具体的错误类对象交互,来完成各自的处理功能。


最终的设计的程序结构图

最终的代码示例

interface ErrorBase
{
    public void handle(ErrorHandler handler);
}
class DBError implements ErrorBase
{
    public void handle(ErrorHandler handler) {
        handler.handle(this);
    }
}
class CommError implements ErrorBase
{
    public void handle(ErrorHandler handler) {
        handler.handle(this);
    }
}
interface ErrorHandler 
{
    public void handle(DBrror dbError);
    public void handle(CommError commError);
}
class GUISys implements ErrorHandler
{
    public void announceError(ErrorBase error) {
        error.handle(this);
    }
    public void handle(DBError dbError) {
        /* 通知用户界面进行有关数据库错误的处理 */       
    }
    public void handle(CommError commError) {
            /* 通知用户界面进行有关通信错误的处理 */       
    }
}
class LogSys implements ErrorHandler
{
    public void announceError(ErrorBase error) {
        error.handle(this);
    }
    public void handle(DBError dbError) {
                /* 通知日志系统进行有关数据库错误的处理 */       
    }
    public void handle(CommError commError) {
        /* 通知日志系统进行有关通信错误的处理 */       
    }
}

 


2、 问题描述

在上一篇文章中,我们对一个网管系统中的错误处理部分的代码进行了重构,最终使用了一个visitor设计模式解决了我们的问题。细心 的读者肯定会发现,这个最终方案一样存在着一个问题:如果错误的类型不是固定不变的,而是随着系统的进展不断增加的,会有什么结果呢?让我们首先来看看上 一篇文章中最终的类图:


图1

在这个类图中,我增加了几条依赖线,即ErrorHandler是依赖于DbError和CommError的。此时我们可以看 到:ErrorBase依赖于ErrorHandler,ErrorHandler依赖于ErrorBase的派生类(DbError和 CommError),而ErrorBase的派生类又要依赖于ErrorBase本身。这就形成了一个循环的依赖过程,这样的结果就是 ErrorBase传递地依赖于它的所有派生类。

这种循环依赖关系会带来严重的问题,一旦ErrorBase新增了一个派生类,那么ErrorHandler类必须要被修改,由于 ErrorBase又依赖于ErrorHandler,那么依赖于ErrorBase的所有类都需要重新编译。这就意味着ErrorBase的所有派生类 以及所有这些派生类的使用者都要重新编译,这种大规模的重新编译在开发一个分布式系统时会导致非常大的工作量,因为要重新分布每一个重新编译过的类,如果 在重新分布时出现一些差错(如:忘记替换一些类),就会导致微妙的错误,而且很不容易查找出来。

另外,在该模式中存在一个假设,就是默认任意一个错误处理者要处理所有的错误类型,这个假设在某些情况下是不成立的,比如:如果对于 LogicError我们不打算通知LOGSys进行处理会怎样呢?我们不得不要写一个处理该错误的空函数(当然你可以在ErrorHandler中写一 个缺省的实现)。如果ErrorBase的类层次架构越来越大,并且它们要求的处理方法也有很多的不同,就会导致ErrorHandler接口中的方法集 庞大,并且任何一个ErrorBase的派生类的改变,都会导致大规模的重新编译(甚至是毫无关系的类也要重新编译),重新分布,如果这种改变比较频繁, 结果当然是无法忍受的。


3、 问题分析

上述的问题描述暴露了visitor模式的一些使用限制,即它仅仅适用于哪些受访问的类层次架构比较固定的情况,导致这样的原因可以使 用一个著名的面向对象设计原则来解释,这个原则就是:DIP(Dependence Inversion Principle),这个原则的核心含义是:高层模块不应该直接依赖于低层模块,所有的模块都要依赖于抽象。也就是说:容易变化的东西一定要依赖于不容 易变化的东西,因为抽象的东西最不容易变化,具体的东西容易变化,所以具体应该依赖于抽象。而在visitor模式中,ErrorHandler依赖于 ErrorBase的所有的具体的派生类,并且如果这些派生类容易变化的话,就会导致不能接受的结果。

通过上面的分析,可以看出打断这个循环依赖的环是克服visitor模式适用范围限制的关键。


4、 解决方案

在上述的循环依赖关系中,有两段依赖关系是无法打断的,一段是ErrorBase的所有派生类对于ErrorBase的依赖,一段是 ErrorBase对于ErrorHandler的依赖,并且这两段依赖关系也是符合DIP的,那么对于仅剩的一段依赖关系我们是必须要打断的了,这段关 系就是,ErrorHandler对于ErrorBase所有派生类的依赖,并且这段关系也是违反DIP的。如果我们不让ErrorHandler知道 ErrorBase的派生类,那么怎样才能够针对每一个具体的ErrorBase的派生类进行相应的处理呢?

面向对象大师Robert C. Martin给出了一个优雅的解决方案,他所采用的技巧是OO方法所建议避免使用的,RTTI(运行时类型鉴别)。可见如果RTTI运用的得当,一样可以 得到很好的设计方案,并且还能够克服一些OO中多态的方法解决不了的问题(当然如果使用多态能够解决的问题,推荐还是使用多态的方法进行解决)。让我们先 看看这个解决方案的类图:


图2

通过上图可以看出,ErrorHandler中没有任何方法了,已经退化为一个空的接口,所以也就不可能再依赖于任何 ErrorBase的派生类了。和visitor模式不同,这个方案中针对每一个特定的ErrorBase的派生类定义一个相应的处理接口,在每个派生类 的handle方法实现中,运用RTTI技术进行相应的类型转换(把ErrorHandler转换为自己对应的错误处理接口,比如:在DbError的 handle方法中,就把ErrorHandler转换为DbErrorHandler。Java在这方面做得不错,可以进行比较安全的类型转换),想要 处理该错误的实体不仅要实现ErrorHandler接口,而且还要实现相应的针对具体错误类的处理接口,比如:GUISys就实现了三个接口 (ErrorHandler、DBErrorHandler以及CommErrorHandler),从而也就实现了对DbError和 CommError的处理。

这种方法打断了类之间的循环依赖关系,使得增加新的错误类型变得容易,并且也避免了可能出现的大规模的重新编译以及类的重新分布。并 且,你也可以有选择地进行错误的处理,比如:如果GUISys不想处理DbError的话,很简单,不要实现DbErrorHandler接口即可,使得 程序的结构非常清晰。可见这个方案克服了原始的visitor设计模式的不足。

通过对比上下两个类图可以看出,下面的要比上面的复杂,这也是该方案的一个缺点。如果问题的规模不大,重新编译以及重新分布没有多少工 作量的话,还是可以使用原始的visitor模式的。仅仅当问题的规模扩大到visitor模式不能适用的地步时,可以考虑使用该方案。另外,由于改进的 方案中使用了RTTI技术,会导致性能上的损失以及不可预测性,在使用时也要特别注意。

我们做如下的类比以便于更好地理解原始的visitor模式和改进后的方案。原始的visitor模式好像一个矩阵,在X方向上是一个 个具体的错误类型,在Y方向上是一个个可以处理错误的实体,每一个交叉点上是具体的处理方法,矩阵中的每一个位置上都必须有一个处理方法。而改进后的方案 象一个稀疏矩阵,仅仅在需要的位置上才有具体的处理方法,从而减少了很多冗余。

下面给出关键的代码片断:

interface ErrorBase
{
    public void handle(ErrorHandler handler);
}
class DBError implements ErrorBase
{
    public void handle(ErrorHandler handler) {
        try {
            DbErrorHandler dbHandler = (DbErrorHandler)handler;
            dbHandler.handle(this);
        }
        catch(ClassCastException e) {
        }
    }
}
class CommError implements ErrorBase
{
    public void handle(ErrorHandler handler) {
        try {
            CommErrorHandler commHandler = (CommErrorHandler)handler;
            commHandler.handle(this);
        }
        catch(ClassCastException e)\ {
        }
    }
}
interface ErrorHandler 
{
}
interface DbErrorHandler
{
    public void handle(DBrror dbError);
}
interface CommErrorHandler
{
    public void handle(CommError commError);
}
class GUISys implements ErrorHandler, DbErrorHandler, CommErrorHandler
{
    public void announceError(ErrorBase error) {
        error.handle(this);
    }
    public void handle(DBError dbError) {
 		/* 通知用户界面进行有关数据库错误的处理 */       
    }
    public void handle(CommError commError) {
    		/* 通知用户界面进行有关通信错误的处理 */       
    }
}
class LogSys implements ErrorHandler, DbErrorHandler, CommErrorHandler
{
    public void announceError(ErrorBase error) {
        error.handle(this);
    }
    public void handle(DBError dbError) {
        		/* 通知日志系统进行有关数据库错误的处理 */       
    }
    public void handle(CommError commError) {
		/* 通知日志系统进行有关通信错误的处理 */       
    }
}

 


5、 结论

本文从另一个方面,设计模式的适用性,探讨了在进行程序重构时该如何选择重构的目标,以及如何对现有的设计模式进行改进使之符合我们的 目标。本文的主要目的是想说明,在进行设计模式的选择时,不仅要关注设计模式是解决什么问题的,还要关注使用该设计模式解决问题时会受到什么约束和限制。 这样就可以帮助你更好地理解问题,做出合理的取舍,或者你可以根据自己的需求对已有的设计模式进行修改使之满足你的要求,如果你这样做了,你就很可能创造 出了一种新的设计模式。

文章评论

代码女神横空出世
代码女神横空出世
写给自己也写给你 自己到底该何去何从
写给自己也写给你 自己到底该何去何从
程序员的一天:一寸光阴一寸金
程序员的一天:一寸光阴一寸金
“懒”出效率是程序员的美德
“懒”出效率是程序员的美德
那些争议最大的编程观点
那些争议最大的编程观点
60个开发者不容错过的免费资源库
60个开发者不容错过的免费资源库
Java 与 .NET 的平台发展之争
Java 与 .NET 的平台发展之争
十大编程算法助程序员走上高手之路
十大编程算法助程序员走上高手之路
旅行,写作,编程
旅行,写作,编程
漫画:程序员的工作
漫画:程序员的工作
我是如何打败拖延症的
我是如何打败拖延症的
看13位CEO、创始人和高管如何提高工作效率
看13位CEO、创始人和高管如何提高工作效率
程序员应该关注的一些事儿
程序员应该关注的一些事儿
程序员和编码员之间的区别
程序员和编码员之间的区别
程序员周末都喜欢做什么?
程序员周末都喜欢做什么?
什么才是优秀的用户界面设计
什么才是优秀的用户界面设计
10个帮程序员减压放松的网站
10个帮程序员减压放松的网站
程序员眼里IE浏览器是什么样的
程序员眼里IE浏览器是什么样的
如何区分一个程序员是“老手“还是“新手“?
如何区分一个程序员是“老手“还是“新手“?
为啥Android手机总会越用越慢?
为啥Android手机总会越用越慢?
做程序猿的老婆应该注意的一些事情
做程序猿的老婆应该注意的一些事情
我的丈夫是个程序员
我的丈夫是个程序员
5款最佳正则表达式编辑调试器
5款最佳正则表达式编辑调试器
科技史上最臭名昭著的13大罪犯
科技史上最臭名昭著的13大罪犯
 程序员的样子
程序员的样子
Java程序员必看电影
Java程序员必看电影
程序猿的崛起——Growth Hacker
程序猿的崛起——Growth Hacker
10个调试和排错的小建议
10个调试和排错的小建议
为什么程序员都是夜猫子
为什么程序员都是夜猫子
Web开发者需具备的8个好习惯
Web开发者需具备的8个好习惯
当下全球最炙手可热的八位少年创业者
当下全球最炙手可热的八位少年创业者
我跳槽是因为他们的显示器更大
我跳槽是因为他们的显示器更大
老美怎么看待阿里赴美上市
老美怎么看待阿里赴美上市
老程序员的下场
老程序员的下场
总结2014中国互联网十大段子
总结2014中国互联网十大段子
初级 vs 高级开发者 哪个性价比更高?
初级 vs 高级开发者 哪个性价比更高?
要嫁就嫁程序猿—钱多话少死的早
要嫁就嫁程序猿—钱多话少死的早
鲜为人知的编程真相
鲜为人知的编程真相
一个程序员的时间管理
一个程序员的时间管理
程序员的鄙视链
程序员的鄙视链
“肮脏的”IT工作排行榜
“肮脏的”IT工作排行榜
程序员都该阅读的书
程序员都该阅读的书
亲爱的项目经理,我恨你
亲爱的项目经理,我恨你
每天工作4小时的程序员
每天工作4小时的程序员
中美印日四国程序员比较
中美印日四国程序员比较
软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有