Comment mettre en œuvre une FSM - Machine D'état fini en Java

Hmm, je suggère que vous utilisez Flyweight pour mettre en œuvre les États. Objectif: éviter la mémoire aérienne d'un grand nombre de petits objets. Les machines d'état peuvent devenir très, très grandes.

http://en.wikipedia.org/wiki/Flyweight_pattern

Je ne suis pas sûr de voir la nécessité d'utiliser l'État design pattern pour implémenter les noeuds. Les nœuds dans une machine d'état sont apatrides. Ils correspondent juste le symbole d'entrée courant au transitions disponibles à partir de l'état actuel. C'est-à-dire, à moins que j'ai complètement oublié comment ils fonctionnent (ce qui est une possibilité certaine).

si je le codais, je ferais quelque chose comme ça:

interface FsmNode {
  public boolean canConsume(Symbol sym);
  public FsmNode consume(Symbol sym);
  // Other methods here to identify the state we are in
}

  List<Symbol> input = getSymbols();
  FsmNode current = getStartState();
  for (final Symbol sym : input) {
    if (!current.canConsume(sym)) {
      throw new RuntimeException("FSM node " + current + " can't consume symbol " + sym);
    }
    current = current.consume(sym);
  }
  System.out.println("FSM consumed all input, end state is " + current);

Que ferait Flyweight dans ce cas? Eh bien, sous le FsmNode il y aurait probablement quelque chose comme ceci:

Map<Integer, Map<Symbol, Integer>> fsm; // A state is an Integer, the transitions are from symbol to state number
FsmState makeState(int stateNum) {
  return new FsmState() {
    public FsmState consume(final Symbol sym) {
      final Map<Symbol, Integer> transitions = fsm.get(stateNum);
      if (transisions == null) {
        throw new RuntimeException("Illegal state number " + stateNum);
      }
      final Integer nextState = transitions.get(sym);  // May be null if no transition
      return nextState;
    }
    public boolean canConsume(final Symbol sym) {
      return consume(sym) != null;
    }
  }
}

cela crée les objets D'État sur une base de besoin-To-use, il vous permet d'utiliser un beaucoup mécanisme sous-jacent plus efficace pour stocker la machine d'état réelle. Celui que j'utilise ici (Map(Entier, la Carte(Symbole, Integer))) n'est pas particulièrement efficace.

notez que la page Wikipedia se concentre sur les cas où de nombreux objets quelque peu similaires partagent les mêmes données, comme c'est le cas dans L'implémentation de chaînes de caractères en Java. À mon avis, Flyweight est un peu plus général, et couvre toute création à la demande d'objets avec une courte durée de vie (utiliser plus de CPU pour économiser sur un plus structure de données sous-jacente efficace).

EasyFSM est une bibliothèque Java dynamique qui peut être utilisée pour implémenter une FSM.

vous pouvez trouver la documentation pour le même à : Machine D'état fini en Java

aussi, vous pouvez télécharger la bibliothèque à : Java FSM Library: DynamicEasyFSM

d'Envisager le facile, léger bibliothèque Java EasyFlow . De leurs docs:

avec EasyFlow vous pouvez:

• implémenter une logique complexe mais garder votre code simple et propre
• gérer les appels asynchrones avec facilité et élégance
• éviter la concurrence en utilisant une approche de programmation axée sur les événements
• éviter le débordement des piles erreur en évitant la récursion
• pour simplifier la conception, la programmation et les tests de complexe d'applications java

vous pouvez mettre en œuvre Machine D'état fini de deux façons différentes.

Option 1:

Machine à états finis avec un workflow prédéfini : recommandé si vous connaissez tous les États à l'avance et la machine d'état est presque fixe Sans aucun changement dans le futur

1. Identifier tous les possibles états dans votre application

2. identifiez tous les événements dans votre demande

3. identifiez toutes les conditions dans votre application, qui peuvent conduire à une transition d'état

4. de Survenance d'un événement qui peut provoquer des transitions d'état

