1.初识状态模式
- 定义
运行一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
-
结构和说明
Context：环境（上下文），通常用来定义客户感兴趣的接口，同时维护一个来具体处理当前状态的实例对象。
State：状态接口，用来封装与上下文的一个特定状态所对应的行为。
ConcreteState：具体实现状态处理的类，每个类实现一个状态的具体处理。
2.体会状态模式
实现在线投票
考虑一个在线投票的应用，要实现控制同一个用户只能投一票，如果一个用户反复投票，而且投票次数超过5次，则判定为恶意刷票，要取消该用户投票的资格，当然同时也要取消他所投的票。如果一个用户的投票次数超过8次，将进入黑名单，禁止再登录和使用系统。不用设计模式的解决方案
example1代码参考github
public class VoteManager {
private Map<String,String> mapVote = new HashMap<String,String>();
private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();
public void vote(String user,String voteItem){
Integer oldVoteCount = mapVoteCount.get(user);
if(oldVoteCount==null){
oldVoteCount = 0;
}
oldVoteCount = oldVoteCount + 1;
mapVoteCount.put(user, oldVoteCount);
if(oldVoteCount==1){
mapVote.put(user, voteItem);
System.out.println("恭喜你投票成功");
}else if(oldVoteCount>1 && oldVoteCount<5){
System.out.println("请不要重复投票");
}else if(oldVoteCount >= 5 && oldVoteCount<8){
String s = mapVote.get(user);
if(s!=null){
mapVote.remove(user);
}
System.out.println("你有恶意刷票行为，取消投票资格");
}else if(oldVoteCount>=8){
System.out.println("进入黑名单，将禁止登录和使用本系统");
}
}
}
测试代码：
public void ex1Test(){
VoteManager vm = new VoteManager();
for(int i=0;i<8;i++){
vm.vote("u1", "A");
}
}
- 使用设计模式来解决
example2代码参考github
把投票的状态和状态对于的行为从原来的大杂烩代码中分离出来，把每个状态所对应的功能处理封装在一个独立的类里面。
public class VoteManager {
/**
* 持有状态处理对象
*/
private VoteState state = null;
/**
* 记录用户投票的结果,Map<String,String>对应Map<用户名称,投票的选项>
*/
private Map<String,String> mapVote = new HashMap<String,String>();
/**
* 记录用户投票次数,Map<String,Integer>对应Map<用户名称,投票的次数>
*/
private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();
/**
* 获取记录用户投票结果的Map
* @return 记录用户投票结果的Map
*/
public Map<String, String> getMapVote() {
return mapVote;
}
/**
* 投票
* @param user 投票人，为了简单，就是用户名称
* @param voteItem 投票的选项
*/
public void vote(String user,String voteItem){
//1：先为该用户增加投票的次数
//先从记录中取出已有的投票次数
Integer oldVoteCount = mapVoteCount.get(user);
if(oldVoteCount==null){
oldVoteCount = 0;
}
oldVoteCount = oldVoteCount + 1;
mapVoteCount.put(user, oldVoteCount);
//2：判断该用户投票的类型，就相当于是判断对应的状态
//到底是正常投票、重复投票、恶意投票还是上黑名单的状态
if(oldVoteCount==1){
state = new NormalVoteState();
}else if(oldVoteCount>1 && oldVoteCount<5){
state = new RepeatVoteState();
}else if(oldVoteCount >= 5 && oldVoteCount<8){
state = new SpiteVoteState();
}else if(oldVoteCount>=8){
state = new BlackVoteState();
}
//然后转调状态对象来进行相应的操作
state.vote(user, voteItem, this);
}
}
3.理解状态模式
3.1 状态和行为
对象状态通常是指对象实例的属性值，行为值对于的功能，一般对应到方法。
状态模式的功能就是分离状态的行为，通过维护状态的变化，来调用不同状态对应的不同功能。
状态决定行为。
由于状态是在运行期被改变的，行为也会根据状态的改变而改变。看起来，在运行期不同时刻，同一对象的类就像是被修改了一样。
3.2 行为的平行性
平行性指的是各个状态的行为所处的层次是一样的，相互是独立的、没有关联的，是根据不同的状态来决定到底走平行线的哪一条，行为是不同的。相互之间不可替换。
平等性强调的是可替换性，是针对同一行为的不同描述或实现。
状态模式的结构和策略模式是一样的，但是它们的目的和本质是完全不一样的。
3.3 上下文和状态处理对象
在状态模式中，上下文是持有状态的对象，但是上下文自身并不处理跟状态相关的行为，而是把处理状态的功能委托给了状态对应的状态处理类来处理。
在具体的状态处理类中经常需要获取上下文自身的数据，甚至在必要时候会回调上下文的方法，因此，通常将上下文自身作为一个参数传递给具体的状态处理类。
客户端一般只和上下文交互，客户端可以用状态对象来配置一个上下文，一旦配置完毕，就不再需要和状态对象交互。
3.4 不完美的OCP
使用状态模式来修改和扩展功能，是没有完全遵守OCP原则的，由于状态的维护和转换在状态模式的结构里面，不管是扩展状态实现类，还是添加状态实现类，都需要修改状态维护和转换的地方。
3.5 创建和销毁对象
究竟何时创建和销毁状态对象：
- 1）当需要使用状态对象时创建，使用完后就销毁
- 2）提前创建并且始终不销毁
- 3）采用延迟加载和缓存合用的方式，当第一次需要使用时创建，使用完后并不销毁，而是缓存起来，等待下一次使用，在合适的时候，由缓存框架销毁。
怎样选择？
- 1）如果进入的状态在运行时是不可知的，而且上下文是比较稳定的，不会经常改变状态，使用也不频繁，建议选第一种
- 2）如果状态改变很频繁，也即需要频繁地创建状态对象，而且状态对象还存储着大量的信息数据，建议选第二种
- 3）如果无法确定状态改变是否频繁，而且有些状态对象的状态数据量大，有些比较小，一切都是未知的，建议选第三种。
事实上，在实际工程开发中，第三种方案是首选，因为其兼顾了前面两种方案的优点，几乎能适应各种情况的需要。
第三种方案在实现时，需要一个合理的缓存框架，并且要考虑多线程并发问题，实现难道稍高。
另外在实现中可以考虑结合享元模式，通过享元模式来共享状态对象。
3.6 状态的维护和转换控制
状态的维护，指的是维护状态的数据，就是给状态设置不同的状态值。
状态的转换，指的是根据状态的变化来选择不同的状态处理对象。
在状态模式中，通常有两个地方可以进行状态的维护和转换控制。
-
1）在上下文中，因为状态本身通常被实现为上下文对象的状态，因此可以在上下文中进行状态维护，当然也就可以控制状态的转换而来。
-
2）另外一个地方就是在状态的处理类里，当每个状态处理对象处理完自身状态所对应的功能后，可以根据需要指定后继的状态，以便让应用能正确处理后续的请求。
public class VoteManager {
/**
* 记录当前每个用户对应的状态处理对象，每个用户当前的状态是不同的
* Map<String,VoteState>对应Map<用户名称,当前对应的状态处理对象>
*/
private Map<String,VoteState> mapState = new HashMap<String,VoteState>();
/**
* 记录用户投票的结果,Map<String,String>对应Map<用户名称,投票的选项>
*/
private Map<String,String> mapVote = new HashMap<String,String>();
/**
* 记录用户投票次数,Map<String,Integer>对应Map<用户名称,投票的次数>
*/
private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();
/**
* 获取记录用户投票结果的Map
* @return 记录用户投票结果的Map
*/
public Map<String, String> getMapVote() {
return mapVote;
}
/**
* 获取记录每个用户对应的状态处理对象的Map
* @return 记录每个用户对应的状态处理对象的Map
*/
public Map<String, VoteState> getMapState() {
return mapState;
}
/**
* 获取记录每个用户对应的投票次数的Map
* @return 记录每个用户对应的投票次数的Map
*/
public Map<String, Integer> getMapVoteCount() {
return mapVoteCount;
}
/**
* 投票
* @param user 投票人，为了简单，就是用户名称
* @param voteItem 投票的选项
*/
public void vote(String user,String voteItem){
//1：先为该用户增加投票的次数
//先从记录中取出已有的投票次数
Integer oldVoteCount = mapVoteCount.get(user);
if(oldVoteCount==null){
oldVoteCount = 0;
}
oldVoteCount = oldVoteCount + 1;
mapVoteCount.put(user, oldVoteCount);
//2：获取该用户的投票状态
VoteState state = mapState.get(user);
//如果没有投票状态，说明还没有投过票，就初始化一个正常投票状态
if(state==null){
state = new NormalVoteState();
}
//然后转调状态对象来进行相应的操作
state.vote(user, voteItem, this);
}
}
public class RepeatVoteState implements VoteState{
public void vote(String user, String voteItem, VoteManager voteManager) {
//重复投票
//暂时不做处理
System.out.println("请不要重复投票");
//重复投票完成，维护下一个状态，重复投票到5次，就算恶意投票了
//注意这里是判断大于等于4，因为这里设置的是下一个状态
//下一个操作次数就是5了，就应该算是恶意投票了
if(voteManager.getMapVoteCount().get(user) >= 4){
voteManager.getMapState().put(user, new SpiteVoteState());
}
}
}
如何选择这两种方式？
- 1）一般情况下，如果状态转换的规则是一定的，一般不需要进行什么扩展规则，则适合在上下文中统一进行状态的维护
- 2）如果状态的转换取决于前一个状态动态处理的结果，或者是依赖于外部数据，为了增强灵活性，这种情况下，一般是在状态处理类里面进行状态的维护。
3.6.1 使用数据库来维护状态
在实际开发中，可以使用数据库来维护状态。在数据库中存储下一个状态的识别数据。也即，维护下一个状态，演化成了维护下一个状态的识别数据，比如状态编码。
在程序中，通过查询数据库中的数据来得到状态编码，然后再根据状态编码来创建出相应的状态对象，然后再委托相应的状态对象进行功能处理。
还有一种情况是直接将“转移”记录到数据库中，这样更灵活。
public class VoteManager {
/**
* 记录当前每个用户对应的状态处理对象，每个用户当前的状态是不同的
* Map<String,VoteState>对应Map<用户名称,当前对应的状态处理对象>
*/
private Map<String,VoteState> mapState = new HashMap<String,VoteState>();
/**
* 获取记录每个用户对应的状态处理对象的Map
* @return 记录每个用户对应的状态处理对象的Map
*/
public Map<String, VoteState> getMapState() {
return mapState;
}
/**
* 记录用户投票的结果,Map<String,String>对应Map<用户名称,投票的选项>
*/
private Map<String,String> mapVote = new HashMap<String,String>();
/**
* 记录用户投票次数,Map<String,Integer>对应Map<用户名称,投票的次数>
*/
private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();
/**
* 获取记录用户投票结果的Map
* @return 记录用户投票结果的Map
*/
public Map<String, String> getMapVote() {
return mapVote;
}
/**
* 获取记录每个用户对应的投票次数的Map
* @return 记录每个用户对应的投票次数的Map
*/
public Map<String, Integer> getMapVoteCount() {
return mapVoteCount;
}
/**
* 投票
* @param user 投票人，为了简单，就是用户名称
* @param voteItem 投票的选项
*/
public void vote(String user,String voteItem)throws Exception{
//1：先为该用户增加投票的次数
//先从记录中取出已有的投票次数
Integer oldVoteCount = mapVoteCount.get(user);
if(oldVoteCount==null){
oldVoteCount = 0;
}
oldVoteCount = oldVoteCount + 1;
mapVoteCount.put(user, oldVoteCount);
VoteState state = null;
//2：直接从数据库获取该用户对应的下一个状态的状态编码
String stateId = "从数据库中获取这个值";
//开始根据状态编码来创建需用的状态对象
//根据状态编码去获取相应的类
String className = "根据状态编码去获取相应的类";
//使用反射创建对象实例，简单示意一下
Class c = Class.forName(className);
state = (VoteState)c.newInstance();
// if("正常投票".equals(stateId)){
// state = new NormalVoteState();
// }else if("重复投票".equals(stateId)){
// state = new RepeatVoteState();
// }else if("恶意投票".equals(stateId)){
// state = new SpiteVoteState();
// }else if("黑名单".equals(stateId)){
// state = new BlackVoteState();
// }
//然后转调状态对象来进行相应的操作
state.vote(user, voteItem, this);
}
}
3.7 模拟工作流
对于工作流，复杂的应用可能会使用工作流中间件，用工作流引擎来负责流程处理，会比较复杂。其实工作流引擎的实现也可以应用上状态模式。
简单点的，把流程数据存放在数据库里面，然后在程序进行流程控制。对于简单的业务流程控制，可以使用状态模式来辅助进行流程控制，因为大部分这种流程都是状态控制的。
-
请假流程实例
上面流程大致有如下状态：等待项目经理审核、等待部门经理审核、审核结束。
特别注意，使用Scanner进行测试时，不能用Junit框架，需要使用main函数才能进行测试。
example4代码参考github
public static void main(String[] args) {
//创建业务对象，并设置业务数据
LeaveRequestModel lrm = new LeaveRequestModel();
lrm.setUser("小李");
lrm.setBeginDate("2010-02-08");
lrm.setLeaveDays(5);
//创建上下文对象
LeaveRequestContext request = new LeaveRequestContext();
//为上下文对象设置业务数据对象
request.setBusinessVO(lrm);
//配置上下文，作为开始的状态，以后就不管了
request.setState(new ProjectManagerState());
//请求上下文，让上下文开始处理工作
request.doWork();
}
public class ProjectManagerState implements LeaveRequestState{
public void doWork(StateMachine request) {
//先把业务对象造型回来
LeaveRequestModel lrm = (LeaveRequestModel)request.getBusinessVO();
System.out.println("项目经理审核中，请稍候......");
//模拟用户处理界面，通过控制台来读取数据
System.out.println(lrm.getUser()+"申请从"+lrm.getBeginDate()+
"开始请假"+lrm.getLeaveDays()+"天,请项目经理审核(1为同意，2为不同意)：");
//读取从控制台输入的数据
Scanner scanner = new Scanner(System.in);
if(scanner.hasNext()){
int a = scanner.nextInt();
//设置回到上下文中
String result = "不同意";
if(a==1){
result = "同意";
}
lrm.setResult("项目经理审核结果："+result);
//根据选择的结果和条件来设置下一步
if(a==1){
if(lrm.getLeaveDays() > 3){
//如果请假天数大于3天，而且项目经理同意了，就提交给部门经理
request.setState(new DepManagerState());
//继续执行下一步工作
request.doWork();
}else{
//3天以内的请假，由项目经理做主,就不用提交给部门经理了，转向审核结束状态
request.setState(new AuditOverState());
//继续执行下一步工作
request.doWork();
}
}else{
//项目经理要是不同意的话，也就不用提交给部门经理了，转向审核结束状态
request.setState(new AuditOverState());
//继续执行下一步工作
request.doWork();
}
}
}
}
4.思考状态模式
状态模式的优缺点
简化应用逻辑控制；
更好地分离状态和行为；
更好地扩展性；
显式化进行状态转换；
引入太多的状态类。状态模式的本质
根据状态来分离和选择行为。何时选用状态模式
1）如果一个对象的行为取决它的状态，而且它必须在运行时刻根据状态来改变它的行为。可以使用状态模式，来把状态和行为分离开，虽然分离开，但状态和行为是有对应关系的，可以在运行期间，通过改变状态，就能够调用到该状态对应的状态处理对象上去，从而改变对象的行为。
2）如果一个操作中含有庞大的分支语句，而且这些分支依赖于该对象的状态。可以使用状态模式，把各个分支的处理分散包装到单独的对象处理类里面，这样，这些分支对应的对象就可以不依赖于其他对象而独立变化。
