如何设计完全可扩展的应用 [转]

为什么80%的码农都做不了架构师？>>>   

设计一个完全可扩展的应用
作者：amir shevat
02/16/2005
翻译：simmone

版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
作者:
amir shevat;url=http://www.matrix.org.cn/user.s html?username=simmone]simmone[/url]
原文地址:
http://www.on java.com/pub/a/on java/2005/02/16/mediators. html
中文地址:
http://www.matrix.org.cn/resource/article/43/43853_mediators. html
关键词： 可扩展 应用


一个软件工程师在设计一个新的应用时有许多方面需要考虑，包括功能、性能、 安全性和图形化的用户界面( gui)。但是因为开始时有多种未知的和不可预测的变数导致了一些对你来说很难发现或集成到初始设计中的隐蔽因素，就像未来将会使用你的应用的用户数和他们的详细需求这样的因素。由于这样或那样的原因，你也许在将来的某个时候需要超出它最初的设计来扩充它的功能，换句话说，扩展它。举例来说，应用可能会处理超过它设计的更大的负载，这将会强迫你将你的应用拆分为部署在不同计算机上的更小的应用。

这篇文章提供了创建这种应用的指导方针：为将来某个时候扩展应用做好准备。这些凭借经验的规则将会使你的应用先从小规模开始，然后再根据需要来扩展它。另外，这篇文章将会介绍一组由m antaray提供的新工具，它是一个基于点对点，无 服务器架构的，革新的， 开源的数据消息项目。
作为例子，我们将会用到一个简单的应用叫 webmonitor(网页监听器)。它最初是一个非常简单的使用 swing编写的 gui。应用从用户那里得到一个url作为输入，并检查该url是否对http请求有响应。应用将会不时地监听该url，并提供它的最新的状态报告。

图1显示了 webmonitor范例的 gui界面。


图1。 webmonitor范例应用的 gui

模块化
第一条规则是将你的应用拆分为模块：代码块作为独立的实体显示，每一个实体都有它自己明确的责任。一个模块可以由一个或多个对象构成，但反过来不行—一个对象封装多个模块是一种不佳实践（在“解藕模块”部分，我们将会说明原因）

很容易看出在 webmonitor应用中至少有两个模块。首先，一个 gui模块负责取得用户输入和显示结果。其次，一个引擎模块负责检查url，并提供一个返回结果表明这个url是否响应。

图2显示了 webmonitor中的模块


图2. webmonitor中的模块

实际上，有人可以指出第三个模块，一个“模型”模块，它就象一个数据存储设备；当数据改变时，它通知“监听者”模块，这样就完整地构成了mvc结构。这个范例的其余部分已经通过忽略第三模块而有意简化了，我们只集中注意力在引擎和 gui模块上。

在你的应用中把模块标识出来是必须的，如果你还想在将来扩展你的应用的话。当时机来到的时候，模块可以被扩展并被分解为更小的应用；这篇文章的后面我们会讲到如何分解它们。

解藕模块
回到我们的例子，让我们想象一下过了一段时间， webmonitor已经很成功了。你的客户非常高兴，但又要求你创建其它的用户接口。it部想要一个命令行的用户接口，支持部想要一个基于 web的用户接口，而开发者则想要保持 swing gui。要想全部完成上述需求，你需要解藕 webmonitor的模块。
为了解藕模块，我们必须确认每一个模块是一个独立的实体。每一个完成解藕的模块必须是一个“黑盒子”，它有着一个明确定义的接口来和其它模块进行通信。
我们看一下 webmonitor并把它拆成若干个解藕的模块

图3显示了 webmonitor的解藕模块

图3 webmonitor中的解藕模块

模块间通过一个中间模块来相互通信，这样就将模块解藕并消除了一个模块所拥有的其它模块的信息。你可以把这些中间层当成模块间的缓冲区。虽然在这一阶段这些中间层看起来并不重要，但是在这篇文章的下一节它们就变得至关重要了。

当我们完成解藕以后，按客户的要求来增加用户界面就变得容易了。必须的模块加入到 webmonitor中，并在需要时与旧模块进行通信。

图4是增加模块以后的 webmonitor

图4 增加完模块以后的 webmonitor

扩展应用

