设计模式初探-状态模式

状态模式(STATE)，别名状态对象(Objects for States)，允许一个对象在其内部状态改变时改变它的行为，看起来就像修改了它的类，属于对象行为型模式。状态模式通过将所有与特定状态相关的行为封装到一个或多个状态对象中，当状态改变时，其行为也会随着改变，从而简化大量的条件判断，使代码逻辑更清晰，更易于维护。大千世界，可以看做各个状态的转换。人，生老病死；水，固液气三态转化；天气，阴晴不定。就是这些状态的变换构成了奇妙的世界。玩个游戏都还分低中高级呢，所以状态模式用途大大地。

一、使用场景

1、一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为。俗话说小孩的脸，六月的天，说变就变。他高兴的时候手舞足蹈，伤心的时候大哭大闹，小孩的行为随着心情而改变。

2、一个操作中含有大量的多分支条件语句，且这些分支依赖于该对象的状态。状态模式将这些条件分支封装到多个状态类中，这些类可以独立变化。

3、封装状态转换的规则。状态模式中，各状态之间的转换即可以由状态类自己把握，也可以由环境类控制，集中而不失灵活。

二、UML图

三、Java实现

[java]  view plain  copy

1. package study.patterns.state;  
2. /** 
3.  * 状态模式:将一个对象在不同状态下的不同行为封装在一个个状态类中， 
4.  * 通过设置不同的状态对象可以让环境对象拥有不同的行为， 
5.  * 而状态转换的细节对于客户端而言是透明的，方便了客户端的使用。 
6.  * @author qbg 
7.  * 此处示例由于对TCP协议了解不深，实现不是多恰当，望包涵！ 
8.  */  
9. public class StatePattern {  
10.     public static void main(String[] args) {  
11.         TCPConnection connection = new TCPConnection();  
12.         connection.activeOpen();  
13.         connection.close();  
14.     }  
15. }  
16. /** 
17.  * TCP连接，维持一个TCP状态对象，并将请求转发给该对象。  
18.  */  
19. class TCPConnection{  
20.     private TCPState state;  
21.       
22.     /** 
23.      * 默认建立的TCP连接是关闭状态 
24.      */  
25.     public TCPConnection(){  
26.         state = TCPClosed.instance;  
27.     }  
28.       
29.     /** 
30.      * 主动发起打开连接请求 
31.      */  
32.     public void activeOpen(){  
33.         state.activeOpen(this);  
34.     }  
35.     /** 
36.      * 被动接受打开连接请求 
37.      */  
38.     public void passiveOpen(){  
39.         state.passiveOpen(this);  
40.     }  
41.     /** 
42.      * 关闭连接 
43.      */  
44.     public void close(){  
45.         state.close(this);  
46.     }  
47.     /** 
48.      * 发送确认码(ACK码) 
49.      */  
50.     public void acknowledge(){  
51.         state.acknowledge(this);  
52.     }  
53.     /** 
54.      * 发送连接请求 
55.      */  
56.     public void send(){  
57.         state.send(this);  
58.     }  
59.       
60.     /** 
61.      * 改变TCP连接状态 
62.      */  
63.     public void changeState(TCPState state){  
64.         System.out.println(this.state+" ===> "+state);  
65.         this.state = state;  
66.     }  
67.       
68.     /** 
69.      *  处理流数据  
70.      */  
71.     public void processOCtet(String stream){  
72.         System.out.println("传输流数据:"+stream);  
73.     }  
74. }  
75. /** 
76.  * TCP状态抽象类，定义了状态的公共行为，并针对所有委托给它的请求实现缺省的行为。  
77.  */  
78. abstract class TCPState{  
79.     /** 
80.      * 传输请求的流数据(包含各种校验码) 
81.      */  
82.     public void transmit(TCPConnection connection,String data){}  
83.     /** 
84.      * 主动发起打开连接请求 
85.      */  
86.     public void activeOpen(TCPConnection connection){}  
87.     /** 
88.      * 被动接受打开连接请求 
89.      */  
90.     public void passiveOpen(TCPConnection connection){}  
91.     /** 
92.      * 关闭连接 
93.      */  
94.     public void close(TCPConnection connection){}  
95.     /** 
96.      * 发送确认码(ACK码) 
97.      */  
98.     public void acknowledge(TCPConnection connection){}  
99.     /** 
100.      * 发送连接请求 
101.      */  
102.     public void send(TCPConnection connection){}  
103.     /** 
104.      * 根据当前状态，改变TCPConnection的TCP连接状态  
105.      */  
106.     public void changeState(TCPConnection connection,TCPState state){  
107.         connection.changeState(state);  
108.     }  
109. }  
110. /** 
111.  * TCP连接建立状态，可以传输数据，关闭连接等 
112.  */  
113. class TCPEstablished extends TCPState{  
114.     /** 
115.      * 无状态类，所以实例可以共享 
116.      */  
117.     public static TCPState instance = new TCPEstablished();  
118.   
119.     @Override  
120.     public void transmit(TCPConnection connection, String data) {  
121.         connection.processOCtet(data);  
122.     }  
123.       
124.     /** 
125.      * 关闭连接并切换状态 
126.      */  
127.     @Override  
128.     public void close(TCPConnection connection) {  
129.         System.out.println("Send FIN,receive ACK of FIN");  
130.         changeState(connection, TCPClosed.instance);  
131.     }  
132.       
133.     public String toString(){  
134.         return "Established";  
135.     }  
136. }  
137. /** 
138.  * TCP连接关闭状态，可以打开连接等 
139.  */  
140. class TCPClosed extends TCPState{  
141.     /** 
142.      * 无状态实例，可以共享 
143.      */  
144.     public static TCPState instance = new TCPClosed();  
145.   
146.     /** 
147.      * 主动建立连接,并改变状态 
148.      */  
149.     @Override  
150.     public void activeOpen(TCPConnection connection) {  
151.         System.out.println("Send SYN,receive SYN,ACK,etc.");  
152.         changeState(connection, TCPEstablished.instance);  
153.     }  
154.   
155.     /** 
156.      * 被动建立连接，并改变状态 
157.      */  
158.     @Override  
159.     public void passiveOpen(TCPConnection connection) {  
160.         changeState(connection, TCPListen.instance);  
161.     }  
162.       
163.     public String toString(){  
164.         return "Closed";  
165.     }  
166. }  
167. /** 
168.  * TCP监听状态，可以发送ACK，SYN，FIN等请求数据  
169.  */  
170. class TCPListen extends TCPState{  
171.     public static TCPState instance = new TCPListen();  
172.   
173.     /** 
174.      * 发送请求数据 
175.      */  
176.     @Override  
177.     public void send(TCPConnection connection) {  
178.         changeState(connection, TCPEstablished.instance);  
179.     }  
180.       
181.     public String toString(){  
182.         return "Listen";  
183.     }  
184. }  

运行结果：

[plain]  view plain  copy

1. Send SYN,receive SYN,ACK,etc.  
2. Closed ===> Established  
3. Send FIN,receive ACK of FIN  
4. Established ===> Closed  

四、模式优缺点

优点：

1、将于特定状态相关的行为局部化，并将不同状态的行为分割开来。状态模式将所有与某个特定状态相关的行为封装到一个状态对象中，这样通过添加新的子类可以很容易的增加新的状态和转换。

2、使状态转换显示化。状态模式中不同状态之间的转换是通过切换环境类中的变量来实现的，如TCPConnection类中的TCPState对象引用，而不是为多个变量赋值，这样确保状态转换的原子性，防止环境类Context内部状态不一致现象的发生。

3、State对象可以被共享。对于那些没有内部状态，只有行为的轻量级State对象，各Context对象可以共享一个State对象，从而减少对象的数量。

缺点：

1、由于每个状态对应一个对象，所以会导致系统中类和对象的个数增加。

2、状态模式的设计和实现比较复杂，增加系统的复杂度。