DOCSEARCHbyAlgolia
Submit Docs

spring-statemachine

repository·main·Indexed 23 days ago

https://github.com/spring-attic/spring-statemachine

Repository for spring-statemachine, including instructions for setting up and running Jepsen tests using Leiningen and Zookeeper, and documentation for various web samples including STOMP Over WebSocket examples and integrated libraries such as AngularJS, AngularJS-Toaster, and Flat UI.

Tokens
65.8K
Snippets
100
Records
494
Agent score
82%

What's inside spring-statemachine

  1. Overview of Spring Statemachine features

    main

    Spring Statemachine (SSM) is a framework designed to integrate traditional state machine concepts into Spring applications. It allows developers to manage complex application logic by defining a finite number of states and the rules for transitioning between them.

    Key features include:

    • Flat State Machines: Simple, one-level state configurations for straightforward use cases.
    • Hierarchical State Machines: Support for nested state structures to manage complexity.
    • State Machine Regions: Support for even more advanced, multi-dimensional state configurations.
    • Core Logic Components: Use of triggers, transitions, guards, and actions to define behavior.
    • Type-safe Configuration: A configuration adapter that ensures type safety during setup.
    • Event Listeners: Ability to listen to state machine lifecycle events.
    • Spring IoC Integration: Seamless association of Spring beans with the state machine.

  4. Explore Spring Statemachine sample projects

    main

    The spring-statemachine-samples directory contains various implementations demonstrating different use cases, configurations, and integrations. Each sample is a standalone Spring Boot project.

    Key sample topics include:

    • Core Logic: Turnstile, CD Player, Washer
    • Reactive Programming: Turnstile Reactive
    • Persistence: Data JPA, Data Persist, Zookeeper, Multi-persist patterns
    • Integrations: Web, Security, Event Service, Monitoring, Order Shipping
    • Advanced Patterns: Tasks, Scope, Deploy

  5. What is vjs.SeekHandle?

    main

    The vjs.SeekHandle is a specialized UI component in Video.js that represents the playhead. Its primary functions are:

    1. Visual Feedback: It indicates the current playback position within the video timeline.
    2. User Interaction: It allows users to seek to different parts of the video by dragging the handle along the progress bar.

    It is defined in src/js/control-bar/progress-control.js and inherits its core functionality from vjs.SliderHandle.

  7. What is vjs.TextTrackMenuItem?

    main
    In Video.js, vjs.TextTrackMenuItem is the specific UI component used to represent a language choice within a text track menu. When a user interacts with a text track menu (like a subtitle selector), each available language is represented by an instance of this class. It inherits from vjs.MenuItem, meaning it behaves like a standard menu item but is contextually aware of text track selection.

  8. What is a vjs.Component?

    main

    A vjs.Component is the base UI class in Video.js. Components are embeddable UI objects that exist simultaneously as a JavaScript object and a corresponding element in the DOM.

    Key characteristics:

    • Hierarchy: Components can be nested, acting as parents or children to other components.
    • Event Emitters: Components inherit event-driven capabilities, allowing them to listen for and trigger events (e.g., 'click').
    // adding a button to the player
var button = player.addChild('button');
button.el(); // -> button element

// Components are also event emitters
button.on('click', function(){
  console.log('Button Clicked!');
});

button.trigger('customevent');

  10. How Video.js UI components work

    main

    The Video.js player uses a custom UI component architecture where the videojs.Component class serves as the base for all player and control classes. This hierarchical structure allows for building complex user interfaces by nesting child components within parent components. When a child component is added, its associated DOM element is automatically inserted into the parent's DOM element.

    // Example of component inheritance hierarchy
videojs.Control = videojs.Component.extend();
videojs.Button = videojs.Control.extend();
videojs.PlayToggle = videojs.Button.extend();

  11. Configure Pseudo States (Initial, Terminate, History, Choice, Junction, Fork, Join)

    main

    Pseudo states provide specialized logic for state machine flow:

    • Initial State: Use initial() to mark a starting state. This can also be used to run an initializing action that runs only once when the machine starts.
    • Terminate State: Use end() to mark a state as a final state. You can have at most one per sub-machine or region.
    • State History: Use history() to define a history state (either History.SHALLOW or History.DEEP). You can optionally define a default transition from the history state into a specific state.
    • Choice State: Use choice() to define a state that acts as an if/elseif/else block. Configure it using withChoice() with a first/then/last structure. first and then can include guards.
    • Junction State: Similar to Choice, but theoretically allows multiple incoming transitions. Use junction() and withJunction() with first/then/last.
    • Fork State: Use fork() to split a single transition into multiple parallel regions. The target must be a super state or an immediate state in a region.
    • Join State: Use join() to merge multiple parallel regions back into a single flow. You can select a target state that is reached once all source states (or end states of a region) are joined.
    • Exit and Entry Points: Use withEntry() and withExit() to define controlled entry and exit points for sub-machines.

  12. Listen to State Machine events via Application Context

    main

    You can react to state machine changes by listening to Spring Application Context events. These events are published via StateMachineEventPublisher. If you use @EnableStateMachine, these events are enabled by default.

    Common event classes include:

    • OnTransitionStartEvent
    • OnTransitionEvent
    • OnTransitionEndEvent
    • OnStateExitEvent
    • OnStateEntryEvent
    • OnStateChangedEvent
    • OnStateMachineStart
    • OnStateMachineStop
    • (and others extending StateMachineEvent)

    You can implement these using a standard Spring ApplicationListener.

    include::samples/DocsConfigurationSampleTests.java[tags=snippetG]