5. construire une machine à état fini par décider d'un flux de travail des états et des transitions.

   E. g si un événement 1 se produit à L'état 1, l'état sera mis à jour et l'état de la machine peut encore être dans l'état 1.

   si un événement 2 se produit à L'état 1, le système passera de l'état 1 à l'état 2

   1519160920"

cette conception est basée sur État et contexte motifs.

regarder Finite State Machine prototype classes.

Option 2:

arbres comportementaux: recommandé en cas de changements fréquents dans le flux de travail de la machine d'état. Vous pouvez dynamiquement ajouter un nouveau comportement sans briser l'arbre.

le la classe de base Task fournit une interface pour toutes ces tâches, les leaf tasks sont ceux qui viennent d'être mentionnés, et les tâches parentes sont les noeuds intérieurs qui décident quelle tâche exécuter ensuite.

les tâches n'ont que la logique dont elles ont besoin pour réellement faire ce qui est exigé d'elles, toute la logique de décision de savoir si une tâche a commencé ou non, si elle doit être mise à jour, si elle a terminé avec succès, etc. être groupé dans la classe TaskController , et ajouté par composition.

les décorateurs sont des tâches qui" décorent " une autre classe en l'enveloppant et en lui donnant une logique supplémentaire.

enfin, la classe Blackboard est une classe appartenant à L'IA mère à laquelle chaque tâche fait référence. Il fonctionne comme une base de données de connaissances pour toutes les tâches leaf

Avoir un coup d'oeil à cet article par Jaime Barrachina Verdia pour plus de détails

j'ai conçu et implémenté un exemple simple de machine d'état fini avec java.

Ifinitestatmachine : l'interface publique pour gérer la machine d'état fini

comme ajouter de nouveaux États à la machine d'état fini ou le transit vers les états suivants par

actions spécifiques.

interface IFiniteStateMachine {
    void setStartState(IState startState);

    void setEndState(IState endState);

    void addState(IState startState, IState newState, Action action);

    void removeState(String targetStateDesc);

    IState getCurrentState();

    IState getStartState();

    IState getEndState();

    void transit(Action action);
}

IState : l'interface publique vers obtenir des informations relatives à l'état

comme le nom de l'état et les correspondances aux États connectés.

interface IState {
    // Returns the mapping for which one action will lead to another state
    Map<String, IState> getAdjacentStates();

    String getStateDesc();

    void addTransit(Action action, IState nextState);

    void removeTransit(String targetStateDesc);
}

Action : la classe qui provoquera la transition des États.

public class Action {
    private String mActionName;

    public Action(String actionName) {
        mActionName = actionName;
    }

    String getActionName() {
        return mActionName;
    }

    @Override
    public String toString() {
        return mActionName;
    }

}

StateImpl : la mise en œuvre de L'État. J'ai appliqué la structure de données telle que HashMap pour garder les mappages D'Action-État.

public class StateImpl implements IState {
    private HashMap<String, IState> mMapping = new HashMap<>();
    private String mStateName;

    public StateImpl(String stateName) {
        mStateName = stateName;
    }

    @Override
    public Map<String, IState> getAdjacentStates() {
        return mMapping;
    }

    @Override
    public String getStateDesc() {
        return mStateName;
    }

    @Override
    public void addTransit(Action action, IState state) {
        mMapping.put(action.toString(), state);
    }

    @Override
    public void removeTransit(String targetStateDesc) {
        // get action which directs to target state
        String targetAction = null;
        for (Map.Entry<String, IState> entry : mMapping.entrySet()) {
            IState state = entry.getValue();
            if (state.getStateDesc().equals(targetStateDesc)) {
                targetAction = entry.getKey();
            }
        }
        mMapping.remove(targetAction);
    }

}

Finitestatmachineimpl : Implementation of Ifinitestatmachine. J'utilise ArrayList pour garder tous les États.