webmonitor应用到目前为止很成功；它监听几千个站点并为几百个用户服务。然后你开始得到报告说应用的响应正在变慢，看起来好像引擎占用了太多的内存并且cpu已达到了机器的极限，客户想要增加监听的url,但是不行，因为机器崩溃了。

你所为应用所做工作―标识出了模块并用中间层将它们解藕―马上就可以得到回报了。既然你已把 webmonitor设计为从头开始扩展，那么现在可以很简单的将引擎放在不同的机器上，甚至可以创建多个引擎并在其上分配负载。因为模块已被中间层解藕，你不需要在模块内部重写代码，但对应的，你只需简单的使用不同的中间层。这样做，你可以无缝地将你的分布式的应用扩展到很多计算机且可以轻松地应对沉重的负载。

图5显示了 webmonitor分布在了几个机器上

图5 webmonitor分布在了几个机器上

你可能已经注意到了，中间层并没有放在任何机器上，因为它们是可以从任何机器上引用的逻辑实体。
下一节将介绍由m antarav 开源项目组提供的一组中间层,它们可以在内存中或是在一个扩展的分布式环境下工作。使用这些中间层，扩展应用不需要改变任何代码。

扩展的stage模式和dispatcher模式

m antaray提供了两种中间层，点到点（stage 模式）和发布－订阅（dispatcher 模式），它们针对不同的中间层需求。合在一起，它们组成一个完整的集合，可以满足这篇文章中所有中间层需求。

stage
seda项目定义了一个stage式事件驱动架构，引入了用于模块交互的一个解藕良好的模型，其中，stage被用来作为模块间的中间层。模块将事件排队放入stage中，其它的模块作为操作者来接收stage中的事件，然后触发操作。这些模块当需要的时候，反过来也会将事件排队放入stage队列中。

图6显示了拥有一个stage的解藕模块

图6. 用stage解藕

m antaray项目将stage的概念提升到了更高层次。模组通过工厂(factory)对象得到一个stage的引用。工厂会动态地生成合适的实现，这依赖于stage是在一个分布式环境中还是在内存中。
几个模块（或同一模块的几个实例）可以将他们自己作为操作者加到同一个stage上，但是一个事件会且只会送给一个操作者。一个事件可以是实现了标记性接口serializable的任意对象。大多数对象能被序列化，但像 socket和outputstream这样的对象不能被序列化，因为实际上他们不能通过网络传递。你可以把这个标记性接口给任意对象加上而不需要增加任何方法。

在 webmonitor的例子中， gui模组通过一个stage将一个请求发送给了引擎，让其监听一个url。引擎将它们自己注册为stage的操作者，stage反过来由于其中间层的角色也成为了一个软件负载的平衡者。

dispatcher
dispatcher与一个stage非常类似，但有一个显著区别。与stage事件有且只有一个操作者不同，一个dispatcher事可以被送给所有的操作者，如果它们将自己注册到了dispatcher上。这样，一个dispatcher就作为一个一对多的中间层来工作。

图7 显示了使用了dispatcher的解藕模组

图7. 用dispatcher解藕

应用到事件上的相同的角色被dispatcher分发，就像排队到stage上的事件一样。另外，算法通过工厂（和用来获得stage的引用的一样）来得到dispatcher的引用。

在 webmonitor例子中，引擎通过dispatcher告知 gui关于所监控的url状态改变的信息。所有的 gui模块将他们自己都注册为发布者的操作者，他们都会得到所监听url状态改变的通知。
下面是一个简短的代码示例： gui、引擎如何与stage、dispatcher集成在一起：

