设计模式（八）状态模式

状态模式：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。看起来，状态模式好像是神通广大很厉害似的——居然能够“修改自身的类”！下面让我们一起来看一下他的厉害吧！

适用场景：

       状态模式主要解决的是当控制一个对象状态装换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判 断逻辑简单化。当一个对象行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式了。

要点：

1． 策略模式和状态模式是双胞胎，它们有相同的类图，但是它们的意图不同。策略模式是围绕可以互换的算法来成功创建业务的,然而状态模式是通过改变对象内部的状态来帮助对象控制自己的行为.

2． Context将与状态相关的操作委托给当前的Concrete State对象处理。

3． Context可将自身作为一个参数传递给处理该请求的状态对象。这使得状态对象在必要时可访问Context。

4． Context或Concrete State类都可决定哪个状态是另外哪一个的后继者，以及是在何种条件下进行状态转换。也就是说可以在State中保存对Concrete State的引用，在必要时设置具体的状态，做到状态的转换。

5． 一般来讲，当状态转换是固定的时候，状态转换就适合放在Context中。然而，当转换是更动态的时候，通常会放到具体的状态类中进行。（具体状态类持有Context的引用，实现状态的转换）

Context类：维护一个ConcreteState子类的一个实例，这个实例定义当前的状态。

State类：抽象状态类，定义一个 接口以封装与Context的一个特定状态相关的行为。

ConcreteStateA,ConcreteStateB类：具体状态类，每一个子 类实现一个与Context的一个状态相关的行为。

具体实现：

 先定义接口UserState 

[java]  view plain copy print ?

1. 1 public interface UserState {    
2.   
3. 2 public UserService userService = new UserService();    
4.   
5. 3 // 状态为0代表普通用户,这些状态主要用于持久化到数据    
6.   
7. 4 public final static int COMMON_STATUS = 0;    
8.   
9. 5 // 状态为1代表待审核用户    
10.   
11. 6 public final static int FOR_VERIFY_STATUS = 1;    
12.   
13. 7 // 状态为2是代表vip用户    
14.   
15. 8 public final static int VIP_STATUS = 2;    
16.   
17. 9     
18.   
19. 10 // 提交信息    
20.   
21. 11 public void submit() throws Exception;    
22.   
23. 12     
24.   
25. 13 // 审核没通过    
26.   
27. 14 public void rollback() throws Exception;    
28.   
29. 15     
30.   
31. 16 // 审核通过    
32.   
33. 17 public void pass() throws Exception;    
34.   
35. 18     
36.   
37. 19 public int getStatus();    

代表各个状态的类 
未提交信息的用户NotSubmitUser.java 

 

   

[java]  view plain copy print ?

1. 2 public class NotSubmitUser implements UserState {    
2.   
3. 3     public void pass() throws Exception {    
4.   
5. 4         throw new Exception("no support method");    
6.   
7. 5     }    
8.   
9. 6     
10.   
11. 7     public void rollback() throws Exception {    
12.   
13. 8         throw new Exception("no support method");    
14.   
15. 9     }    
16.   
17. 10     
18.   
19. 11     public void submit() throws Exception {    
20.   
21. 12         User user = userService.getUser(0);    
22.   
23. 13         user.setStauts(FOR_VERIFY_STATUS);    
24.   
25. 14         userService.update(user);    
26.   
27. 15     }    
28.   
29. 16     
30.   
31. 17     public int getStatus() {    
32.   
33. 18         return COMMON_STATUS;    
34.   
35. 19     }    
36.   
37. 20 }    

待审核的用户WaitForVerifyUser.java 

Java代码  

  

[java]  view plain copy print ?

1. 22 public class WaitForVerifyUser implements UserState {    
2.   
3. 23     
4.   
5. 24     public void pass() throws Exception {    
6.   
7. 25         User user = userService.getUser(0);    
8.   
9. 26         user.setStauts(VIP_STATUS);    
10.   
11. 27         userService.update(user);    
12.   
13. 28     }    
14.   
15. 29     
16.   
17. 30     public void rollback() throws Exception {    
18.   
19. 31         User user = userService.getUser(0);    
20.   
21. 32         user.setStauts(COMMON_STATUS);    
22.   
23. 33         userService.update(user);    
24.   
25. 34     }    
26.   
27. 35     
28.   
29. 36     public void submit() throws Exception {    
30.   
31. 37         throw new Exception("no support method");    
32.   
33. 38     }    
34.   
35. 39     
36.   
37. 40     public int getStatus() {    
38.   
39. 41         return VIP_STATUS;    
40.   
41. 42     }    
42.   
43. 43 }    

审核通过的用户，vip VipUser.java 

   

[java]  view plain copy print ?

1. 45 public class VipUser implements UserState {    
2.   
3. 46     
4.   
5. 47     public void pass() throws Exception {    
6.   
7. 48         throw new Exception("no support method");    
8.   
9. 49     }    
10.   
11. 50     
12.   
13. 51     public void rollback() throws Exception {    
14.   
15. 52         User user = userService.getUser(0);    
16.   
17. 53         user.setStauts(COMMON_STATUS);    
18.   
19. 54         userService.update(user);    
20.   
21. 55     }    
22.   
23. 56     
24.   
25. 57     public void submit() throws Exception {    
26.   
27. 58         throw new Exception("no support method");    
28.   
29. 59     }    
30.   
31. 60     
32.   
33. 61     public int getStatus() {    
34.   
35. 62         return FOR_VERIFY_STATUS;    
36.   
37. 63     }    
38.   
39. 64 }    

根据用户的status的返回不同的UserState 

 

 

[java]  view plain copy print ?

1. 66 public class UserStateFactory {    
2.   
3. 67     static List list = null;    
4.   
5. 68     static {    
6.   
7. 69         list = new ArrayList();    
8.   
9. 70         list.add(new NotSubmitUser());    
10.   
11. 71         list.add(new VipUser());    
12.   
13. 72         list.add(new WaitForVerifyUser());    
14.   
15. 73     
16.   
17. 74     }    
18.   
19. 75     
20.   
21. 76     public static UserState getUserState(int status) {    
22.   
23. 77         for (UserState state : list) {    
24.   
25. 78             if (state.getStatus() == status)    
26.   
27. 79                 return state;    
28.   
29. 80         }    
30.   
31. 81         return null;    
32.   
33. 82     }    
34.   
35. 83 }    

     状态模式操作是固定的，但是接受者类不相同。多态性的原则实际执行哪个方法不仅取决与方法签名，还取决与操作的接受者类。 

该例子只是state模式的一个场景的应用，比较具体。 
状态模式的优点：

1.非常好的扩展性---假设增加一个用户组：当vip用户的信用达到一定程度后，升级到永久的vip。这时只需另外添加一个状态类，对原来的代码并不需要做改动。 
2.代码结构清晰，不同出错。即程序健壮--除UserStateFactory的getUserState(int status)外，其他方法的逻辑非常的简单，都不包含局部变量。如果程序不需要持久化到数据库，也不需要getUserState(int status)，该方法是状态模式内容之外的 。用状态模式类的数量会大大的增加。 

说明：该例子只是状态模式的一个应用，并不是状态模式，是属于比较具体