Chinaunix首页 | 论坛 | 博客
  • 博客访问: 572854
  • 博文数量: 155
  • 博客积分: 4015
  • 博客等级: 上校
  • 技术积分: 1625
  • 用 户 组: 普通用户
  • 注册时间: 2005-11-18 16:55
文章分类

全部博文(155)

文章存档

2009年(20)

2008年(39)

2007年(66)

2006年(29)

2005年(1)

我的朋友

分类: 项目管理

2007-12-05 10:19:01

  设计模式中的观察者(Observer)模式我个人觉得是蛮好玩的。原因是原本这个模式并不难,道理也较容易懂,但就是这样我也是看了好几次才明白这个模式的用意是什么。其实模式本质真的是可以跨语言,很多时候模式是种思想:"重用,解耦合"。这种思想在GOF提出的23种模式中无处不在。
  Observer,观察者模式。它还有个别名叫:发布--订阅.这个别名比较形象。时常上网的朋友都会在网上订一些网络杂志/消费记录通知等等。比如我就订了移动公司的每月话费清单,还订了天极网的每周杂志。正是这种服务商提供订阅,而消费者订阅相应的服务构成了观察者的雏形。
  作为构建软件的你,或许更关心这些发布--订阅是怎么实现的。发布--订阅的真正好处是:可重用,松耦合。我们先来看看可重用。
  可重用,无论对发布者(移动公司)或是消费者(订阅话费清单的人)来说。从软件角度来说他们都是可重用的,这体现在。发布者可以稍稍改动一下把话费清单改为积分通知,重用了原来的话费清单模块。订阅者也稍稍改动一下订阅联通公司的话费清单。这样在软件中,你重用发布部分也好,重用订阅人也好,随你.
  松散耦合,移动公司新增了积分通知——你并不知道,也不需要知道。你订阅了联通公司的话费清单——移动公司并不知道,也不需要知道。
  现在可以对号入座了,我们消费者就是观察者(Observer).我们观察我们每个月的消费记录。移动公司提供订阅的主题(Subject).我们先来看看Observer以及Subject都能做哪些事情。
  Observer只需(被通知)话费清单已到.
 

class Observer
{
public:
    virtual void Received()=0; //收到通知后动作,阅读话费清单
};

 
 Subject(移动公司),需提供
    1,一个接口让用户订阅话费清单(添加已订阅用户列表);
    2,一个接口让用户取消订阅话费清单(更新已订阅用户列表);
    3,发出通知告诉订阅用户话费清单已到.
 

class Subject
{
public:
    //Support Subscribe/Unsubscrible
    virtual void Attach(Observer* o);
    virtual void Detach(Observer* o);

    virtual void Notify();   //发送通知
private:
    list<Observer*> observers//已订阅用户列表
};

  
   函数部分实现部分也很简单,提供上面所说的三种功能。
 

void Subject::Attach(Observer* o)
{
    observers.push_back(o);   //加至订阅用户列表
}
void Subject::Detach(Observer* o)
{
    observers.remove(o);     //从订阅用户列表中移除
}
void Subject::Notify()
{

     //通知所有订阅者
    list<Observer*>::iterator i
    for(i=observers.begin(); i!=observers.end(); i++)      {
        static_cast<Observer*>(*i)->Received(this);
    }
}

 
  现在我们定义出具体的一个Subject和具体的订阅人:
 

