最近学习了设计模式的State模式，因为曾碰到过HTML的解析问题，正好需要使用状态机来分析，所以就尝试了使用State模式来写HTML的解析过程，虽然这有点杀鸡用牛刀的味道，但对设计模式的理解也有不少的收获，在此和大家分享一下。
 
一、HTML解析分析
        HTML解析基本上是要对每个字符进行判断，字符内容大概可以分以下几类:
  ： <
： >
： /
： =
： 字母
： 数字
： 下划线
： 汉字
  另外还有用于注释的<!--、-->，这里暂不处理。
对于HTML的解析可以用状态图来分析如下：
 
图（1）
    从上图可以看出，HTML的状态基本上是处理标签名、标签值和标签属性这三大类状态，如果再细分的话，标签名还可以再分为左标签名和右标签名，属性还可以再分为属性名和属性值，当然还有一些情况，如注释和一些错误的数据，这些细节就暂不考虑。
如果这里单单用一个switch的分支处理的话，代码就会很复杂，起码要用两层switch，第一层用于判断当前读取的字符，第二层需要判断当前的状态。伪代码如下：
  
 
   
  1.        do {  
  2.               char ch = *itChar;  
  3.               switch(ch)  
  4.               {  
  5.               case '<':  
  6.                      switch(State)  
  7.  {  
  8.  case 开始状态:  
  9.        开始处理…  
  10.        切换到左标签状态  
  11.  break;  
  12.  case 标签值状态:  
  13.       标签值状态处理…  
  14.       break;  
  15.  }  
  16.                      break;  
  17.               case '>':  
  18.                      switch(State)  
  19.  {  
  20.  case 左标签名状态:  
  21.         左标签名状态处理…  
  22.                             切换到标签名状态  
  23.                             break;  
  24.                      case 右标签名状态:  
  25.                             右标签名状态处理…  
  26.                             break;  
  27.  }  
  28.  break;  
  29.  …  
  30.  }  
  31.  } while(字符串读取未结束)  
 
   
 
 
   
 
 
   

         第二层的每个分支都可以写成一个函数，如果有状态增加的话，那么就要增加case的分支处理。 
   
 
   

     是否有更好的方法可以不用switch语句呢？当然你会说，可以使用循环处理，照个思路的话，那就要为循环处理建立一张映射表，用于进行状态的切换。如果不用映射表呢，有什么好的办法么。 
   
 
   

       
   
 
   
 
    二、state模式 
   
 
   

             设计模式中的State模式就可以很好的解决这个问题，当然这里面就要用到很多的类。我们先看下面的关系图 
   
 
   
 
    
  
 
    

      图（2） 
    
 
    

          首先解释下上图，这里起码要建立三个类，Context、State、和ConcreteStateX： 
    
 
    

      Context是负责执行状态处理的，它包含了一个State*的基类指针，当每次进行状态处理时，就调用Request，而在Request中会通过State*这个基类指针调用ConcreteStateA或ConcreteStateB对象的Handle()。我们可以把一种状态写成一个ConcreteStateX对象，然后把处理放在Handle里面，这样只要循环调用Request()就可以完成所有状态处理。这时，你也许就要问了，状态和状态直接的切换如何实现呢？关键就在这里，因为在Context里有个State*，我们只需要更改State*所指的对象就可以了。那么什么时候更改这个指针呢，我们可以把这个处理放在Handle里面，当我们需要切换状态时，调用State中的ChangeState(…, state : State *)方法，通过参数将State对象传入（参见代码），然后更改Context中的State*指针，这里需要注意的是，在Context里面需要将State声明为firend，这样做的好处就是可以直接访问Context中的私有字段，而将其他的类拒之门外。我们在Context里面还加了个方法ChangeState，当然也可以直接赋值，不调用这个方法，但这样写有个好处，我们待会再讲。 
    
 
    

              讲到这里，你也许会问了，一个状态就要用一个类，那么状态多了就要创建很多个类对象，这么多个类对象如何管理呢，一个比较简单的方法就是将每个状态类用单例实现，这样就不需要关心对象的创建和释放。还有一种方法是使用工厂模式，将这些类集中创建，集中释放。但是你是否考虑到释放的环节呢，在什么地方释放是最合适的。对了，就在我们刚才提到的ChangeState中，当我们重新赋值state时，就可以把前面的一个State对象给delete掉，如果是单例，就调用Release()方法，这样对需要使用大量内存的状态对象时是很有好处的。 
    
 
    
 
            如果你明白以上的内容，那么下面的代码你就很容易能看明白了： 
    
 
    
 
        

          //state.h 
        
 
        

          #ifndef 
         _STATE_H_  
        
 
        

          #define 
         _STATE_H_  
        
 
        

          class 
         Context; //前置声明 
        
 
        

          class 
         State  
        
 
        

          { 
        
 
        

          public: 
        
 
        
 
                State();  
        
 
        
 
                virtual ~State();  
        
 
        
 
                virtual void Handle(Context* ) = 0;  
        
 
        

          protected: 
        
 
        
 
                bool ChangeState(Context* con,State* st);  
        
 
        

          }; 
        
 
        

          class 
         ConcreteStateA:public State  
        
 
        

          { 
        
 
        

          public: 
        
 
        
 
                ConcreteStateA() {};  
        
 
        
 
                virtual ~ConcreteStateA() {};  
        
 
        
 
                virtual void Handle(Context* );  
        
 
        

          }; 
        
 
        

          class 
         ConcreteStateB:public State  
        
 
        

          { 
        
 
        

          public: 
        
 
        
 
                ConcreteStateB() {};  
        
 
        
 
                virtual ~ConcreteStateB() {};  
        
 
        
 
                virtual void Handle(Context* );  
        
 
        

          }; 
        
 
        

          #endif 
         //~_STATE_H_ 
        
 
        

            
        
 
 
    

        
    
 
    
 
        

          //state.cpp 
        
 
        

          #include 
         "Context.h"  
        
 
        

          #include 
         <iostream> 
        
 
        

          using 
         namespace std;  
        
 
        

          void 
         State::Handle(Context* con)  
        
 
        

          { 
        
 
        
 
                cout<<"State::.."<<endl;  
        
 
        

          } 
        
 
        

          bool 
         State::ChangeState(Context* con,State* st) 
        
 
        

          { 
        
 
        
 
                con->ChangeState(st);  
        
 
        
 
                return true;  
        
 
        

          } 
        
 
        

          void 
         ConcreteStateA::Handle(Context* con)  
        
 
        

          { 
        
 
        
 
                cout<<"ConcreteStateA::OperationInterface......"<<endl;  
        
 
        
 
                this->ChangeState(con,new ConcreteStateB());  
        
 
        

          } 
        
 
        

          void 
         ConcreteStateB::Handle(Context* con)  
        
 
        

          { 
        
 
        
 
                cout<<"ConcreteStateB::OperationInterface......"<<endl;  
        
 
        
 
                this->ChangeState(con,new ConcreteStateA());  
        
 
        

          } 
        
 
 
    

        
    
 
    
 
        

          //context.h 
        
 
        

          #ifndef 
         _CONTEXT_H_  
        
 
        

          #define 
         _CONTEXT_H_  
        
 
        

          class 
         State;  
        
 
        

          class 
         Context  
        
 
        

          { 
        
 
        

          public: 
        
 
        
 
                Context();  
        
 
        
 
                Context(State* state);  
        
 
        
 
                ~Context();  
        
 
        
 
                void Request();  
        
 
        

          protected: 
        
 
        

          private: 
        
 
        
 
                friend class State; //表明在 
         State类中可以访问Context类的private字段 
        
 
        
 
                bool ChangeState(State* state);  
        
 
        

          private: 
        
 
        
 
                State* _state;  
        
 
        

          }; 
        
 
        

          #endif 
         //~_CONTEXT_H_ 
        
 
 
    

        
    
 
    
 
        

          //context.cpp 
        
 
        

          #include 
         "stdafx.h" 
        
 
        

          #include 
         "Context.h"  
        
 
        

          #include 
         "State.h"  
        
 
        

          Context:: 
         Context()  
        
 
        

          { 
        
 
        

          } 
        
 
        

          Context:: 
         Context(State* state)  
        
 
        

          { 
        
 
        
 
                this->_state = state;  
        
 
        

          } 
        
 
        

          Context::~ 
         Context()  
        
 
        

          { 
        
 
        
 
                delete _state;  
        
 
        

          } 
        
 
        

          void 
         Context::Request()  
        
 
        

          { 
        
 
        
 
                _state->Handle(this);  
        
 
        

          } 
        
 
        

          bool 
         Context::ChangeState(State* state)  
        
 
        

          { 
        
 
        
 
                if (_state) delete _state; 
        
 
        
 
                _state = state;  
        
 
        
 
                return true;  
        
 
        

          } 
        
 
 
    

        
    
 
    
 
        

          //测试代码 
        
 
        

          int 
         StateTest()  
        
 
        

          { 
        
 
        
 
                State* st = new ConcreteStateA();  
        
 
        
 
                Context* con = new Context(st);  
        
 
        
 
                con->Request(); 
        
 
        
 
                con->Request(); 
        
 
        
 
                con->Request(); 
        
 
        
 
                if (con != NULL)  
        
 
        
 
                       delete con;  
        
 
        
 
                if (st != NULL)  
        
 
        
 
                       st = NULL;  
        
 
        
 
                return 0;  
        
 
        

          } 
        
 
 
    

        
    
 
    

             故事讲到这里，还没有结束呢，从图（1）我们可以看到，每个状态常会带个Entry处理和Exit处理，在进入状态和离开状态时，我们经常会需要进行一些处理，因为每个状态会有重复状态的处理，我们把重复性的处理单独分离出来。具体实现的时候，有三种方案： 
    
 
    

      一、我们可以在调用Request之前调用Entry方法()，并且加上一个状态判断，检查是否是同一个状态，这样就需要加个额外的变量记录当前的状态。Exit()方法则可以加在State::ChangeState()的方法中在调用Context::ChangState()之前调用，这样就可以了。 
    
 
    

      二、将每个状态类用单例实现，在类的构造中调用Entry(),在析构中调用Exit(),这样在ChangeState中调用对象的Release()即可调用Exit()，Entry可以在对象的Instance()时被调用，这种方法遗留了一个缺陷，下个状态的Entry会在上个状态的Exit()前被调用。 
    
 
    

      三、可以通过使用工厂模式，在类的构造中调用Entry(),在析构中调用Exit(),当然这就需要在ChangeState中调用delete和new了，既然使用了工厂模式，那么在调用ChangeState的传入的参数就不需要使用对象了，而是可以是状态ID，在Constext::ChangeState里，先delete掉前一个状态对象，然后再调用new创建新的对象，这样代码就比较完美了。 
    
 
    
 
         State模式的应用心得就讲到这里了，HTML的代码如何实现就不是这么简单了，而解析过程只是为了显示HTML服务，这只是实现的一部分，而真正要实现HTML的浏览难就更复杂了，使用栈处理可能会高效一些，这里我们只是将其作为State的一个应用来描述。设计模式里的各个模式都不是孤立的，需要针对具体情况搭配的使用，在一个代码里可能会用到若干种模式，善用这些对提高代码的质量和可复用性很有好处。您如果有什么更好的建议和想法，请不吝赐教，或对我的描述有什么疑问或错误的，也请慷慨指出。