public class FiniteStateMachineImpl implements IFiniteStateMachine {
    private IState mStartState;
    private IState mEndState;
    private IState mCurrentState;
    private ArrayList<IState> mAllStates = new ArrayList<>();
    private HashMap<String, ArrayList<IState>> mMapForAllStates = new HashMap<>();

    public FiniteStateMachineImpl(){}
    @Override
    public void setStartState(IState startState) {
        mStartState = startState;
        mCurrentState = startState;
        mAllStates.add(startState);
        // todo: might have some value
        mMapForAllStates.put(startState.getStateDesc(), new ArrayList<IState>());
    }

    @Override
    public void setEndState(IState endState) {
        mEndState = endState;
        mAllStates.add(endState);
        mMapForAllStates.put(endState.getStateDesc(), new ArrayList<IState>());
    }

    @Override
    public void addState(IState startState, IState newState, Action action) {
        // validate startState, newState and action

        // update mapping in finite state machine
        mAllStates.add(newState);
        final String startStateDesc = startState.getStateDesc();
        final String newStateDesc = newState.getStateDesc();
        mMapForAllStates.put(newStateDesc, new ArrayList<IState>());
        ArrayList<IState> adjacentStateList = null;
        if (mMapForAllStates.containsKey(startStateDesc)) {
            adjacentStateList = mMapForAllStates.get(startStateDesc);
            adjacentStateList.add(newState);
        } else {
            mAllStates.add(startState);
            adjacentStateList = new ArrayList<>();
            adjacentStateList.add(newState);
        }
        mMapForAllStates.put(startStateDesc, adjacentStateList);

        // update mapping in startState
        for (IState state : mAllStates) {
            boolean isStartState = state.getStateDesc().equals(startState.getStateDesc());
            if (isStartState) {
                startState.addTransit(action, newState);
            }
        }
    }

    @Override
    public void removeState(String targetStateDesc) {
        // validate state
        if (!mMapForAllStates.containsKey(targetStateDesc)) {
            throw new RuntimeException("Don't have state: " + targetStateDesc);
        } else {
            // remove from mapping
            mMapForAllStates.remove(targetStateDesc);
        }

        // update all state
        IState targetState = null;
        for (IState state : mAllStates) {
            if (state.getStateDesc().equals(targetStateDesc)) {
                targetState = state;
            } else {
                state.removeTransit(targetStateDesc);
            }
        }

        mAllStates.remove(targetState);

    }

    @Override
    public IState getCurrentState() {
        return mCurrentState;
    }

    @Override
    public void transit(Action action) {
        if (mCurrentState == null) {
            throw new RuntimeException("Please setup start state");
        }
        Map<String, IState> localMapping = mCurrentState.getAdjacentStates();
        if (localMapping.containsKey(action.toString())) {
            mCurrentState = localMapping.get(action.toString());
        } else {
            throw new RuntimeException("No action start from current state");
        }
    }

    @Override
    public IState getStartState() {
        return mStartState;
    }

    @Override
    public IState getEndState() {
        return mEndState;
    }
}

exemple :

public class example {

    public static void main(String[] args) {
        System.out.println("Finite state machine!!!");
        IState startState = new StateImpl("start");
        IState endState = new StateImpl("end");
        IFiniteStateMachine fsm = new FiniteStateMachineImpl();
        fsm.setStartState(startState);
        fsm.setEndState(endState);
        IState middle1 = new StateImpl("middle1");
        middle1.addTransit(new Action("path1"), endState);
        fsm.addState(startState, middle1, new Action("path1"));
        System.out.println(fsm.getCurrentState().getStateDesc());
        fsm.transit(new Action(("path1")));
        System.out.println(fsm.getCurrentState().getStateDesc());
        fsm.addState(middle1, endState, new Action("path1-end"));
        fsm.transit(new Action(("path1-end")));
        System.out.println(fsm.getCurrentState().getStateDesc());
        fsm.addState(endState, middle1, new Action("path1-end"));
    }

}

exemple complet sur Github