//定义一个具体Subject类(移动公司)
class Mobile:public Subject
{
public:
    Mobile(){ _checklist = "";};
    string GetChecklist();
    void SimulateChklst();
private:
    string _checklist;
};
void Mobile::SimulateChklst()
{
    cout<<"---------话费清单(Mobile.Suzhou)---------"<<endl;
    _checklist = "市话话费:17.52\t\t长途话费:57.00\n短信:5.00(包月)\t\t彩铃:2.00(包月)\n";
    Notify();
}
string Mobile::GetChecklist()
{
    return _checklist;
}
//定义一个具体观察者:Jerry --找移动公司订阅(到移动大厅让移动服务人员订阅)
class Jerry:public Observer
{
public:
    void Received(Subject* sender);
};
void Jerry::Received(Subject* sender)
{
    cout<<"Jerry收到话费通知:"<<endl
        <<static_cast<Mobile*>(sender)->GetChecklist()
        <<endl;
}
//定义另一个具体观察者:Anco --由观察者自已订阅(上网自助订阅)
class Anco:public Observer
{
public:
    void Subscribe(Subject *subject);
    void Unsubscrible(Subject *subject);
    void Received(Subject* sender);
private:
    Subject _subject;
};
void Anco::Received(Subject* sender)
{
    cout<<"Anco收到话费通知:"<<endl
        <<static_cast<Mobile*>(sender)->GetChecklist()
        <<endl;
}
void Anco::Subscribe(Subject *subject)    //自助订阅
{
    subject->Attach(this);
}
void Anco::Unsubscrible(Subject *subject//自助取消订阅
{
    subject->Detach(this);
}

 
  我们的类,看起来是下面这个样子的:
  其中需要注意那一段注释:
      for(all o in observers){
         o->Received();
      }
这段注释道出了Observer的另一个重点:由基类Notify统一维护各观察者的状态,这样可以确保观察者都可以得到通知。这给解耦合带来了绝佳的效果。
  我们再也不用担心,谁去维护这个状态,状态怎么样保持一致。
 
  现在我给出完整的代码:
 

//Platform: WinXP + VC6.0
#include <iostream>
#include <string>
#include <list>
using namespace std;
//--------------------------------------------------
//An abstract class define the Observer's interface
class Subject;
class Observer
{
public:
    virtual ~Observer(){};
    virtual void Received(Subject* sender)=0; //传入sender,支持多主题Subscribe
protected:
    Observer(){};
};
//An abstract class define the Subject's interface
class Subject
{
public:
    virtual ~Subject(){};

    //Support subcribe
    virtual void Attach(Observer* o);
    virtual void Detach(Observer* o);
    virtual void Notify();
public:
    Subject(){};
private:
    list<Observer*> observers;
};

void Subject::Attach(Observer* o)
{
    observers.push_back(o);
}
void Subject::Detach(Observer* o)
{
    observers.remove(o);
}
void Subject::Notify()
{
    list<Observer*>::iterator i;
    for(i=observers.begin(); i!=observers.end(); i++)
    {
        static_cast<Observer*>(*i)->Received(this);
    }
}
//--------------------------------------
//定义一个具体Subject类
class Mobile:public Subject
{
public:
    Mobile(){ _checklist = "";};
    string GetChecklist();
    void SimulateChklst();
private:
    string _checklist;
};
void Mobile::SimulateChklst()
{
    cout<<"---------话费清单(Mobile.Suzhou)---------"<<endl;
    _checklist = "市话话费:17.52\t\t长途话费:57.00\n短信:5.00(包月)\t\t彩铃:2.00(包月)\n";
    Notify();
}
string Mobile::GetChecklist()
{
    return _checklist;
}
//定义一个具体观察者:Jerry --找移动公司订阅(到移动大厅让移动服务人员订阅)
class Jerry:public Observer
{
public:
    void Received(Subject* sender);
};
void Jerry::Received(Subject* sender)
{
    cout<<"Jerry收到话费通知:"<<endl
        <<static_cast<Mobile*>(sender)->GetChecklist()
        <<endl;
}
//定义另一个具体观察者:Anco --由观察者自已订阅(上网自助订阅)
class Anco:public Observer
{
public:
    void Subscribe(Subject *subject);
    void Unsubscrible(Subject *subject);
    void Received(Subject* sender);
private:
    Subject _subject;
};
void Anco::Received(Subject* sender)
{
    cout<<"Anco收到话费通知:"<<endl
        <<static_cast<Mobile*>(sender)->GetChecklist()
        <<endl;
}
void Anco::Subscribe(Subject *subject)
{
    subject->Attach(this);
}
void Anco::Unsubscrible(Subject *subject)
{
    subject->Detach(this);
}
//------------Main函数------------------
int main()
{
    Mobile mobile;
    Jerry jerry;
    Anco anco;
    //订阅
    mobile.Attach(&jerry); //Subject添加Observer
    anco.Subscribe(&mobile); //Observer subscrible Subject;
     //本质就是向Subject维护的observers链表中加一条记录

    mobile.SimulateChklst();
    cout<<"\t[月底了...移动又该送话费清单啦:-)大家赶快看啊!]"<<endl;
    mobile.SimulateChklst();

    cout<<endl<<"\t[喏,Anco,取消订阅了...]"<<endl;
    anco.Unsubscrible(&mobile);
    mobile.SimulateChklst ();
    
    system("PAUSE");
    return 0;
}

 
  C#为观察者模式提供的便利:
 
  C#中的事件机制为实现观察者(Observer)提供了很好的支持,在C#中若一类提供了事件,则这个类就相当于发布了一个主题。
  在C#中若在一个类中定义了一个事件,则等于定义了一个委托+两个方法,对应于上面的Subject类就是定义了ObserverList成员用来存用户列表,两个方法分别对应Attach()和Detach().
  在C#中实现以上的观察者模式就要简单的多了,现给出代码:

//Platform: WinXP + C# in vs2003
using System;
namespace Class1
{    
    //-------------定义委托及事件传送的数据-------------
    internal class ChkLstEventArgs:EventArgs
    {
        private readonly string _checklist;
        public ChkLstEventArgs(string checklist)
        {
            _checklist = checklist;
        }
        public string Checklist
        {
            get{return _checklist;}
        }
    }
    internal delegate void PublishEventHandler(object sender, ChkLstEventArgs args);
   //--------------------定义抽象类---------------------
    internal class Subject
    {
        public event PublishEventHandler PublishChkLst;
        public void Notify(ChkLstEventArgs args)
        {
            if(PublishChkLst != null)
                PublishChkLst(this,args);
        }
    }
    internal abstract class Observer
    {
        public abstract void Received(object sender, ChkLstEventArgs args);
    }
    //------------------定义实体类----------------------
    class Mobile:Subject
    {
        public void SimulateChklst()
        {
            Console.WriteLine("---------话费清单(Mobile.Suzhou)---------");
            ChkLstEventArgs args = new ChkLstEventArgs("市话话费:17.52\t\t长途话费:57.00\n短信:5.00(包月)\t\t彩铃:2.00(包月)\n");
            base.Notify(args);
        }
    }
    class Jerry:Observer
    {
        public override void Received(object sender, ChkLstEventArgs args)
        {
            Console.WriteLine("Jerry收到话费通知:\n{0}",args.Checklist);
        }
    }
    class Anco:Observer
    {
        public void Subscribe(Subject sub)
        {
            sub.PublishChkLst += new PublishEventHandler(Received);
        }
        public void Unsubscrible(Subject sub)
        {
            sub.PublishChkLst -= new PublishEventHandler(Received);
        }
        public override void Received(object sender, ChkLstEventArgs args)
        {
            Console.WriteLine("Anco收到话费通知:\n{0}",args.Checklist);
        }
    }
    class ExcelProgram
    {
        [STAThread]
        static void Main(string[] args)
        {
            Mobile mobile = new Mobile();
            Jerry jerry = new Jerry();
            Anco anco = new Anco();

            //订阅
            mobile.PublishChkLst += new PublishEventHandler(jerry.Received); //Subject添加Observer
            anco.Subscribe(mobile); //Observer subscrible Subject;
                     //本质就是向Subject维护的observers链表中加一条记录


            mobile.SimulateChklst();
            Console.WriteLine("\t[月底了...移动又该送话费清单啦:-)大家赶快看啊]");
            mobile.SimulateChklst();
            Console.WriteLine("\t[喏,Anco,取消订阅了...]");
            anco.Unsubscrible(mobile);
            mobile.SimulateChklst ();

            Console.ReadLine();
        }
    }
}

 
  观察者模式应用相当广泛,因为他非常好用。当你看MVC模式时,你可以看到观察者模式。当你用VB,DELPHI编程时,对类似按钮的事件的处理也可以看到观察者的影子。
  引用GOF设计模式中的两段话作为总结:
 
  定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象
都得到通知并被自动更新。
  Observer模式描述了如何建立这种关系。这一模式中的关键对象是目标(Subject)和观察者(Observer)。一个目标可以有任意数目的依赖它的观察者。一旦目标的状态发生改变, 所有的观察者都得到通知。作为对这个通知的响应,每个观察者都将查询目标以使其状态与目标的状态同步。
 
 
 
 
 
 
 
 
 
 
 
 
Jerry.Chow
    12/5'07
阅读(2089) | 评论(1) | 转发(0) |
给主人留下些什么吧!~~

flandy19822008-01-18 09:43:41

不错,谢谢.