gui代码

   import org.mr.api.blocks.scalabledispatcher;
    import org.mr.api.blocks.scalablefactory;
    import org.mr.api.blocks.scalablehandler;
    import org.mr.api.blocks.scalablestage;
    ...
    public class webmonitorgui implements actionlistener
    , scalablehandler{    
// 输入的url被检查
    jtextfield urlinput;
         
// 从外面指向引擎的stage
    public scalablestage enginestage;
    
     // 从引擎而来的内置dispatcher
    public scalabledispatcher guidispatcher;
    
/**
 * gui分别得到一个对内的dispatcher和对外的stage的引用，
*  分布式的参数被传至这些对象的工厂。
 * @param distributed. 如果布尔值为真则表示这个范例是运行在
 *  分布式的环境中，引擎是分布在了不同的虚拟机上。
 */
    public webmonitorgui(boolean distributed){
        // 从工厂中得到stage
        enginestage = scalablefactory.getstage("engine"
            , distributed);
        // 从工厂中得到dispatcher
        guidispatcher = scalablefactory.getdispatcher(
            "gui", distributed);
        
        // 将这个对象注册为所有即将发生事件的处理器
        guidispatcher.addhandler(this);
    }
    
    /**
     * 开始swing gui      */
    public void startgui(){
//确信我们已经有了不错的gui         ..
}
 //开始gui     
    /**
     * 当用户把url的输入通过stage送到引擎时，这个方法被调用。
     */
    public void actionperformed(actionevent e) {
        enginestage.queue(urlinput.gettext());
        
    }
    
    /**
     * 这是一个scalablehandler接口的实现方法。当收到从引擎而来
     * 的一个事件时被调用，更新显示。
     */
    public void handle(object event) {
        hashmap result = (hashmap) event;
        iterator urls = result.keyset().iterator();
        while(urls.hasnext()){
            string url = (string) urls.next();
            string status = (string) result.get(url);
            updateurlstatus(url,status);
        }    
    }
    
}//webmonitorgui

引擎

  

  import org.mr.api.blocks.scalabledispatcher;
    import org.mr.api.blocks.scalablefactory;
    import org.mr.api.blocks.scalablehandler;
    import org.mr.api.blocks.scalablestage;
    ...
    
    public class webmonitorengine extends thread
     implements scalablehandler {
     
     //对内的stage。引擎从这个stage中得到url
    public scalablestage enginestage;
    
     // 对外的发布者。引擎返回一个结果map给这个发布者。
    public scalabledispatcher guidispatcher;
    
    // 结果map
    public hashmap urlstostatus = new hashmap();
    
    /**
* @param distributed. 如果布尔值为真则表示这全示例是运行在
 *  分布式的环境中，引擎是分布在了不同的虚拟机上。
     */
    public webmonitorengine(boolean distributed){
    
        //得到对内的stage并注册为处理器
        enginestage = scalablefactory.getstage("engine"
            , distributed);
        enginestage.addhandler(this);
        // 得到对外的发布者
        guidispatcher = scalablefactory.getdispatcher(
            "gui", distributed);
    }
    
    /**
     * 这是一个scalablehandler的实现方法。当stage从gui 
     * 收到事件（发出请求）时调用，将url加入到“待检查的”的
     * map—urlstostatus中。
     */
    public  void handle(object event) {
            // 这个事件是一个像”java.sun.com”的字符串
            string urlstr = (string) event;
            // 将url放入map中等待检查
            urlstostatus.put(urlstr, "checking");
        }
        
    }
    
    /**
     * 引擎是一个线程，它检查url并生成关于状态改变的报告
     */
    public void run(){
        while(true){
            hashmap result= geturlnewstatus();
                // 如果结果不为空时发布它
                if(!result.isempty())
                    guidispatcher.dispatch(urlstostatus);
            }// while
        }// run
        
    }
}//webmonitorengine

使用了stage和dispatcher技术的 webmonitor的完整例子可以在m antaray的最新版本上的范例文件夹中找到。这篇文章为了让它更适合章的格式将代码简化了。

总结
我们都希望这样的成功：我们的客户喜欢我们开发的软件并且被广泛的使用，但是我们必须确信我们已经为这样的成功作好的准备。我们必须为那样的时刻的到来预先作好计划：几百万的用户愉快地使用着我们的产品，它能优雅地，灵活地扩展来满足负载的增加，需求的修改和功能的增加。

m antaray的可扩展的工具集让这一切变简单了：创建一个应用，它为不用修改的从第一天的基础上扩展作好了准备。一个factory动态地生成所需的解藕的模块实现，不管它是分布式的或是在内存中，这样就无缝地将一个小规模的应用转换成了一个企业级的应用。

资源
m antaray在sourceforge 上的项目主页
m antaray的主页
seda 项目
mvc结构

amir shevat是一个在计算领域有着八年经验的高级软件开发者

转载于:https://my.oschina.net/digerl/blog/10794