状态模式

现在有一个这样的场景。

 

对于TCP的连接，大家都知道，TCP是面向连接的一种通信方式，那么他有三种基本的状态

1：等待连接  2：连接   3：断开

那么每一个TCP都有这样三种操作，但是等等...如果一个TCP已经在连接状态了，那么它还能连接？？显然不能，每一个TCP通信在一种状态下面只能有一种连接方式。

 

它的关系应当是这样的：在等待状态下只能进行连接，连接完后把状态改成连接状态，连接状态只能进行断开操作，然后改状态为断开，然后依次可以循环下去。那么怎么来实现这样一个操作呢？

这就要用到状态模式，在不同的状态下进行合适的操作正是为了解决这样的问题而存在的。

 

状态模式的定义：当一个对象内在改变时允许其改变行为，这个对象看起来像改变了其类。

 

这个模式有三个角色：

State ：接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。

ConcreteState : 具体状态角色，本状态有两个职责，本状态的行为管理以及趋向状态处理，通俗的说，就是本状态下要做的事情，以及本状态如何过渡到其他状态。

Context : 环境角色，定义客户端需要的接口，并且负责具体状态的切换。

 

那么我们来实现一下以TCP连接的状态模式。

 

package com.gengu.状态模式;

/**
 * 状态类
 * 以TCP为例
 * 等待状态 连接状态  断开状态
 * 等待->断开->连接->等待
 * */

public abstract class State {

	/**定义上下文类用他来规定状态该怎么切换*/
	protected Context context;

	public void setContext(Context context) {
		this.context = context;
	}
	
	//等待
	public abstract void wait1();
	//连接
	public abstract void link();
	//断开
	public abstract void stop();
	
}

 

package com.gengu.状态模式;

public class StateLink extends State{

	@Override
	public void link() {
		System.out.println("状态不正确，不允许操作");
	}

	@Override
	public void stop() {
		System.out.println("现在是连接状态，可以操作，将状态转为关闭状态");
		//把当前状态给他
		super.context.setCurrentState(Context.STOP_STATE);
	}

	@Override
	public void wait1() {
		System.out.println("状态不正确，不允许操作");
	}
}

 

package com.gengu.状态模式;

public class StateStop extends State{

	@Override
	public void link() {
		System.out.println("状态不正确，不允许操作");
	}

	@Override
	public void stop() {
		System.out.println("状态不正确，不允许操作");
	}

	@Override
	public void wait1() {
		System.out.println("现在是停止状态，可以操作，将转为等待状态");
		super.context.setCurrentState(Context.WAIT_STATE);
	}
}

 

package com.gengu.状态模式;

public class StateWait extends State{

	@Override
	public void link() {
		System.out.println("状态正确，可以操作，将状态转为连接状态");
		//把当前状态给他
		super.context.setCurrentState(Context.STOP_STATE);
	}

	@Override
	public void stop() {
		System.out.println("状态不正确，不允许操作");
	}

	@Override
	public void wait1() {
		System.out.println("状态不正确，不允许操作");
	}
}

 

package com.gengu.状态模式;

/**
 * 只负责这个类的具体状态切换
 * */
public class Context {

	//连接
	public final static State LINK_STATE = new StateLink();
	//断开
	public final static State STOP_STATE = new StateStop();
	//等待
	public final static State WAIT_STATE = new StateWait();
	
	//当前状态
	public State currentState ;

	public State getCurrentState() {
		return currentState;
	}

	public void setCurrentState(State currentState) {
		this.currentState = currentState;
		this.currentState.setContext(this);
	}
	
	//连接
	public void link(){
		this.currentState.link();
	}
	//关闭
	public void stop(){
		this.currentState.stop();
	}
	//等待
	public void wait1(){
		this.currentState.wait1();
	}
}

 

package com.gengu.状态模式;

public class Client {

	public static void main(String[] args) {
		Context context = new Context();
		context.setCurrentState(Context.STOP_STATE);
		context.wait1();
		context.link();
		context.link();
	}
}

 

这样可以让我们的场景类变得非常容易实现。

 

 

评论

3 楼 firemaster 2013-07-31  

靠！不能修改自己发表过的评论么？

2 楼 firemaster 2013-07-31  

StateWait类的link函数一行代码写错了。

package com.gengu.状态模式;

public class StateWait extends State{

	@Override
	public void link() {
		System.out.println("状态正确，可以操作，将状态转为连接状态");
		//把当前状态给他
		super.context.setCurrentState(

Context.STOP_STATE

);
	}

	@Override
	public void stop() {
		System.out.println("状态不正确，不允许操作");
	}

	@Override
	public void wait1() {
		System.out.println("状态不正确，不允许操作");
	}
}

1 楼 firemaster 2013-07-31  

StateWait类的link函数一行代码写错了。

package com.gengu.状态模式;  
  
public class StateWait extends State{  
  
    @Override  
    public void link() {  
        System.out.println("状态正确，可以操作，将状态转为连接状态");  
        //把当前状态给他  
        super.context.setCurrentState([color=red][i]Context.LINK_STATE[/i][/color]);  
    }  
  
    @Override  
    public void stop() {  
        System.out.println("状态不正确，不允许操作");  
    }  
  
    @Override  
    public void wait1() {  
        System.out.println("状态不正确，不允许操作");  
    }  
}